Process.StandardOutput Eigenschaft

Definition

Ruft einen Stream ab, der dazu verwendet wird, die Textausgabe der Anwendung zu lesen.Gets a stream used to read the textual output of the application.

public:
 property System::IO::StreamReader ^ StandardOutput { System::IO::StreamReader ^ get(); };
public System.IO.StreamReader StandardOutput { get; }
[System.ComponentModel.Browsable(false)]
public System.IO.StreamReader StandardOutput { get; }
member this.StandardOutput : System.IO.StreamReader
[<System.ComponentModel.Browsable(false)>]
member this.StandardOutput : System.IO.StreamReader
Public ReadOnly Property StandardOutput As StreamReader

Eigenschaftswert

StreamReader

Ein StreamReader zum Lesen des Standardausgabestreams der Anwendung.A StreamReader that can be used to read the standard output stream of the application.

Attribute

Ausnahmen

Der StandardOutput-Stream wurde nicht für die Umleitung definiert. Stellen Sie sicher, dass RedirectStandardOutput auf true und UseShellExecute auf false festgelegt ist.The StandardOutput stream has not been defined for redirection; ensure RedirectStandardOutput is set to true and UseShellExecute is set to false.

- oder --or- Der StandardOutput-Stream wurde für asynchrone Lesevorgänge mit BeginOutputReadLine() geöffnet.The StandardOutput stream has been opened for asynchronous read operations with BeginOutputReadLine().

Beispiele

Im folgenden Beispiel wird der ipconfig.exe Befehl ausgeführt und die Standardausgabe an das Konsolenfenster des Beispiels umgeleitet.The following example runs the ipconfig.exe command and redirects its standard output to the example's console window.

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 in der Konsole angezeigt.When a Process writes text to its standard stream, that text is normally displayed on the console. Wenn Sie den Stream umleiten StandardOutput , können Sie die Ausgabe eines Prozesses ändern oder unterdrücken.By redirecting the StandardOutput stream, you can manipulate or suppress the output of a process. Beispielsweise können Sie den Text filtern, ihn anders formatieren oder die Ausgabe in die Konsole und eine bestimmte Protokolldatei schreiben.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Hinweis

Um zu verwenden StandardOutput , müssen Sie ProcessStartInfo.UseShellExecute auf festlegen false , und Sie müssen ProcessStartInfo.RedirectStandardOutput auf festlegen true .To use StandardOutput, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardOutput to true. Andernfalls löst das Lesen aus dem StandardOutput Stream eine Ausnahme aus.Otherwise, reading from the StandardOutput stream throws an exception.

Der umgeleitete StandardOutput Stream kann synchron oder asynchron gelesen werden.The redirected StandardOutput stream can be read synchronously or asynchronously. Methoden wie Read , ReadLine und ReadToEnd führen synchrone Lesevorgänge für den Ausgabestream des Prozesses aus.Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the output stream of the process. Diese synchronen Lesevorgänge werden erst abgeschlossen, wenn die zugeordnete Process in Ihren StandardOutput Stream schreibt, oder der Stream wird geschlossen.These synchronous read operations do not complete until the associated Process writes to its StandardOutput stream, or closes the stream.

Im Gegensatz dazu BeginOutputReadLine startet asynchrone Lesevorgänge im StandardOutput Stream.In contrast, BeginOutputReadLine starts asynchronous read operations on the StandardOutput stream. Diese Methode aktiviert einen festgelegten Ereignishandler für die Datenstrom Ausgabe und kehrt sofort an den Aufrufer zurück, der andere Aufgaben ausführen kann, während die Datenstrom Ausgabe an den Ereignishandler weitergeleitet wird.This method enables a designated event handler for the stream output and immediately returns to the caller, which can perform other work while the stream output is directed to the event handler.

Synchrone Lesevorgänge stellen eine Abhängigkeit zwischen dem aus dem StandardOutput Stream gelesenen Aufrufer und dem untergeordneten Prozess vor, der in diesen Stream schreibtSynchronous read operations introduce a dependency between the caller reading from the StandardOutput stream and the child process writing to that stream. Diese Abhängigkeiten können zu Deadlock-Bedingungen führen.These dependencies can result in deadlock conditions. Wenn der Aufrufer aus dem umgeleiteten Stream eines untergeordneten Prozesses liest, ist er vom untergeordneten Element abhängig.When the caller reads from the redirected stream of a child process, it is dependent on the child. Der Aufrufer wartet auf den Lesevorgang, bis das untergeordnete Objekt in den Stream schreibt oder den Stream schließt.The caller waits on the read operation until the child writes to the stream or closes the stream. Wenn der untergeordnete Prozess genügend Daten schreibt, um den umgeleiteten Stream auszufüllen, ist er vom übergeordneten Prozess abhängig.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. Der untergeordnete Prozess wartet auf den nächsten Schreibvorgang, bis das übergeordnete Element aus dem vollständigen Stream liest oder den Stream schließt.The child process waits on the next write operation until the parent reads from the full stream or closes the stream. Die Deadlockbedingung ergibt sich, wenn der Aufrufer und der untergeordnete Prozess aufeinander warten, um einen Vorgang abzuschließen.The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. Sie können Deadlocks vermeiden, indem Sie Abhängigkeiten zwischen dem Aufrufer und dem untergeordneten Prozess auswerten.You can avoid deadlocks by evaluating dependencies between the caller and child process.

