Process.StandardOutput Eigenschaft

Definition

Namespace:

System.Diagnostics

Assembly:

System.Diagnostics.Process.dll

Quelle:

Process.cs

Ruft einen Stream ab, der dazu verwendet wird, die Textausgabe der Anwendung zu lesen.

public:
 property System::IO::StreamReader ^ StandardOutput { System::IO::StreamReader ^ get(); };

public System.IO.StreamReader StandardOutput { get; }

member this.StandardOutput : System.IO.StreamReader

Public ReadOnly Property StandardOutput As StreamReader

Eigenschaftswert

StreamReader

Ein StreamReader zum Lesen des Standardausgabestreams der Anwendung.

Ausnahmen

InvalidOperationException

Der StandardOutput-Stream wurde nicht für die Umleitung definiert. Stellen Sie sicher, dass RedirectStandardOutput auf true und UseShellExecute auf false festgelegt ist.

- oder -

Der StandardOutput-Stream wurde für asynchrone Lesevorgänge mit BeginOutputReadLine() geöffnet.

Beispiele

Im folgenden Beispiel wird der Befehl ipconfig.exe ausgeführt und die Standardausgabe an das Konsolenfenster des Beispiels weitergeleitet.

using namespace System;
using namespace System::IO;
using namespace System::Diagnostics;

int main()
{
    Process^ process = gcnew Process();
    process->StartInfo->FileName = "ipconfig.exe";
    process->StartInfo->UseShellExecute = false;
    process->StartInfo->RedirectStandardOutput = true;
    process->Start();

    // Synchronously read the standard output of the spawned process-> 
    StreamReader^ reader = process->StandardOutput;
    String^ output = reader->ReadToEnd();

    // Write the redirected output to this application's window.
    Console::WriteLine(output);

    process->WaitForExit();
    process->Close();

    Console::WriteLine("\n\nPress any key to exit");
    Console::ReadLine();
    return 0;
}

using System;
using System.IO;
using System.Diagnostics;

class StandardOutputExample
{
    public static void Main()
    {
        using (Process process = new Process())
        {
            process.StartInfo.FileName = "ipconfig.exe";
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardOutput = true;
            process.Start();

            // Synchronously read the standard output of the spawned process.
            StreamReader reader = process.StandardOutput;
            string output = reader.ReadToEnd();

            // Write the redirected output to this application's window.
            Console.WriteLine(output);

            process.WaitForExit();
        }

        Console.WriteLine("\n\nPress any key to exit.");
        Console.ReadLine();
    }
}

Imports System.IO
Imports System.Diagnostics

Module Module1
    Sub Main()
        Using process As New Process()
            process.StartInfo.FileName = "ipconfig.exe"
            process.StartInfo.UseShellExecute = False
            process.StartInfo.RedirectStandardOutput = True
            process.Start()

            ' Synchronously read the standard output of the spawned process. 
            Dim reader As StreamReader = process.StandardOutput
            Dim output As String = reader.ReadToEnd()
            Console.WriteLine(output)

            process.WaitForExit()
        End Using

        Console.WriteLine(Environment.NewLine + Environment.NewLine + "Press any key to exit.")
        Console.ReadLine()
    End Sub
End Module

Hinweise

Wenn ein Process Text in seinen Standardstream schreibt, wird dieser Text normalerweise auf der Konsole angezeigt. Durch Umleitung des Datenstroms StandardOutput können Sie die Ausgabe eines Prozesses bearbeiten oder unterdrücken. Beispielsweise können Sie den Text filtern, anders formatieren oder die Ausgabe sowohl in die Konsole als auch in eine festgelegte Protokolldatei schreiben.

Hinweis

Um zu verwendenStandardOutput, müssen Sie auf falsefestlegenProcessStartInfo.UseShellExecute, und Sie müssen auf truefestlegenProcessStartInfo.RedirectStandardOutput. Andernfalls löst das Lesen aus dem StandardOutput Stream eine Ausnahme aus.

