it-swarm.com.de

Aufzeichnen der Konsolenausgabe einer .NET-Anwendung (C #)

Wie rufe ich eine Konsolenanwendung aus meiner .NET-Anwendung auf und erfasse alle in der Konsole generierten Ausgaben?

(Denken Sie daran, dass ich die Informationen nicht zuerst in einer Datei speichern und dann erneut auflisten möchte, da ich sie gerne als Live-Informationen erhalten würde.)

119
Gripsoft

Dies kann mit der Eigenschaft ProcessStartInfo.RedirectStandardOutput auf einfache Weise erreicht werden. Ein vollständiges Beispiel ist in der verknüpften MSDN-Dokumentation enthalten. Die einzige Einschränkung ist, dass Sie möglicherweise auch den Standardfehlerstrom umleiten müssen, um alle Ausgaben Ihrer Anwendung zu sehen.

Process compiler = new Process();
compiler.StartInfo.FileName = "csc.exe";
compiler.StartInfo.Arguments = "/r:System.dll /out:sample.exe stdstr.cs";
compiler.StartInfo.UseShellExecute = false;
compiler.StartInfo.RedirectStandardOutput = true;
compiler.Start();    

Console.WriteLine(compiler.StandardOutput.ReadToEnd());

compiler.WaitForExit();
155
mdb

Dies ist eine geringfügige Verbesserung gegenüber der akzeptierten Antwort von @mdb. Insbesondere erfassen wir auch die Fehlerausgabe des Prozesses. Darüber hinaus erfassen wir diese Ausgaben über Ereignisse, da ReadToEnd () nicht funktioniert, wenn Sie beide Fehler- und reguläre Ausgaben erfassen möchten. Ich habe einige Zeit gebraucht, um diese Funktion auszuführen, da BeginxxxReadLine () nach Start () aufgerufen werden muss.

using System.Diagnostics;

Process process = new Process();

void LaunchProcess()
{
    process.EnableRaisingEvents = true;
    process.OutputDataReceived += new System.Diagnostics.DataReceivedEventHandler(process_OutputDataReceived);
    process.ErrorDataReceived += new System.Diagnostics.DataReceivedEventHandler(process_ErrorDataReceived);
    process.Exited += new System.EventHandler(process_Exited);

    process.StartInfo.FileName = "some.exe";
    process.StartInfo.Arguments = "param1 param2"
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardError = true;
    process.StartInfo.RedirectStandardOutput = true;

    process.Start();
    process.BeginErrorReadLine();
    process.BeginOutputReadLine();          

    //below line is optional if we want a blocking call
    //process.WaitForExit();
}

void process_Exited(object sender, EventArgs e)
{
    Console.WriteLine(string.Format("process exited with code {0}\n", process.ExitCode.ToString()));
}

void process_ErrorDataReceived(object sender, DataReceivedEventArgs e)
{
    Console.WriteLine(e.Data + "\n");
}

void process_OutputDataReceived(object sender, DataReceivedEventArgs e)
{
    Console.WriteLine(e.Data + "\n");
}
28
Shital Shah

Verwenden Sie ProcessInfo.RedirectStandardOutput , um die Ausgabe beim Erstellen Ihres Konsolenprozesses umzuleiten.

Dann können Sie Process.StandardOutput verwenden, um die Programmausgabe zu lesen.

Der zweite Link enthält einen Beispielcode.

13
Franci Penov

ConsoleAppLauncher ist eine Open Source-Bibliothek, die speziell für die Beantwortung dieser Frage entwickelt wurde. Es erfasst alle in der Konsole generierten Ausgaben und bietet eine einfache Oberfläche zum Starten und Schließen der Konsolenanwendung.

Das ConsoleOutput-Ereignis wird jedes Mal ausgelöst, wenn von der Konsole eine neue Zeile in die Standard-/Fehlerausgabe geschrieben wird. Die Zeilen werden in die Warteschlange gestellt und folgen garantiert der Ausgabereihenfolge.

Auch verfügbar als NuGet-Paket .

Beispielaufruf für die vollständige Konsolenausgabe:

// Run simplest Shell command and return its output.
public static string GetWindowsVersion()
{
    return ConsoleApp.Run("cmd", "/c ver").Output.Trim();
}

Probe mit Live-Feedback:

// Run ping.exe asynchronously and return roundtrip times back to the caller in a callback
public static void PingUrl(string url, Action<string> replyHandler)
{
    var regex = new Regex("(time=|Average = )(?<time>.*?ms)", RegexOptions.Compiled);
    var app = new ConsoleApp("ping", url);
    app.ConsoleOutput += (o, args) =>
    {
        var match = regex.Match(args.Line);
        if (match.Success)
        {
            var roundtripTime = match.Groups["time"].Value;
            replyHandler(roundtripTime);
        }
    };
    app.Run();
}
7
SlavaGu

Hinzugefügt process.StartInfo.**CreateNoWindow** = true; und timeout.

private static void CaptureConsoleAppOutput(string exeName, string arguments, int timeoutMilliseconds, out int exitCode, out string output)
{
    using (Process process = new Process())
    {
        process.StartInfo.FileName = exeName;
        process.StartInfo.Arguments = arguments;
        process.StartInfo.UseShellExecute = false;
        process.StartInfo.RedirectStandardOutput = true;
        process.StartInfo.CreateNoWindow = true;
        process.Start();

        output = process.StandardOutput.ReadToEnd();

        bool exited = process.WaitForExit(timeoutMilliseconds);
        if (exited)
        {
            exitCode = process.ExitCode;
        }
        else
        {
            exitCode = -1;
        }
    }
}
2
Sergei Zinovyev

Ich habe dem O2 Platform (Open Source-Projekt) eine Reihe von Hilfsmethoden hinzugefügt, mit denen Sie auf einfache Weise eine Interaktion mit einem anderen Prozess über die Konsolenausgabe und -eingabe skripten können (siehe http://code.google.com/p/o2platform/source/browse/trunk/O2_Scripts/APIs/Windows/CmdExe/CmdExeAPI.cs )

Für Sie ist möglicherweise auch die API hilfreich, mit der die Konsolenausgabe des aktuellen Prozesses (in einem vorhandenen Steuerelement oder Popup-Fenster) angezeigt werden kann. Weitere Informationen finden Sie in diesem Blogbeitrag: http://o2platform.wordpress.com/2011/11/26/api_consoleout-cs-inprocess-capture-of-the-console-output/ (this blog Enthält auch Details, wie die Konsolenausgabe von neuen Prozessen verwendet werden kann.

2
Dinis Cruz

Von PythonTR - Python Programcıları Derneği, e-kitap, örnek:

Process p = new Process();   // Create new object
p.StartInfo.UseShellExecute = false;  // Do not use Shell
p.StartInfo.RedirectStandardOutput = true;   // Redirect output
p.StartInfo.FileName = "c:\\python26\\python.exe";   // Path of our Python compiler
p.StartInfo.Arguments = "c:\\python26\\Hello_C_Python.py";   // Path of the .py to be executed
1
livetogogo