Process.StandardError Eigenschap

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

Waarde van eigenschap

Een StreamReader die kan worden gebruikt om de standaardfoutstroom van de toepassing te lezen.

Kenmerken

BrowsableAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt de net use opdracht samen met een door de gebruiker opgegeven argument gebruikt om een netwerkresource toe te wijzen. Vervolgens wordt de standaardfoutstroom van de net-opdracht gelezen en naar de console geschreven.

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

Opmerkingen

Wanneer een Process tekst naar de standaardfoutstroom schrijft, wordt die tekst normaal gesproken weergegeven op de console. Door de StandardError stroom om te leiden, kunt u de foutuitvoer van een proces manipuleren of onderdrukken. U kunt bijvoorbeeld de tekst filteren, anders opmaken of de uitvoer naar zowel de console als een aangewezen logboekbestand schrijven.

De omgeleide StandardError stream kan synchroon of asynchroon worden gelezen. Methoden zoals Read, ReadLineen ReadToEnd voeren synchrone leesbewerkingen uit op de foutuitvoerstroom van het proces. Deze synchrone leesbewerkingen worden pas voltooid als de bijbehorende Process schrijfbewerkingen naar StandardError de stream zijn voltooid of de stream worden gesloten.

Start daarentegen BeginErrorReadLine asynchrone leesbewerkingen op de StandardError stream. Deze methode maakt een aangewezen gebeurtenis-handler mogelijk voor de stroomuitvoer en keert onmiddellijk terug naar de aanroeper, die ander werk kan uitvoeren terwijl de stroomuitvoer wordt omgeleid naar de gebeurtenis-handler.

Synchrone leesbewerkingen introduceren een afhankelijkheid tussen de aanroeper die vanuit de StandardError stream leest en het onderliggende proces dat naar die stroom wordt geschreven. Deze afhankelijkheden kunnen leiden tot impassevoorwaarden. Wanneer de beller leest vanuit de omgeleide stroom van een onderliggend proces, is deze afhankelijk van het onderliggende proces. De beller wacht op de leesbewerking totdat het kind naar de stream schrijft of de stream sluit. Wanneer het onderliggende proces voldoende gegevens schrijft om de omgeleide stream te vullen, is het afhankelijk van het bovenliggende proces. Het onderliggende proces wacht op de volgende schrijfbewerking totdat het bovenliggende item uit de volledige stream leest of de stream sluit. De impassevoorwaarde treedt op wanneer de beller en het onderliggende proces op elkaar wachten om een bewerking te voltooien en geen van beide kan doorgaan. U kunt impasses voorkomen door afhankelijkheden tussen de aanroeper en het onderliggende proces te evalueren.

De laatste twee voorbeelden in deze sectie gebruiken de methode om een uitvoerbaar bestand met de Start naam Write500Lines.exete starten. Het volgende voorbeeld bevat de broncode.

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.

In het volgende voorbeeld ziet u hoe u kunt lezen uit een omgeleide foutstroom en wacht totdat het onderliggende proces is afgesloten. Het voorkomt een impassevoorwaarde door eerder p.WaitForExitaan te roepenp.StandardError.ReadToEnd. Een impassevoorwaarde kan resulteren als het bovenliggende proces eerder p.StandardError.ReadToEnd aanroept p.WaitForExit en het onderliggende proces voldoende tekst schrijft om de omgeleide stream te vullen. Het bovenliggende proces wacht voor onbepaalde tijd totdat het onderliggende proces is afgesloten. Het onderliggende proces wacht voor onbepaalde tijd totdat het bovenliggende item uit de volledige StandardError stream wordt gelezen.

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.

Er is een vergelijkbaar probleem wanneer u alle tekst uit zowel de standaarduitvoer als de standaardfoutstromen leest. In het volgende voorbeeld wordt een leesbewerking uitgevoerd op beide streams. Het voorkomt de impassevoorwaarde door asynchrone leesbewerkingen uit te voeren op de StandardError stream. Een impassevoorwaarde resulteert als de bovenliggende procesaanroepen p.StandardOutput.ReadToEnd gevolgd door p.StandardError.ReadToEnd en het onderliggende proces voldoende tekst schrijft om de foutstroom te vullen. Het bovenliggende proces wacht voor onbepaalde tijd totdat het onderliggende proces de StandardOutput stream sluit. Het onderliggende proces wacht voor onbepaalde tijd totdat het bovenliggende item uit de volledige StandardError stream wordt gelezen.

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.

U kunt asynchrone leesbewerkingen gebruiken om deze afhankelijkheden en hun impassepotentieel te voorkomen. U kunt ook de impassevoorwaarde voorkomen door twee threads te maken en de uitvoer van elke stream op een afzonderlijke thread te lezen.

Zie ook

• StandardInput
• StandardOutput
• RedirectStandardError