Der umgeleitete StandardOutput Stream kann synchron oder asynchron gelesen werden. Methoden wie Read, ReadLineund ReadToEnd führen synchrone Lesevorgänge für den Ausgabestream des Prozesses aus. Diese synchronen Lesevorgänge werden erst abgeschlossen, wenn die zugeordneten Process Schreibvorgänge in den StandardOutput Stream oder den Stream geschlossen werden.

Im Gegensatz dazu BeginOutputReadLine werden asynchrone Lesevorgänge für den StandardOutput Stream gestartet. Diese Methode aktiviert einen angegebenen Ereignishandler für die Streamausgabe und kehrt sofort an den Aufrufer zurück, der andere Arbeiten ausführen kann, während die Streamausgabe an den Ereignishandler weitergeleitet wird.

Synchrone Lesevorgänge führen eine Abhängigkeit zwischen dem Aufrufer, der aus dem StandardOutput Stream liest, und dem untergeordneten Prozess, der in diesen Stream schreibt. Diese Abhängigkeiten können zu Deadlockbedingungen führen. Wenn der Aufrufer aus dem umgeleiteten Stream eines untergeordneten Prozesses liest, ist er vom untergeordneten Prozess abhängig. Der Aufrufer wartet auf den Lesevorgang, bis das untergeordnete Element in den Stream schreibt oder den Stream schließt. Wenn der untergeordnete Prozess genügend Daten schreibt, um den umgeleiteten Stream zu füllen, ist er vom übergeordneten Prozess abhängig. Der untergeordnete Prozess wartet beim nächsten Schreibvorgang, bis das übergeordnete Element aus dem vollständigen Stream liest oder den Stream schließt. Die Deadlockbedingung ergibt sich, wenn aufrufer und untergeordneter Prozess aufeinander warten, um einen Vorgang abzuschließen, und beide können nicht fortgesetzt werden. Sie können Deadlocks vermeiden, indem Sie Abhängigkeiten zwischen dem Aufrufer und dem untergeordneten Prozess auswerten.

In den letzten beiden Beispielen in diesem Abschnitt wird die Start -Methode verwendet, um eine ausführbare Datei namens Write500Lines.exezu starten. Das folgende Beispiel enthält den Quellcode.

using System;
using System.IO;

public class Example3
{
   public static void Main()
   {
      for (int ctr = 0; ctr < 500; ctr++)
         Console.WriteLine($"Line {ctr + 1} of 500 written: {ctr + 1/500.0:P2}");

      Console.Error.WriteLine("\nSuccessfully wrote 500 lines.\n");
   }
}
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//'
//
//      Error stream: Successfully wrote 500 lines.

Imports System.IO

Public Module Example
   Public Sub Main()
      For ctr As Integer = 0 To 499
         Console.WriteLine($"Line {ctr + 1} of 500 written: {ctr + 1/500.0:P2}")
      Next

      Console.Error.WriteLine($"{vbCrLf}Successfully wrote 500 lines.{vbCrLf}")
   End Sub
End Module
' The example displays the following output:
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'
'
'      Error stream: Successfully wrote 500 lines.

Das folgende Beispiel zeigt, wie Sie aus einem umgeleiteten Stream lesen und warten, bis der untergeordnete Prozess beendet wird. Im Beispiel wird eine Deadlockbedingung vermieden, indem vor p.WaitForExitaufgerufen p.StandardOutput.ReadToEnd wird. Eine Deadlockbedingung kann auftreten, wenn der übergeordnete Prozess vor p.StandardOutput.ReadToEnd aufruft p.WaitForExit und der untergeordnete Prozess genügend Text schreibt, um den umgeleiteten Stream auszufüllen. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess beendet wird. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen StandardOutput Stream lesen kann.

using System;
using System.Diagnostics;

public class Example2
{
   public static void Main()
   {
      var p = new Process();  
      p.StartInfo.UseShellExecute = false;  
      p.StartInfo.RedirectStandardOutput = true;  
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

      // To avoid deadlocks, always read the output stream first and then wait.  
      string output = p.StandardOutput.ReadToEnd();  
      p.WaitForExit();

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'");
   }
}
// The example displays the following output:
//      Successfully wrote 500 lines.
//
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//      '

Imports System.Diagnostics'

