Démarrer un processus de manière synchrone et "diffuser" la sortie

Question

Je cherche à démarrer un processus à partir de F #, attendre jusqu'à la fin, mais aussi lire progressivement.

Est-ce la bonne/meilleure façon de le faire? (Dans mon cas, je suis en train d'exécuter des commandes git, mais qui est tangente à la question)

let gitexecute (logger:string->unit) cmd = 
    let procStartInfo = new ProcessStartInfo(@"C:\Program Files\Git\bin\git.exe", cmd) 

    // Redirect to the Process.StandardOutput StreamReader. 
    procStartInfo.RedirectStandardOutput <- true 
    procStartInfo.UseShellExecute <- false; 

    // Do not create the black window. 
    procStartInfo.CreateNoWindow <- true; 

    // Create a process, assign its ProcessStartInfo and start it 
    let proc = new Process(); 
    proc.StartInfo <- procStartInfo; 
    proc.Start() |> ignore 

    // Get the output into a string 
    while not proc.StandardOutput.EndOfStream do 
     proc.StandardOutput.ReadLine() |> logger 

Ce que je ne comprends pas comment le proc.Start() peut retourner une valeur booléenne et aussi être assez asynchrone pour que je puisse sortir progressivement de la sortie.

Malheureusement, je n'ai pas un dépôt assez grand - ou lent la machine assez, pour être en mesure de dire ce que les choses se passent dans l'ordre ...

MISE À JOUR

J'ai essayé de Brian suggestion, et cela fonctionne.

Ma question était un peu vague. Mon incompréhension était que je supposais que Process.Start() renvoyait le succès du processus dans son ensemble, et pas seulement du 'Start', et donc je ne pouvais pas voir comment cela fonctionnerait.

Answer 1

Le code que vous avez écrit dans le formulaire que vous avez écrit est (presque) ok: process.Start lance le processus que vous spécifiez dans, bien, un autre processus, afin que vos flux de sortie se déroulent parallèlement à votre exécution de processus. Un problème cependant est que vous devriez lancer un appel à process.WaitForExit à la fin - le fait que le flux de sortie est fermé n'implique pas que ce processus soit terminé. Cependant, vous rencontrerez des problèmes de lecture synchronisée si vous essayez de lire à la fois stdout et stderr du processus: il n'y a aucun moyen de lire deux flux de manière synchrone et simultanée - vous serez bloqué si vous lisez stdout et que le processus écrit stderr et attend que vous consommiez sa sortie ou vice versa.

Pour la médiation, vous pouvez vous abonner à OutputDataRecieved et ErrorDataRecieved, comme ceci:

type ProcessResult = { exitCode : int; stdout : string; stderr : string } 

let executeProcess (exe,cmdline) = 
    let psi = new System.Diagnostics.ProcessStartInfo(exe,cmdline) 
    psi.UseShellExecute <- false 
    psi.RedirectStandardOutput <- true 
    psi.RedirectStandardError <- true 
    psi.CreateNoWindow <- true   
    let p = System.Diagnostics.Process.Start(psi) 
    let output = new System.Text.StringBuilder() 
    let error = new System.Text.StringBuilder() 
    p.OutputDataReceived.Add(fun args -> output.Append(args.Data) |> ignore) 
    p.ErrorDataReceived.Add(fun args -> error.Append(args.Data) |> ignore) 
    p.BeginErrorReadLine() 
    p.BeginOutputReadLine() 
    p.WaitForExit() 
    { exitCode = p.ExitCode; stdout = output.ToString(); stderr = error.ToString() } 

Vous pouvez aussi écrire quelque chose le long des lignes de:

async { 
    while true do 
     let! args = Async.AwaitEvent p.OutputDataReceived 
     ... 
} |> Async.StartImmediate 

pour F # -STYLE gestion des événements réactifs .