Process.StandardError Właściwość

Definicja

Pobiera strumień używany do odczytywania danych wyjściowych błędu aplikacji.Gets a stream used to read the error output of the application.

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

Wartość właściwości

StreamReader

StreamReader, Który może być używany do odczytywania standardowego strumienia błędów aplikacji.A StreamReader that can be used to read the standard error stream of the application.

Atrybuty

Wyjątki

StandardErrorStrumień nie został zdefiniowany na potrzeby przekierowania; upewnij RedirectStandardError się, że jest ustawiony na true UseShellExecute false .The StandardError stream has not been defined for redirection; ensure RedirectStandardError is set to true and UseShellExecute is set to false.

-lub--or- StandardErrorStrumień został otwarty dla asynchronicznych operacji odczytu z BeginErrorReadLine() .The StandardError stream has been opened for asynchronous read operations with BeginErrorReadLine().

Przykłady

Poniższy przykład używa net use polecenia wraz z argumentem dostarczonym przez użytkownika w celu mapowania zasobu sieciowego.The following example uses the net use command together with a user supplied argument to map a network resource. Następnie odczytuje standardowy strumień błędów polecenia NET i zapisuje go w konsoli programu.It then reads the standard error stream of the net command and writes it to console.

Process^ myProcess = gcnew Process;
ProcessStartInfo^ myProcessStartInfo = gcnew ProcessStartInfo( "net ",String::Concat( "use ", args[ 0 ] ) );

myProcessStartInfo->UseShellExecute = false;
myProcessStartInfo->RedirectStandardError = true;
myProcess->StartInfo = myProcessStartInfo;
myProcess->Start();

StreamReader^ myStreamReader = myProcess->StandardError;
// Read the standard error of net.exe and write it on to console.
Console::WriteLine( myStreamReader->ReadLine() );
myProcess->Close();
using (Process myProcess = new Process())
{
    ProcessStartInfo myProcessStartInfo = new ProcessStartInfo("net ", "use " + args[0]);

    myProcessStartInfo.UseShellExecute = false;
    myProcessStartInfo.RedirectStandardError = true;
    myProcess.StartInfo = myProcessStartInfo;
    myProcess.Start();

    StreamReader myStreamReader = myProcess.StandardError;
    // Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine());
}
Using myProcess As New Process()
    Dim myProcessStartInfo As New ProcessStartInfo("net ", "use " + args(0))

    myProcessStartInfo.UseShellExecute = False
    myProcessStartInfo.RedirectStandardError = True
    myProcess.StartInfo = myProcessStartInfo
    myProcess.Start()

    Dim myStreamReader As StreamReader = myProcess.StandardError
    ' Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine())
End Using

Uwagi

Gdy Process zapisuje tekst do standardowego strumienia błędów, ten tekst jest zwykle wyświetlany w konsoli programu.When a Process writes text to its standard error stream, that text is normally displayed on the console. Przekierowując StandardError strumień, można manipulować lub pomijać dane wyjściowe danego procesu.By redirecting the StandardError stream, you can manipulate or suppress the error output of a process. Na przykład można filtrować tekst, formatować go inaczej lub zapisywać dane wyjściowe do konsoli i wyszukanego pliku dziennika.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Uwaga

Aby użyć StandardError , należy ustawić ProcessStartInfo.UseShellExecute na wartość false i ustawić wartość ProcessStartInfo.RedirectStandardError true .To use StandardError, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardError to true. W przeciwnym razie odczyt ze StandardError strumienia zgłasza wyjątek.Otherwise, reading from the StandardError stream throws an exception.

Przekierowany StandardError strumień można odczytywać synchronicznie lub asynchronicznie.The redirected StandardError stream can be read synchronously or asynchronously. Metody takie jak Read , ReadLine i ReadToEnd wykonują synchroniczne operacje odczytu w strumieniu wyjściowym procesu.Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the error output stream of the process. Te synchroniczne operacje odczytu nie są wykonywane do momentu skojarzonego Process zapisu w jego StandardError strumieniu lub zamknięcia strumienia.These synchronous read operations do not complete until the associated Process writes to its StandardError stream, or closes the stream.

Z kolei program BeginErrorReadLine uruchamia asynchroniczne operacje odczytu w StandardError strumieniu.In contrast, BeginErrorReadLine starts asynchronous read operations on the StandardError stream. Ta metoda umożliwia wyznaczeniu programu obsługi zdarzeń dla danych wyjściowych strumienia i natychmiast powraca do obiektu wywołującego, który może wykonywać inne czynności, gdy dane wyjściowe strumienia są kierowane do programu obsługi zdarzeń.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.

