Process.StandardError Propriedade

public:
 property System::IO::StreamReader ^ StandardError { System::IO::StreamReader ^ get(); };

[System.ComponentModel.Browsable(false)]
public System.IO.StreamReader StandardError { get; }

[<System.ComponentModel.Browsable(false)>]
member this.StandardError : System.IO.StreamReader

Public ReadOnly Property StandardError As StreamReader

Valor de Propriedade

A StreamReader que pode ser usado para ler o fluxo de erro padrão da aplicação.

Atributos

BrowsableAttribute

Exceções

Exemplos

O exemplo seguinte utiliza o net use comando juntamente com um argumento fornecido pelo utilizador para mapear um recurso de rede. Depois, lê o fluxo de erro padrão do comando net e escreve-o na consola.

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());
}

use myProcess = new Process()
let myProcessStartInfo = ProcessStartInfo("net ", $"use {args[0]}")

myProcessStartInfo.UseShellExecute <- false
myProcessStartInfo.RedirectStandardError <- true
myProcess.StartInfo <- myProcessStartInfo
myProcess.Start() |> ignore

let myStreamReader = myProcess.StandardError
// Read the standard error of net.exe and write it on to console.
printfn $"{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

Observações

Quando um Process texto escreve no seu fluxo de erro padrão, esse texto é normalmente exibido na consola. Ao redirecionar o StandardError fluxo, pode manipular ou suprimir a saída de erro de um processo. Por exemplo, podes filtrar o texto, formatá-lo de forma diferente ou escrever a saída tanto na consola como num ficheiro de registo designado.

O fluxo redirecionado StandardError pode ser lido de forma síncrona ou assíncrona. Métodos como Read, ReadLine, e ReadToEnd realizam operações de leitura síncronas no fluxo de saída de erro do processo. Estas operações de leitura síncronas só são concluídas até que o correspondente Process escreva no seu StandardError fluxo, ou encerre o fluxo.

Em contraste, BeginErrorReadLine inicia operações de leitura assíncronas no StandardError fluxo. Este método permite um gestor de eventos designado para a saída do fluxo e retorna imediatamente ao chamador, que pode realizar outros trabalhos enquanto a saída do fluxo é direcionada para o gestor de eventos.

As operações de leitura síncronas introduzem uma dependência entre o chamador que lê do StandardError fluxo e o processo filho que escreve nesse fluxo. Estas dependências podem resultar em condições de bloqueio. Quando o chamador lê do fluxo redirecionado de um processo filho, isso depende da criança. O chamador espera pela operação de leitura até que o filho escreva no fluxo ou o feche. Quando o processo filho escreve dados suficientes para preencher o seu fluxo redirecionado, depende do pai. O processo filho espera na próxima operação de escrita até que o pai leia do fluxo completo ou feche o fluxo. A condição de bloqueio ocorre quando o chamador e o processo filho esperam um do outro para completar uma operação, e nenhum dos dois pode avançar. Pode evitar bloqueios avaliando as dependências entre o chamador e o processo filho.

Os dois últimos exemplos desta secção usam o Start método para lançar um executável chamado Write500Lines.exe. O exemplo seguinte contém o seu código-fonte.

using System;

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:
//      Line 1 of 500 written: 0,20%
//      Line 2 of 500 written: 0,40%
//      Line 3 of 500 written: 0,60%
//      ...
//      Line 498 of 500 written: 99,60%
//      Line 499 of 500 written: 99,80%
//      Line 500 of 500 written: 100,00%
//
//      Successfully wrote 500 lines.

module Write500Lines

for i in 1. .. 500. do
    printfn $"Line {i} of 500 written: {i/500.:P2}";

eprintfn "Successfully wrote 500 lines.";
// The example displays the following output:
//      Line 1 of 500 written: 0,20%
//      Line 2 of 500 written: 0,40%
//      Line 3 of 500 written: 0,60%
//      ...
//      Line 498 of 500 written: 99,60%
//      Line 499 of 500 written: 99,80%
//      Line 500 of 500 written: 100,00%
//      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:
'      Line 1 of 500 written 0,20%
'      Line 2 of 500 written: 0,40%
'      Line 3 of 500 written: 0,60%
'      ...
'      Line 498 of 500 written: 99,60%
'      Line 499 of 500 written: 99,80%
'      Line 500 of 500 written: 100,00%
'
'      Successfully wrote 500 lines.

O exemplo seguinte mostra como ler de um fluxo de erro redirecionado e esperar que o processo filho saia. Evita uma condição de bloqueio ao chamar p.StandardError.ReadToEnd antes p.WaitForExitde . Pode resultar uma condição de deadlock se o processo pai chamar p.WaitForExit antes p.StandardError.ReadToEnd e o processo filho escrever texto suficiente para preencher o fluxo redirecionado. O processo parental esperaria indefinidamente que o processo filho fosse retirado. O processo filho esperaria indefinidamente que o pai lesse o stream completo 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.

module STDErrorSync

open System.Diagnostics

let p = new Process()
p.StartInfo.UseShellExecute <- false
p.StartInfo.RedirectStandardError <- true
p.StartInfo.FileName <- "Write500Lines.exe"
p.Start() |> ignore

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

printfn $"\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.

Há um problema semelhante quando lês todo o texto tanto da saída padrão como do fluxo de erro padrão. O exemplo seguinte realiza uma operação de leitura em ambos os fluxos. Evita a condição de bloqueio ao realizar operações de leitura assíncronas no StandardError fluxo. Uma condição de deadlock ocorre se o processo pai chamar p.StandardOutput.ReadToEnd seguido de p.StandardError.ReadToEnd e o processo filho escrever texto suficiente para preencher o seu fluxo de erros. O processo pai esperaria indefinidamente que o processo filho fechasse o seu StandardOutput fluxo. O processo filho esperaria indefinidamente que o pai lesse o stream completo 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:
//      'ritten: 99,80%
//      Line 500 of 500 written: 100,00%
//      '
//
//      Error stream: Successfully wrote 500 lines.

module STDOutputAsync

open System.Diagnostics

let p = new Process()
p.StartInfo.UseShellExecute <- false
p.StartInfo.RedirectStandardOutput <- true
let mutable eOut = ""
p.StartInfo.RedirectStandardError <- true
p.ErrorDataReceived.AddHandler(DataReceivedEventHandler(fun sender e -> eOut <- eOut + e.Data))

p.StartInfo.FileName <- "Write500Lines.exe"
p.Start() |> ignore

// To avoid deadlocks, use an asynchronous read operation on at least one of the streams.
p.BeginErrorReadLine()
let output = p.StandardOutput.ReadToEnd()
p.WaitForExit()

printfn $"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'"
printfn $"\nError stream: {eOut}"
// The example displays the following output:
//      The last 50 characters in the output stream are:
//      'ritten: 99,80%
//      Line 500 of 500 written: 100,00%
//      '
//
//      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:
'      'ritten: 99,80%
'      Line 500 of 500 written: 100,00%
'      '
'
'      Error stream: Successfully wrote 500 lines.

Pode usar operações de leitura assíncronas para evitar estas dependências e o seu potencial deadlock. Alternativamente, pode evitar a condição de deadlock criando dois threads e lendo a saída de cada stream num thread separado.

Ver também

• StandardInput
• StandardOutput
• RedirectStandardError