ProcessStartInfo.RedirectStandardError Propiedad

Definición

Obtiene o establece un valor que indica si la salida de errores de una aplicación se escribe en la secuencia de StandardError.Gets or sets a value that indicates whether the error output of an application is written to the StandardError stream.

public:
 property bool RedirectStandardError { bool get(); void set(bool value); };
public bool RedirectStandardError { get; set; }
member this.RedirectStandardError : bool with get, set
Public Property RedirectStandardError As Boolean

Valor de propiedad

Boolean

true si la salida de error se debe escribir en StandardError; si no, false.true if error output should be written to StandardError; otherwise, false. De manera predeterminada, es false.The default is false.

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 typically 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

Debe establecer UseShellExecute en false si desea establecer RedirectStandardError en true .You must set UseShellExecute to false if you want to set 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. 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.

Nota

La aplicación que está procesando la salida asincrónica debe llamar al Process.WaitForExit método para asegurarse de que se ha vaciado el búfer de salida.The application that is processing the asynchronous output should call the Process.WaitForExit method to ensure that the output buffer has been flushed.

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 cause 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 for 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 la siguiente operación de escritura hasta que el elemento primario Lee de la secuencia completa o cierra la secuencia.The child process waits for 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 for each other to complete an operation, and neither can continue. 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. El siguiente código de C#, por ejemplo, realiza una operación de lectura en ambas secuencias.The following C# code, for 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.

Se aplica a

Consulte también