Operacje odczytu synchronicznego wprowadzają zależność między odczytem obiektu wywołującego ze StandardError strumienia i procesem podrzędnym w tym strumieniu.Synchronous read operations introduce a dependency between the caller reading from the StandardError stream and the child process writing to that stream. Te zależności mogą powodować powstanie warunków zakleszczenia.These dependencies can result in deadlock conditions. Gdy obiekt wywołujący odczytuje z przekierowanego strumienia procesu podrzędnego, zależy od elementu podrzędnego.When the caller reads from the redirected stream of a child process, it is dependent on the child. Obiekt wywołujący czeka na operację odczytu do momentu zapisu podrzędnego w strumieniu lub zamknięcia strumienia.The caller waits on the read operation until the child writes to the stream or closes the stream. Gdy proces podrzędny zapisuje wystarczające dane, aby wypełnić przekierowany strumień, zależy od elementu nadrzędnego.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. Proces podrzędny czeka na następną operację zapisu do momentu, gdy element nadrzędny zostanie odczytany z pełnego strumienia lub zamknie strumień.The child process waits on the next write operation until the parent reads from the full stream or closes the stream. Warunek zakleszczenia powstaje, gdy wywołujący i proces podrzędny zaczekają na siebie, aby ukończyć operację, i nie może wykonać żadnej operacji.The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. Można uniknąć zakleszczenii, oceniając zależności między procesem wywołującym i podrzędnym.You can avoid deadlocks by evaluating dependencies between the caller and child process.

W ostatnich dwóch przykładach w tej sekcji użyto Start metody do uruchomienia pliku wykonywalnego o nazwie Write500Lines.exe.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. Poniższy przykład zawiera kod źródłowy.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.

Poniższy przykład pokazuje, jak odczytywać ze strumienia błędów przekierowanych i poczekać na zakończenie procesu podrzędnego.The following example shows how to read from a redirected error stream and wait for the child process to exit. Pozwala to uniknąć stanu zakleszczenia przez wywołanie p.StandardError.ReadToEnd przed p.WaitForExit .It avoids a deadlock condition by calling p.StandardError.ReadToEnd before p.WaitForExit. Warunek zakleszczenia może spowodować, że proces nadrzędny wywoła p.WaitForExit przed p.StandardError.ReadToEnd i proces podrzędny zapisze wystarczającą ilość tekstu, aby wypełnić przekierowany strumień.A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardError.ReadToEnd and the child process writes enough text to fill the redirected stream. Proces nadrzędny czeka na zakończenie procesu podrzędnego.The parent process would wait indefinitely for the child process to exit. Proces podrzędny zaczeka w nieskończoność na odczytanie ze pełnego StandardError strumienia.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.RedirectStandardError = true;  
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

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

      Console.WriteLine($"\nError stream: {output}");
   }
}
// The end of the output produced by the example includes the following:
//      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.RedirectStandardError = 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.StandardError.ReadToEnd()  
        p.WaitForExit()

        Console.WriteLine($"{vbCrLf}Error stream: {output}")
    End Sub
End Module
' The end of the output produced by the example includes the following:
'      Error stream:
'      Successfully wrote 500 lines.

Podobny problem występuje w przypadku odczytywania całego tekstu zarówno ze standardowego wyjścia, jak i standardowego strumienia błędów.There is a similar issue when you read all text from both the standard output and standard error streams. Poniższy przykład wykonuje operację odczytu dla obu strumieni.The following example performs a read operation on both streams. Pozwala to uniknąć stanu zakleszczenia przez wykonywanie asynchronicznych operacji odczytu StandardError strumienia.It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Warunek zakleszczenia powstaje, gdy wywołujące proces nadrzędny, p.StandardOutput.ReadToEnd p.StandardError.ReadToEnd a następnie proces podrzędny zapisuje wystarczającą ilość tekstu w celu wypełnienia strumienia błędów.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. Proces nadrzędny czeka na zamknięcie jego strumienia przez proces podrzędny StandardOutput .The parent process would wait indefinitely for the child process to close its StandardOutput stream. Proces podrzędny zaczeka w nieskończoność na odczytanie ze pełnego StandardError strumienia.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.

Można użyć asynchronicznych operacji odczytu, aby uniknąć tych zależności i ich potencjału zakleszczenia.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. Można też uniknąć sytuacji zakleszczenia, tworząc dwa wątki i odczytując dane wyjściowe każdego strumienia w osobnym wątku.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Uwaga

Nie można mieszać asynchronicznych i synchronicznych operacji odczytu w przekierowanym strumieniu.You cannot mix asynchronous and synchronous read operations on a redirected stream. Gdy przekierowany strumień a Process zostanie otwarty w trybie asynchronicznym lub synchronicznym, wszystkie dalsze operacje odczytu w tym strumieniu muszą znajdować się w tym samym trybie.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. Na przykład nie należy śledzić BeginErrorReadLine wywołania do ReadLine StandardError strumienia lub na odwrót.For example, do not follow BeginErrorReadLine with a call to ReadLine on the StandardError stream, or vice versa. Można jednak odczytywać dwa różne strumienie w różnych trybach.However, you can read two different streams in different modes. Na przykład można wywołać BeginOutputReadLine i wywołać ReadLine StandardError strumień.For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

Dotyczy

Zobacz też