Process.BeginErrorReadLine Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Zahájí asynchronní operace čtení u přesměrovaného StandardError datového proudu aplikace.
public:
void BeginErrorReadLine();public void BeginErrorReadLine();[System.Runtime.InteropServices.ComVisible(false)]
public void BeginErrorReadLine();member this.BeginErrorReadLine : unit -> unit[<System.Runtime.InteropServices.ComVisible(false)>]
member this.BeginErrorReadLine : unit -> unitPublic Sub BeginErrorReadLine ()- Atributy
Výjimky
Vlastnost RedirectStandardError je false.
nebo
Asynchronní operace čtení již probíhá ve streamu StandardError .
nebo
Stream StandardError byl používán synchronní operací čtení.
Příklady
Následující příklad pomocí net view příkazu zobrazí seznam dostupných síťových prostředků na vzdáleném počítači. Uživatel zadá název cílového počítače jako argument příkazového řádku. Uživatel může také zadat název souboru pro výstup chyby. Příklad shromažďuje výstup příkazu net, čeká na dokončení procesu a pak zapíše výstupní výsledky do konzoly. Pokud uživatel zadá volitelný chybový soubor, příklad zapíše do souboru chyby.
// Define the namespaces used by this sample.
using System;
using System.Text;
using System.Globalization;
using System.IO;
using System.Diagnostics;
using System.Threading;
using System.ComponentModel;
namespace ProcessAsyncStreamSamples
{
class ProcessNetStreamRedirection
{
// Define static variables shared by class methods.
private static StreamWriter streamError =null;
private static String netErrorFile = "";
private static StringBuilder netOutput = null;
private static bool errorRedirect = false;
private static bool errorsWritten = false;
public static void RedirectNetCommandStreams()
{
String netArguments;
Process netProcess;
// Get the input computer name.
Console.WriteLine("Enter the computer name for the net view command:");
netArguments = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);
if (String.IsNullOrEmpty(netArguments))
{
// Default to the help command if there is not an input argument.
netArguments = "/?";
}
// Check if errors should be redirected to a file.
errorsWritten = false;
Console.WriteLine("Enter a fully qualified path to an error log file");
Console.WriteLine(" or just press Enter to write errors to console:");
netErrorFile = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);
if (!String.IsNullOrEmpty(netErrorFile))
{
errorRedirect = true;
}
// Note that at this point, netArguments and netErrorFile
// are set with user input. If the user did not specify
// an error file, then errorRedirect is set to false.
// Initialize the process and its StartInfo properties.
netProcess = new Process();
netProcess.StartInfo.FileName = "Net.exe";
// Build the net command argument list.
netProcess.StartInfo.Arguments = String.Format("view {0}",
netArguments);
// Set UseShellExecute to false for redirection.
netProcess.StartInfo.UseShellExecute = false;
// Redirect the standard output of the net command.
// This stream is read asynchronously using an event handler.
netProcess.StartInfo.RedirectStandardOutput = true;
netProcess.OutputDataReceived += new DataReceivedEventHandler(NetOutputDataHandler);
netOutput = new StringBuilder();
if (errorRedirect)
{
// Redirect the error output of the net command.
netProcess.StartInfo.RedirectStandardError = true;
netProcess.ErrorDataReceived += new DataReceivedEventHandler(NetErrorDataHandler);
}
else
{
// Do not redirect the error output.
netProcess.StartInfo.RedirectStandardError = false;
}
Console.WriteLine("\nStarting process: net {0}",
netProcess.StartInfo.Arguments);
if (errorRedirect)
{
Console.WriteLine("Errors will be written to the file {0}",
netErrorFile);
}
// Start the process.
netProcess.Start();
// Start the asynchronous read of the standard output stream.
netProcess.BeginOutputReadLine();
if (errorRedirect)
{
// Start the asynchronous read of the standard
// error stream.
netProcess.BeginErrorReadLine();
}
// Let the net command run, collecting the output.
netProcess.WaitForExit();
if (streamError != null)
{
// Close the error file.
streamError.Close();
}
else
{
// Set errorsWritten to false if the stream is not
// open. Either there are no errors, or the error
// file could not be opened.
errorsWritten = false;
}
if (netOutput.Length > 0)
{
// If the process wrote more than just
// white space, write the output to the console.
Console.WriteLine("\nPublic network shares from net view:\n{0}\n",
netOutput);
}
if (errorsWritten)
{
// Signal that the error file had something
// written to it.
String [] errorOutput = File.ReadAllLines(netErrorFile);
if (errorOutput.Length > 0)
{
Console.WriteLine("\nThe following error output was appended to {0}.",
netErrorFile);
foreach (String errLine in errorOutput)
{
Console.WriteLine(" {0}", errLine);
}
}
Console.WriteLine();
}
netProcess.Close();
}
private static void NetOutputDataHandler(object sendingProcess,
DataReceivedEventArgs outLine)
{
// Collect the net view command output.
if (!String.IsNullOrEmpty(outLine.Data))
{
// Add the text to the collected output.
netOutput.Append(Environment.NewLine + " " + outLine.Data);
}
}
private static void NetErrorDataHandler(object sendingProcess,
DataReceivedEventArgs errLine)
{
// Write the error text to the file if there is something
// to write and an error file has been specified.
if (!String.IsNullOrEmpty(errLine.Data))
{
if (!errorsWritten)
{
if (streamError == null)
{
// Open the file.
try
{
streamError = new StreamWriter(netErrorFile, true);
}
catch (Exception e)
{
Console.WriteLine("Could not open error file!");
Console.WriteLine(e.Message.ToString());
}
}
if (streamError != null)
{
// Write a header to the file if this is the first
// call to the error output handler.
streamError.WriteLine();
streamError.WriteLine(DateTime.Now.ToString());
streamError.WriteLine("Net View error output:");
}
errorsWritten = true;
}
if (streamError != null)
{
// Write redirected errors to the file.
streamError.WriteLine(errLine.Data);
streamError.Flush();
}
}
}
}
}
// Define the namespaces used by this sample.
open System
open System.Text
open System.Globalization
open System.IO
open System.Diagnostics
// Define variables shared by functions.
let mutable streamError = Unchecked.defaultof<StreamWriter>
let mutable netErrorFile = ""
let mutable netOutput = StringBuilder()
let mutable errorRedirect = false
let mutable errorsWritten = false
let netOutputDataHandler (sendingProcess: obj) (outLine: DataReceivedEventArgs) =
// Collect the net view command output.
if String.IsNullOrEmpty outLine.Data |> not then
// Add the text to the collected output.
netOutput.Append(Environment.NewLine + " " + outLine.Data) |> ignore
let netErrorDataHandler (sendingProcess: obj) (errLine: DataReceivedEventArgs) =
// Write the error text to the file if there is something
// to write and an error file has been specified.
if String.IsNullOrEmpty errLine.Data |> not then
if not errorsWritten then
if isNull streamError then
// Open the file.
try
streamError <- new StreamWriter(netErrorFile, true)
with e ->
printfn "Could not open error file!"
printfn $"{e.Message}"
if isNull streamError |> not then
// Write a header to the file if this is the first
// call to the error output handler.
streamError.WriteLine()
streamError.WriteLine DateTime.Now
streamError.WriteLine "Net View error output:"
errorsWritten <- true
if isNull streamError |> not then
// Write redirected errors to the file.
streamError.WriteLine errLine.Data
streamError.Flush()
let redirectNetCommandStreams () =
// Get the input computer name.
printfn "Enter the computer name for the net view command:"
let netArguments = stdin.ReadLine().ToUpper CultureInfo.InvariantCulture
// Default to the help command if there is not an input argument.
let netArguments =
if String.IsNullOrEmpty netArguments then
"/?"
else
netArguments
// Check if errors should be redirected to a file.
errorsWritten <- false
printfn "Enter a fully qualified path to an error log file"
printfn " or just press Enter to write errors to console:"
netErrorFile <- stdin.ReadLine().ToUpper CultureInfo.InvariantCulture
if String.IsNullOrEmpty netErrorFile |> not then
errorRedirect <- true
// Note that at this point, netArguments and netErrorFile
// are set with user input. If the user did not specify
// an error file, then errorRedirect is set to false.
// Initialize the process and its StartInfo properties.
let netProcess = new Process()
netProcess.StartInfo.FileName <- "Net.exe"
// Build the net command argument list.
netProcess.StartInfo.Arguments <- $"view {netArguments}"
// Set UseShellExecute to false for redirection.
netProcess.StartInfo.UseShellExecute <- false
// Redirect the standard output of the net command.
// This stream is read asynchronously using an event handler.
netProcess.StartInfo.RedirectStandardOutput <- true
netProcess.OutputDataReceived.AddHandler(DataReceivedEventHandler netOutputDataHandler)
netOutput <- new StringBuilder()
if errorRedirect then
// Redirect the error output of the net command.
netProcess.StartInfo.RedirectStandardError <- true
netProcess.ErrorDataReceived.AddHandler(DataReceivedEventHandler netErrorDataHandler)
else
// Do not redirect the error output.
netProcess.StartInfo.RedirectStandardError <- false
printfn $"\nStarting process: net {netProcess.StartInfo.Arguments}"
if errorRedirect then
printfn $"Errors will be written to the file {netErrorFile}"
// Start the process.
netProcess.Start() |> ignore
// Start the asynchronous read of the standard output stream.
netProcess.BeginOutputReadLine()
if errorRedirect then
// Start the asynchronous read of the standard error stream.
netProcess.BeginErrorReadLine()
// Let the net command run, collecting the output.
netProcess.WaitForExit()
if streamError <> null then
// Close the error file.
streamError.Close()
else
// Set errorsWritten to false if the stream is not
// open. Either there are no errors, or the error
// file could not be opened.
errorsWritten <- false
if netOutput.Length > 0 then
// If the process wrote more than just
// white space, write the output to the console.
printfn $"\nPublic network shares from net view:\n{netOutput}\n"
if errorsWritten then
// Signal that the error file had something
// written to it.
let errorOutput = File.ReadAllLines netErrorFile
if errorOutput.Length > 0 then
printfn $"\nThe following error output was appended to {netErrorFile}."
for errLine in errorOutput do
printfn $" {errLine}"
printfn ""
netProcess.Close()
' Define the namespaces used by this sample.
Imports System.Text
Imports System.Globalization
Imports System.IO
Imports System.Diagnostics
Imports System.Threading
Imports System.ComponentModel
Namespace ProcessAsyncStreamSamples
Class ProcessAsyncErrorRedirection
' Define static variables shared by class methods.
Private Shared streamError As StreamWriter = Nothing
Private Shared netErrorFile As String = ""
Private Shared netOutput As StringBuilder = Nothing
Private Shared errorRedirect As Boolean = False
Private Shared errorsWritten As Boolean = False
Public Shared Sub RedirectNetCommandStreams()
Dim netArguments As String
Dim netProcess As Process
' Get the input computer name.
Console.WriteLine("Enter the computer name for the net view command:")
netArguments = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture)
If String.IsNullOrEmpty(netArguments) Then
' Default to the help command if there is
' not an input argument.
netArguments = "/?"
End If
' Check if errors should be redirected to a file.
errorsWritten = False
Console.WriteLine("Enter a fully qualified path to an error log file")
Console.WriteLine(" or just press Enter to write errors to console:")
netErrorFile = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture)
If Not String.IsNullOrEmpty(netErrorFile) Then
errorRedirect = True
End If
' Note that at this point, netArguments and netErrorFile
' are set with user input. If the user did not specify
' an error file, then errorRedirect is set to false.
' Initialize the process and its StartInfo properties.
netProcess = New Process()
netProcess.StartInfo.FileName = "Net.exe"
' Build the net command argument list.
netProcess.StartInfo.Arguments = String.Format("view {0}", _
netArguments)
' Set UseShellExecute to false for redirection.
netProcess.StartInfo.UseShellExecute = False
' Redirect the standard output of the net command.
' Read the stream asynchronously using an event handler.
netProcess.StartInfo.RedirectStandardOutput = True
AddHandler netProcess.OutputDataReceived, _
AddressOf NetOutputDataHandler
netOutput = new StringBuilder()
If errorRedirect Then
' Redirect the error output of the net command.
netProcess.StartInfo.RedirectStandardError = True
AddHandler netProcess.ErrorDataReceived, _
AddressOf NetErrorDataHandler
Else
' Do not redirect the error output.
netProcess.StartInfo.RedirectStandardError = False
End If
Console.WriteLine(ControlChars.Lf + "Starting process: NET {0}", _
netProcess.StartInfo.Arguments)
If errorRedirect Then
Console.WriteLine("Errors will be written to the file {0}", _
netErrorFile)
End If
' Start the process.
netProcess.Start()
' Start the asynchronous read of the standard output stream.
netProcess.BeginOutputReadLine()
If errorRedirect Then
' Start the asynchronous read of the standard
' error stream.
netProcess.BeginErrorReadLine()
End If
' Let the net command run, collecting the output.
netProcess.WaitForExit()
If Not streamError Is Nothing Then
' Close the error file.
streamError.Close()
Else
' Set errorsWritten to false if the stream is not
' open. Either there are no errors, or the error
' file could not be opened.
errorsWritten = False
End If
If netOutput.Length > 0 Then
' If the process wrote more than just
' white space, write the output to the console.
Console.WriteLine()
Console.WriteLine("Public network shares from net view:")
Console.WriteLine()
Console.WriteLine(netOutput)
Console.WriteLine()
End If
If errorsWritten Then
' Signal that the error file had something
' written to it.
Dim errorOutput As String()
errorOutput = File.ReadAllLines(netErrorFile)
If errorOutput.Length > 0 Then
Console.WriteLine(ControlChars.Lf + _
"The following error output was appended to {0}.", _
netErrorFile)
Dim errLine as String
For Each errLine in errorOutput
Console.WriteLine(" {0}", errLine)
Next
Console.WriteLine()
End If
End If
netProcess.Close()
End Sub
Private Shared Sub NetOutputDataHandler(sendingProcess As Object, _
outLine As DataReceivedEventArgs)
' Collect the net view command output.
If Not String.IsNullOrEmpty(outLine.Data) Then
' Add the text to the collected output.
netOutput.Append(Environment.NewLine + " " + outLine.Data)
End If
End Sub
Private Shared Sub NetErrorDataHandler(sendingProcess As Object, _
errLine As DataReceivedEventArgs)
' Write the error text to the file if there is something to
' write and an error file has been specified.
If Not String.IsNullOrEmpty(errLine.Data) Then
If Not errorsWritten Then
If streamError Is Nothing Then
' Open the file.
Try
streamError = New StreamWriter(netErrorFile, true)
Catch e As Exception
Console.WriteLine("Could not open error file!")
Console.WriteLine(e.Message.ToString())
End Try
End If
If Not streamError Is Nothing Then
' Write a header to the file if this is the first
' call to the error output handler.
streamError.WriteLine()
streamError.WriteLine(DateTime.Now.ToString())
streamError.WriteLine("Net View error output:")
End If
errorsWritten = True
End If
If Not streamError Is Nothing Then
' Write redirected errors to the file.
streamError.WriteLine(errLine.Data)
streamError.Flush()
End If
End If
End Sub
End Class
End Namespace
Poznámky
Stream StandardError je možné číst synchronně nebo asynchronně. Metody, jako Readje , ReadLinea ReadToEnd provádět synchronní operace čtení ve výstupním datovém proudu chyby procesu. Tyto synchronní operace čtení se nedokončí, dokud přidružené Process zápisy do jeho StandardError datového proudu nebo nezavře datový proud.
Naproti tomu BeginErrorReadLine spouští asynchronní operace čtení ve streamu StandardError . Tato metoda umožňuje určenou obslužnou rutinu události pro výstup streamu a okamžitě se vrátí volajícímu, který může provést jinou práci, zatímco výstup streamu je směrován na obslužnou rutinu události.
Při provádění asynchronních operací StandardError čtení pro Process :
Nastavte UseShellExecute na hodnotu
false.Nastavte RedirectStandardError na hodnotu
true.Přidejte do události obslužnou rutinu ErrorDataReceived události. Obslužná rutina události musí odpovídat podpisu delegáta System.Diagnostics.DataReceivedEventHandler .
Spusťte tlačítko Process.
Zavolejte BeginErrorReadLine .Process Toto volání spouští asynchronní operace čtení na StandardError.
Při spuštění asynchronních operací čtení se obslužná rutina události volá pokaždé, když přidružená Process zapíše řádek textu do streamu StandardError .
Asynchronní operaci čtení můžete zrušit voláním CancelErrorRead. Operaci čtení může volající nebo obslužná rutina události zrušit. Po zrušení můžete znovu volat BeginErrorReadLine , abyste obnovili asynchronní operace čtení.
Note
Asynchronní a synchronní operace čtení u přesměrovaného datového proudu nelze kombinovat. Po otevření přesměrovaného streamu Process v asynchronním nebo synchronním režimu musí být všechny další operace čtení v daném datovém proudu ve stejném režimu. Například nespočítejte BeginErrorReadLine s voláním ReadLine do datového StandardError proudu nebo naopak. Můžete ale číst dva různé streamy v různých režimech. Můžete například volat BeginErrorReadLine a volat ReadLine pro StandardOutput stream.
