Process.StandardError Propiedad

Definición

Obtiene una secuencia que se usa para leer la salida de errores de la aplicación.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

Valor de propiedad

StreamReader

StreamReader que puede usarse para leer la secuencia de error estándar de la aplicación.A StreamReader that can be used to read the standard error stream of the application.

Atributos

Excepciones

La secuencia StandardError no se ha definido para redirección; asegúrese de que RedirectStandardError se establece en true y UseShellExecute que se establece en false.The StandardError stream has not been defined for redirection; ensure RedirectStandardError is set to true and UseShellExecute is set to false.

o bien-or- La secuencia StandardError se ha abierto para operaciones de lectura asincrónicas con BeginErrorReadLine().The StandardError stream has been opened for asynchronous read operations with BeginErrorReadLine().

Ejemplos

En el ejemplo siguiente se usa el net use comando junto con un argumento proporcionado por el usuario para asignar un recurso de red.The following example uses the net use command together with a user supplied argument to map a network resource. A continuación, lee el flujo de error estándar del comando net y lo escribe en la consola.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

Comentarios

Cuando Process escribe texto en la secuencia de error estándar, el texto se muestra normalmente en la consola.When a Process writes text to its standard error stream, that text is normally displayed on the console. Mediante el redireccionamiento de la StandardError secuencia, puede manipular o suprimir la salida de error de un proceso.By redirecting the StandardError stream, you can manipulate or suppress the error output of a process. Por ejemplo, puede filtrar el texto, darles formato de forma diferente o escribir la salida en la consola y en un archivo de registro designado.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Nota

Para usar StandardError , debe establecer ProcessStartInfo.UseShellExecute en false y debe establecer ProcessStartInfo.RedirectStandardError en true .To use StandardError, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardError to true. De lo contrario, la lectura de la StandardError secuencia produce una excepción.Otherwise, reading from the StandardError stream throws an exception.

La secuencia redirigida StandardError se puede leer de forma sincrónica o asincrónica.The redirected StandardError stream can be read synchronously or asynchronously. Los métodos como Read , ReadLine y ReadToEnd realizan operaciones de lectura sincrónicas en el flujo de salida de error del proceso.Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the error output stream of the process. Estas operaciones de lectura sincrónicas no se completan hasta que el Process objeto asociado escribe en su StandardError secuencia o cierra la secuencia.These synchronous read operations do not complete until the associated Process writes to its StandardError stream, or closes the stream.

En cambio, BeginErrorReadLine inicia las operaciones de lectura asincrónica en la StandardError secuencia.In contrast, BeginErrorReadLine starts asynchronous read operations on the StandardError stream. Este método habilita un controlador de eventos designado para la salida de flujo y vuelve inmediatamente al llamador, que puede realizar otro trabajo mientras la salida de flujo se dirige al controlador de eventos.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.

Las operaciones de lectura sincrónicas presentan una dependencia entre el autor de la llamada que lee desde la StandardError secuencia y el proceso secundario que escribe en esa secuencia.Synchronous read operations introduce a dependency between the caller reading from the StandardError stream and the child process writing to that stream. Estas dependencias pueden producir condiciones de interbloqueo.These dependencies can result in deadlock conditions. Cuando el autor de la llamada Lee de la secuencia redirigida de un proceso secundario, depende del elemento secundario.When the caller reads from the redirected stream of a child process, it is dependent on the child. El autor de la llamada espera la operación de lectura hasta que el elemento secundario escribe en la secuencia o cierra la secuencia.The caller waits on the read operation until the child writes to the stream or closes the stream. Cuando el proceso secundario escribe suficientes datos para rellenar su secuencia redirigida, depende del elemento primario.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. El proceso secundario espera en la siguiente operación de escritura hasta que el elemento primario lee el flujo completo o cierra la secuencia.The child process waits on the next write operation until the parent reads from the full stream or closes the stream. La condición de interbloqueo se produce cuando el autor de la llamada y el proceso secundario esperan entre sí para completar una operación y ninguno puede continuar.The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. Puede evitar los interbloqueos evaluando las dependencias entre el llamador y el proceso secundario.You can avoid deadlocks by evaluating dependencies between the caller and child process.

En los dos últimos ejemplos de esta sección se usa el Start método para iniciar un ejecutable denominado Write500Lines.exe.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. El ejemplo siguiente contiene el código fuente.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.

En el ejemplo siguiente se muestra cómo leer desde un flujo de errores Redirigido y esperar a que el proceso secundario se cierre.The following example shows how to read from a redirected error stream and wait for the child process to exit. Evita una condición de interbloqueo mediante una llamada a p.StandardError.ReadToEnd antes de p.WaitForExit .It avoids a deadlock condition by calling p.StandardError.ReadToEnd before p.WaitForExit. Se puede producir una condición de interbloqueo si el proceso primario llama a p.WaitForExit antes p.StandardError.ReadToEnd de y el proceso secundario escribe suficiente texto para rellenar la secuencia redirigida.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. El proceso primario espera indefinidamente a que el proceso secundario se cierre.The parent process would wait indefinitely for the child process to exit. El proceso secundario esperar indefinidamente a que el elemento primario Lea el StandardError flujo completo.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.

Hay un problema similar cuando se lee todo el texto de la salida estándar y de los flujos de error estándar.There is a similar issue when you read all text from both the standard output and standard error streams. En el ejemplo siguiente se realiza una operación de lectura en ambas secuencias.The following example performs a read operation on both streams. Evita la condición de interbloqueo mediante la realización de operaciones de lectura asincrónica en la StandardError secuencia.It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Se produce una condición de interbloqueo si el proceso primario llama a p.StandardOutput.ReadToEnd seguido de p.StandardError.ReadToEnd y el proceso secundario escribe suficiente texto para rellenar la secuencia de error.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. El proceso primario esperaría indefinidamente a que el proceso secundario cerrara su StandardOutput flujo.The parent process would wait indefinitely for the child process to close its StandardOutput stream. El proceso secundario esperar indefinidamente a que el elemento primario Lea el StandardError flujo completo.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.

Puede usar operaciones de lectura asincrónicas para evitar estas dependencias y su potencial de interbloqueo.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. Como alternativa, puede evitar la condición de interbloqueo mediante la creación de dos subprocesos y la lectura de la salida de cada secuencia en un subproceso independiente.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Nota

No se pueden mezclar operaciones de lectura asincrónicas y sincrónicas en una secuencia redirigida.You cannot mix asynchronous and synchronous read operations on a redirected stream. Una vez que la secuencia redirigida de un Process se abre en modo asincrónico o sincrónico, todas las demás operaciones de lectura en esa secuencia deben estar en el mismo modo.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. Por ejemplo, no siga BeginErrorReadLine con una llamada a ReadLine en el StandardError flujo, o viceversa.For example, do not follow BeginErrorReadLine with a call to ReadLine on the StandardError stream, or vice versa. Sin embargo, puede leer dos flujos diferentes en distintos modos.However, you can read two different streams in different modes. Por ejemplo, puede llamar a BeginOutputReadLine y, a continuación, llamar a ReadLine para la StandardError secuencia.For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

Se aplica a

Consulte también