Public Module Example
   Public Sub Main()
      Dim p As New Process()
      p.StartInfo.UseShellExecute = False  
      p.StartInfo.RedirectStandardOutput = True  
      p.StartInfo.FileName = "Write500Lines.exe"  
      p.Start() 

      ' To avoid deadlocks, always read the output stream first and then wait.  
      Dim output As String = p.StandardOutput.ReadToEnd()  
      p.WaitForExit()

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'")
   End Sub
End Module
' The example displays the following output:
'      Successfully wrote 500 lines.
'
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'      '

Es gibt ein ähnliches Problem, wenn Sie den gesamten Text sowohl aus der Standardausgabe als auch aus den Standardfehlerdatenströmen lesen. Im folgenden Beispiel wird ein Lesevorgang für beide Streams ausgeführt. Es vermeidet die Deadlockbedingung, indem asynchrone Lesevorgänge für den StandardError Stream ausgeführt werden. Eine Deadlockbedingung ergibt sich, wenn der übergeordnete Prozess gefolgt von p.StandardError.ReadToEnd aufruft p.StandardOutput.ReadToEnd und der untergeordnete Prozess genügend Text schreibt, um seinen Fehlerdatenstrom auszufüllen. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess seinen StandardOutput Stream schließt. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen StandardError Stream lesen kann.

using System;
using System.Diagnostics;

public class Example
{
   public static void Main()
   {
      var p = new Process();  
      p.StartInfo.UseShellExecute = false;  
      p.StartInfo.RedirectStandardOutput = true;  
      string eOut = null;
      p.StartInfo.RedirectStandardError = true;
      p.ErrorDataReceived += new DataReceivedEventHandler((sender, e) => 
                                 { eOut += e.Data; });
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

      // To avoid deadlocks, use an asynchronous read operation on at least one of the streams.  
      p.BeginErrorReadLine();
      string output = p.StandardOutput.ReadToEnd();  
      p.WaitForExit();

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'");
      Console.WriteLine($"\nError stream: {eOut}");
   }
}
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//      '
//
//      Error stream: Successfully wrote 500 lines.

Imports System.Diagnostics

Public Module Example
   Public Sub Main()
      Dim p As New Process()  
      p.StartInfo.UseShellExecute = False  
      p.StartInfo.RedirectStandardOutput = True  
      Dim eOut As String = Nothing
      p.StartInfo.RedirectStandardError = True
      AddHandler p.ErrorDataReceived, Sub(sender, e) eOut += e.Data 
      p.StartInfo.FileName = "Write500Lines.exe"  
      p.Start()  

      ' To avoid deadlocks, use an asynchronous read operation on at least one of the streams.  
      p.BeginErrorReadLine()
      Dim output As String = p.StandardOutput.ReadToEnd()  
      p.WaitForExit()

      Console.WriteLine($"The last 50 characters in the output stream are:{vbCrLf}'{output.Substring(output.Length - 50)}'")
      Console.WriteLine($"{vbCrLf}Error stream: {eOut}")
   End Sub
End Module
' The example displays the following output:
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'      '
'
'      Error stream: Successfully wrote 500 lines.

Sie können asynchrone Lesevorgänge verwenden, um diese Abhängigkeiten und ihr Deadlockpotenzial zu vermeiden. Alternativ können Sie die Deadlockbedingung vermeiden, indem Sie zwei Threads erstellen und die Ausgabe jedes Datenstroms in einem separaten Thread lesen.

Hinweis

Sie können keine asynchronen und synchronen Lesevorgänge für einen umgeleiteten Stream kombinieren. Sobald der umgeleitete Stream eines im Process asynchronen oder synchronen Modus geöffnet wird, müssen sich alle weiteren Lesevorgänge für diesen Stream im gleichen Modus befinden. Folgen Sie BeginOutputReadLine beispielsweise nicht mit einem Aufruf von ReadLine im StandardOutput Stream oder umgekehrt. Sie können jedoch zwei verschiedene Streams in verschiedenen Modi lesen. Beispielsweise können Sie den StandardError Stream aufrufen BeginOutputReadLine und dann aufrufenReadLine.

Weitere Informationen

• StandardInput
• StandardError
• RedirectStandardOutput