Compartir a través de


Process.StandardError Propiedad

Definición

Obtiene una secuencia que se usa para leer la salida de errores de la aplicación.

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 que puede usarse para leer la secuencia de error estándar de la aplicación.

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.

o bien

La secuencia StandardError se ha abierto para operaciones de lectura asincrónicas con 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. A continuación, lee el flujo de error estándar del comando net y lo escribe en la consola.

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 un Process escribe texto en su secuencia de errores estándar, ese texto se muestra normalmente en la consola. Al redirigir la StandardError secuencia, puede manipular o suprimir la salida de error de un proceso. Por ejemplo, puede filtrar el texto, darle formato de forma diferente o escribir la salida en la consola y en un archivo de registro designado.

Nota

Para usar StandardError, debe establecer en ProcessStartInfo.UseShellExecutefalsey debe establecer en ProcessStartInfo.RedirectStandardErrortrue. De lo contrario, la lectura de la StandardError secuencia produce una excepción.

La secuencia redirigida StandardError se puede leer de forma sincrónica o asincrónica. Métodos como Read, ReadLiney ReadToEnd realizan operaciones de lectura sincrónicas en el flujo de salida de error del proceso. Estas operaciones de lectura sincrónicas no se completan hasta que las escrituras asociadas Process en su StandardError secuencia o cierran la secuencia.

En cambio, BeginErrorReadLine inicia operaciones de lectura asincrónicas en la StandardError secuencia. Este método habilita un controlador de eventos designado para la salida del flujo y vuelve inmediatamente al autor de la llamada, que puede realizar otro trabajo mientras la salida del flujo se dirige al controlador de eventos.

Las operaciones de lectura sincrónicas presentan una dependencia entre la lectura del autor de la llamada desde la StandardError secuencia y el proceso secundario que escribe en esa secuencia. Estas dependencias pueden dar lugar a condiciones de interbloqueo. Cuando el autor de la llamada lee desde la secuencia redirigida de un proceso secundario, depende del elemento secundario. El autor de la llamada espera a la operación de lectura hasta que el elemento secundario escribe en la secuencia o cierra la secuencia. Cuando el proceso secundario escribe suficientes datos para rellenar su secuencia redirigida, depende del elemento primario. El proceso secundario espera en la siguiente operación de escritura hasta que el elemento primario lee desde la secuencia completa o cierra la secuencia. 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 tampoco puede continuar. Puede evitar interbloqueos mediante la evaluación de las dependencias entre el autor de la llamada y el proceso secundario.

En los dos últimos ejemplos de esta sección se usa el Start método para iniciar un ejecutable denominado Write500Lines.exe. El ejemplo siguiente contiene su código fuente.

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.

En el ejemplo siguiente se muestra cómo leer de un flujo de error redirigido y esperar a que se cierre el proceso secundario. Evita una condición de interbloqueo llamando a p.StandardError.ReadToEnd antes de p.WaitForExit. Una condición de interbloqueo puede dar lugar si el proceso primario llama p.WaitForExit a antes p.StandardError.ReadToEnd y el proceso secundario escribe texto suficiente para rellenar la secuencia redirigida. El proceso primario esperaría indefinidamente a que se cierre el proceso secundario. El proceso secundario esperaría indefinidamente a que el elemento primario lea de la secuencia completa StandardError .

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 al leer todo el texto de los flujos de error estándar y de salida estándar. En el ejemplo siguiente se realiza una operación de lectura en ambos flujos. Evita la condición de interbloqueo realizando operaciones de lectura asincrónicas en la StandardError secuencia. Una condición de interbloqueo se produce si el proceso primario llama p.StandardOutput.ReadToEnd seguido de p.StandardError.ReadToEnd y el proceso secundario escribe suficiente texto para rellenar su secuencia de errores. El proceso primario esperaría indefinidamente para que el proceso secundario cierre su StandardOutput secuencia. El proceso secundario esperaría indefinidamente a que el elemento primario lea de la secuencia completa StandardError .

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. Como alternativa, puede evitar la condición de interbloqueo creando dos subprocesos y leyendo la salida de cada secuencia en un subproceso independiente.

Nota

No se pueden mezclar operaciones de lectura asincrónicas y sincrónicas en un flujo redirigido. Una vez que la secuencia redirigida de se Process abre en modo asincrónico o sincrónico, todas las operaciones de lectura adicionales de esa secuencia deben estar en el mismo modo. Por ejemplo, no siga BeginErrorReadLine con una llamada a ReadLine en la StandardError secuencia, o viceversa. Sin embargo, puede leer dos secuencias diferentes en diferentes modos. Por ejemplo, puede llamar BeginOutputReadLine a y, a continuación, llamar a ReadLine para la StandardError secuencia.

Se aplica a

Consulte también