Process.StandardError Process.StandardError Process.StandardError Process.StandardError Property

Definizione

Ottiene un flusso usato per leggere l'output di errore dell'applicazione.Gets a stream used to read the error output of the application.

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

Valore della proprietà

Oggetto StreamReader che può essere usato per leggere il flusso di errore standard dell'applicazione.A StreamReader that can be used to read the standard error stream of the application.

Eccezioni

Il flusso StandardError non è stato definito per il reindirizzamento; assicurarsi che RedirectStandardError sia impostato su true e che UseShellExecute sia impostato su false.The StandardError stream has not been defined for redirection; ensure RedirectStandardError is set to true and UseShellExecute is set to false.

In alternativa-or- Il flusso StandardError è stato aperto per operazioni di lettura asincrona con BeginErrorReadLine().The StandardError stream has been opened for asynchronous read operations with BeginErrorReadLine().

Esempi

Nell'esempio seguente viene usato net use il comando insieme a un argomento fornito dall'utente per eseguire il mapping di una risorsa di rete.The following example uses the net use command together with a user supplied argument to map a network resource. Legge quindi il flusso di errore standard del comando NET e lo scrive nella console.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

Commenti

Quando un Process testo scrive nel flusso di errore standard, il testo viene normalmente visualizzato nella console.When a Process writes text to its standard error stream, that text is normally displayed on the console. Tramite il reindirizzamento del StandardError flusso, è possibile modificare o escludere l'output degli errori di un processo.By redirecting the StandardError stream, you can manipulate or suppress the error output of a process. Ad esempio, è possibile filtrare il testo, formattarlo in modo diverso o scrivere l'output nella console e in un file di log designato.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Nota

Per utilizzare StandardError, è necessario impostare ProcessStartInfo.UseShellExecute su falseed è necessario impostare ProcessStartInfo.RedirectStandardError su true.To use StandardError, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardError to true. In caso contrario, la StandardError lettura dal flusso genera un'eccezione.Otherwise, reading from the StandardError stream throws an exception.

Il flusso StandardError reindirizzato può essere letto in modo sincrono o asincrono.The redirected StandardError stream can be read synchronously or asynchronously. Metodi come Read, ReadLineed ReadToEnd eseguono operazioni di lettura sincrona nel flusso di output degli errori del processo.Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the error output stream of the process. Queste operazioni di lettura sincrona non vengono completate Process fino a quando StandardError l'oggetto associato non scrive nel relativo flusso o chiude il flusso.These synchronous read operations do not complete until the associated Process writes to its StandardError stream, or closes the stream.

Al contrario, BeginErrorReadLine avvia le operazioni di lettura asincrona StandardError sul flusso.In contrast, BeginErrorReadLine starts asynchronous read operations on the StandardError stream. Questo metodo abilita un gestore eventi designato per l'output del flusso e ritorna immediatamente al chiamante, che può eseguire altre operazioni mentre l'output del flusso viene indirizzato al gestore dell'evento.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.

Le operazioni di lettura sincrona introducono una dipendenza tra il StandardError chiamante che legge dal flusso e il processo figlio che scrive nel flusso.Synchronous read operations introduce a dependency between the caller reading from the StandardError stream and the child process writing to that stream. Queste dipendenze possono causare condizioni di deadlock.These dependencies can result in deadlock conditions. Quando il chiamante legge dal flusso reindirizzato di un processo figlio, dipende dall'elemento figlio.When the caller reads from the redirected stream of a child process, it is dependent on the child. Il chiamante attende l'operazione di lettura fino a quando l'elemento figlio non scrive nel flusso o chiude il flusso.The caller waits on the read operation until the child writes to the stream or closes the stream. Quando il processo figlio scrive un numero sufficiente di dati per riempire il flusso reindirizzato, dipende dall'elemento padre.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. Il processo figlio attende la successiva operazione di scrittura finché l'elemento padre non legge dal flusso completo o chiude il flusso.The child process waits on the next write operation until the parent reads from the full stream or closes the stream. La condizione di deadlock si verifica quando il chiamante e il processo figlio restano in attesa l'uno sull'altro per completare un'operazione e nessuno dei due può procedere.The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. È possibile evitare i deadlock valutando le dipendenze tra il chiamante e il processo figlio.You can avoid deadlocks by evaluating dependencies between the caller and child process.

Gli ultimi due esempi in questa sezione usano il Start metodo per avviare un eseguibile denominato Write500Lines. exe.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. L'esempio seguente contiene il codice sorgente.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.

Nell'esempio seguente viene illustrato come leggere da un flusso di errore reindirizzato e attendere la chiusura del processo figlio.The following example shows how to read from a redirected error stream and wait for the child process to exit. Evita una condizione di deadlock chiamando p.StandardError.ReadToEnd before. p.WaitForExitIt avoids a deadlock condition by calling p.StandardError.ReadToEnd before p.WaitForExit. Una condizione di deadlock può verificarsi se il processo padre p.WaitForExit chiama p.StandardError.ReadToEnd prima e il processo figlio scrive un testo sufficiente per riempire il flusso reindirizzato.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. Il processo padre attenderà per un tempo illimitato la chiusura del processo figlio.The parent process would wait indefinitely for the child process to exit. Il processo figlio attenderebbe indefinitamente che l'elemento padre legga dal StandardError flusso 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.

Si verifica un problema simile quando si legge tutto il testo sia dall'output standard che dai flussi di errore standard.There is a similar issue when you read all text from both the standard output and standard error streams. Nell'esempio seguente viene eseguita un'operazione di lettura su entrambi i flussi.The following example performs a read operation on both streams. Evita la condizione di deadlock eseguendo operazioni di lettura asincrona sul StandardError flusso.It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Una condizione di deadlock viene generata se il processo p.StandardOutput.ReadToEnd padre chiama p.StandardError.ReadToEnd seguito da e il processo figlio scrive un testo sufficiente per riempire il flusso di errore.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. Il processo padre attenderebbe in modo indefinito che il processo figlio chiuda StandardOutput il flusso.The parent process would wait indefinitely for the child process to close its StandardOutput stream. Il processo figlio attenderebbe indefinitamente che l'elemento padre legga dal StandardError flusso 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.

È possibile utilizzare le operazioni di lettura asincrona per evitare queste dipendenze e il relativo potenziale di deadlock.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. In alternativa, è possibile evitare la condizione di deadlock creando due thread e leggendo l'output di ogni flusso in un thread separato.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Nota

Non è possibile combinare operazioni di lettura sincrone e asincrone su un flusso reindirizzato.You cannot mix asynchronous and synchronous read operations on a redirected stream. Quando il flusso reindirizzato Process di un oggetto viene aperto in modalità asincrona o sincrona, tutte le altre operazioni di lettura nel flusso devono essere nella stessa modalità.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. Ad esempio, non seguire BeginErrorReadLine con una chiamata a ReadLine nel StandardError flusso o viceversa.For example, do not follow BeginErrorReadLine with a call to ReadLine on the StandardError stream, or vice versa. Tuttavia, è possibile leggere due flussi diversi in modalità diverse.However, you can read two different streams in different modes. Ad esempio, è possibile chiamare BeginOutputReadLine e quindi chiamare ReadLine per il StandardError flusso.For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

Sicurezza

LinkDemand
per l'attendibilità totale per il chiamante immediato.for full trust for the immediate caller. Impossibile utilizzare questo membro in codice parzialmente attendibile.This member cannot be used by partially trusted code.

Si applica a

Vedi anche