In den letzten beiden Beispielen in diesem Abschnitt wird die- Start Methode verwendet, um eine ausführbare Datei namens Write500Lines.exe zu starten.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. Das folgende Beispiel enthält den Quellcode.The following example contains its source code.

using System;
using System.IO;

public class Example
{
   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.

Im folgenden Beispiel wird gezeigt, wie Sie aus einem umgeleiteten Stream lesen und warten, bis der untergeordnete Prozess beendet wird.The following example shows how to read from a redirected stream and wait for the child process to exit. Im Beispiel wird eine Deadlockbedingung durch Aufrufen von p.StandardOutput.ReadToEnd vor vermieden p.WaitForExit .The example avoids a deadlock condition by calling p.StandardOutput.ReadToEnd before p.WaitForExit. Ein Deadlockzustand kann auftreten, wenn der übergeordnete Prozess p.WaitForExit vor aufruft p.StandardOutput.ReadToEnd und der untergeordnete Prozess genug Text schreibt, um den umgeleiteten Stream auszufüllen.A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardOutput.ReadToEnd and the child process writes enough text to fill the redirected stream. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess beendet wird.The parent process would wait indefinitely for the child process to exit. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen Stream gelesen wird StandardOutput .The child process would wait indefinitely for the parent to read from the full StandardOutput stream.

using System;
using System.Diagnostics;

public class Example
{
   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 Standardfehlerstreams lesen.There is a similar issue when you read all text from both the standard output and standard error streams. Im folgenden Beispiel wird ein Lesevorgang für beide Streams durchführt.The following example performs a read operation on both streams. Die Deadlockbedingung wird vermieden, indem asynchrone Lesevorgänge im Stream durchgeführt werden StandardError .It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Eine Deadlockbedingung ergibt sich, wenn der p.StandardOutput.ReadToEnd übergeordnete Prozess gefolgt von aufruft p.StandardError.ReadToEnd und der untergeordnete Prozess genug Text schreibt, um den Fehler Datenstrom auszufüllen.A deadlock condition results if the parent process calls p.StandardOutput.ReadToEnd followed by p.StandardError.ReadToEnd and the child process writes enough text to fill its error stream. Der übergeordnete Prozess wartet unbegrenzt, bis der untergeordnete Prozess seinen StandardOutput Stream schließt.The parent process would wait indefinitely for the child process to close its StandardOutput stream. Der untergeordnete Prozess wartet unbegrenzt, bis das übergeordnete Element aus dem vollständigen Stream gelesen wird StandardError .The child process would wait indefinitely for the parent to read from the full StandardError stream.

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.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. Alternativ können Sie die Deadlockbedingung vermeiden, indem Sie zwei Threads erstellen und die Ausgabe der einzelnen Datenströme in einem separaten Thread lesen.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Hinweis

Asynchrone und synchrone Lesevorgänge können nicht in einem umgeleiteten Stream gemischt werden.You cannot mix asynchronous and synchronous read operations on a redirected stream. Sobald der umgeleitete Stream eines Process im asynchronen oder im synchronen Modus geöffnet ist, müssen sich alle weiteren Lesevorgänge in diesem Stream im gleichen Modus befinden.Once the redirected stream of a Process is opened in either asynchronous or synchronous mode, all further read operations on that stream must be in the same mode. Folgen Sie z BeginOutputReadLine . b. nicht mit einem aufrufen ReadLine von für den StandardOutput Stream oder umgekehrt.For example, do not follow BeginOutputReadLine with a call to ReadLine on the StandardOutput stream, or vice versa. Sie können jedoch zwei verschiedene Streams in verschiedenen Modi lesen.However, you can read two different streams in different modes. Sie können z. b. aufzurufen BeginOutputReadLine und dann ReadLine für den Stream aufzurufen StandardError .For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

Gilt für:

Siehe auch