Process.start: Wie erhält man die Ausgabe?

Question

Ich möchte ein externes Befehlszeilenprogramm von meiner Mono/.NET-Anwendung aus ausführen. Zum Beispiel würde ich gerne Folgendes ausführen mencoder . Ist es möglich:

1. Um die Ausgabe der Kommandozeile zu erhalten und sie in mein Textfeld zu schreiben?
2. Um den numerischen Wert für die Anzeige eines Fortschrittsbalkens mit der verstrichenen Zeit zu erhalten?

Answer 1

Wenn Sie Ihr Process-Objekt erstellen, legen Sie StartInfo entsprechend fest:

var proc = new Process 
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "program.exe",
        Arguments = "Befehlszeilenargumente für Ihr ausführbares Programm",
        UseShellExecute = false,
        RedirectStandardOutput = true,
        CreateNoWindow = true
    }
};

dann starten Sie den Prozess und lesen Sie daraus:

proc.Start();
while (!proc.StandardOutput.EndOfStream)
{
    string line = proc.StandardOutput.ReadLine();
    // etwas mit der Zeile machen
}

Sie können int.Parse() oder int.TryParse() verwenden, um die Zeichenfolgen in numerische Werte umzuwandeln. Möglicherweise müssen Sie zuerst einige Zeichenkettenmanipulationen durchführen, wenn ungültige numerische Zeichen in den gelesenen Zeichenfolgen vorhanden sind.

Answer 2

Sie können Ihre Ausgabe synchron oder asynchron verarbeiten.

1. Synchrone Beispiel

static void runCommand()
{
    Process process = new Process();
    process.StartInfo.FileName = "cmd.exe";
    process.StartInfo.Arguments = "/c DIR"; // Beachten Sie den /c Befehl (*)
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardOutput = true;
    process.StartInfo.RedirectStandardError = true;
    process.Start();
    //* Lesen Sie die Ausgabe (oder den Fehler)
    string output = process.StandardOutput.ReadToEnd();
    Console.WriteLine(output);
    string err = process.StandardError.ReadToEnd();
    Console.WriteLine(err);
    process.WaitForExit();
}

Hinweis, dass es besser ist, sowohl Ausgabe als auch Fehler zu verarbeiten: sie müssen getrennt behandelt werden.

(*) Für einige Befehle (hier StartInfo.Arguments) müssen Sie die /c Direktive hinzufügen, sonst friert der Prozess im WaitForExit() ein.

2. Asynchrone Beispiel

static void runCommand() 
{
    //* Erstellen Sie Ihren Prozess
    Process process = new Process();
    process.StartInfo.FileName = "cmd.exe";
    process.StartInfo.Arguments = "/c DIR";
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardOutput = true;
    process.StartInfo.RedirectStandardError = true;
    //* Setzen Sie Ihre Ausgabe- und Fehler- (asynchrone) Handler
    process.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);
    process.ErrorDataReceived += new DataReceivedEventHandler(OutputHandler);
    //* Starten Sie den Prozess und die Handler
    process.Start();
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();
    process.WaitForExit();
}

static void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine) 
{
    //* Bearbeiten Sie die Ausgabe (schreiben Sie in Konsole/Log/StringBuilder)
    Console.WriteLine(outLine.Data);
}

Wenn Sie keine komplizierten Operationen mit der Ausgabe durchführen müssen, können Sie die OutputHandler-Methode umgehen, indem Sie die Handler direkt in der Zeile hinzufügen:

//* Setzen Sie Ihre Ausgabe- und Fehler- (asynchrone) Handler
process.OutputDataReceived += (s, e) => Console.WriteLine(e.Data);
process.ErrorDataReceived += (s, e) => Console.WriteLine(e.Data);

Answer 3

Gut, für alle, die sowohl Fehler als auch Ausgaben lesen möchten, aber mit einer der Lösungen, die in anderen Antworten (wie bei mir) angegeben sind, Deadlocks haben, hier ist eine Lösung, die ich nach dem Lesen der MSDN-Erklärung für die StandardOutput-Eigenschaft erstellt habe.

Die Antwort basiert auf T30's Code:

static void runCommand()
{
    //* Erstellen Sie Ihren Prozess
    Process process = new Process();
    process.StartInfo.FileName = "cmd.exe";
    process.StartInfo.Arguments = "/c DIR";
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardOutput = true;
    process.StartInfo.RedirectStandardError = true;
    //* Setzen Sie HIER NUR einen Handler.
    process.ErrorDataReceived += new DataReceivedEventHandler(ErrorOutputHandler);
    //* Starten Sie den Prozess
    process.Start();
    //* Lesen Sie ein Element asynchron
    process.BeginErrorReadLine();
    //* Lesen Sie das andere synchron
    string output = process.StandardOutput.ReadToEnd();
    Console.WriteLine(output);
    process.WaitForExit();
}

static void ErrorOutputHandler(object sendingProcess, DataReceivedEventArgs outLine) 
{
    //* Verarbeiten Sie die Ausgabe (Schreiben in Konsole/Log/StringBuilder)
    Console.WriteLine(outLine.Data);
}

Answer 4

Die standardmäßige .NET-Methode, dies zu tun, besteht darin, aus dem StandardOutput-Stream des Prozesses zu lesen. Ein Beispiel hierzu finden Sie in der verknüpften MSDN-Dokumentation. Ebenso können Sie aus dem StandardError lesen und in StandardInput schreiben.

Answer 5

1. Es ist möglich, die Ausgabe der Befehlszeilenshell eines Prozesses wie hier beschrieben zu erhalten: http://www.c-sharpcorner.com/UploadFile/edwinlima/SystemDiagnosticProcess12052005035444AM/SystemDiagnosticProcess.aspx

2. Dies hängt von mencoder ab. Wenn es diesen Status in der Befehlszeile ausgibt, dann ja :)