ProcessStartInfo.RedirectStandardError Vlastnost
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í.
Získá nebo nastaví hodnotu, která označuje, zda je výstup chyby aplikace zapsán do datového StandardError proudu.
public:
property bool RedirectStandardError { bool get(); void set(bool value); };public bool RedirectStandardError { get; set; }member this.RedirectStandardError : bool with get, setPublic Property RedirectStandardError As BooleanHodnota vlastnosti
true pokud by měl být výstup chyby zapsán do StandardError; jinak , false. Výchozí hodnota je false.
Příklady
Následující příklad používá net use příkaz společně s argumentem zadaným uživatelem k mapování síťového prostředku. Pak přečte standardní chybový proud příkazu net a zapíše ho do konzoly.
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
Poznámky
Když zapíše text do standardního Process chybového streamu, obvykle se tento text zobrazí v konzole. Přesměrováním datového StandardError proudu můžete manipulovat nebo potlačit výstup chyby procesu. Můžete například filtrovat text, formátovat ho jinak nebo zapisovat výstup do konzoly i určeného souboru protokolu.
Note
UseShellExecute
false Pokud chcete nastavit hodnotu RedirectStandardErrortrue. V opačném případě při čtení z datového StandardError proudu dojde k výjimce.
Přesměrovaný StandardError stream je možné číst synchronně nebo asynchronně. Metody, jako Readje , ReadLine a ReadToEnd provádět synchronní operace čtení ve výstupním 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ádět další práci, zatímco výstup streamu je směrován na obslužnou rutinu události.
Note
Aplikace, která zpracovává asynchronní výstup, by měla volat metodu Process.WaitForExit , aby se zajistilo, že výstupní vyrovnávací paměť byla vyprázdněna.
Synchronní operace čtení představují závislost mezi volajícím čtením z datového StandardError proudu a podřízeným procesem zápisu do tohoto datového proudu. Tyto závislosti můžou způsobit podmínky vzájemného zablokování. Když volající přečte z přesměrovaného datového proudu podřízeného procesu, závisí na podřízené sadě. Volající počká na operaci čtení, dokud podřízený zápis do datového proudu nezapíše nebo datový proud nezavře. Když podřízený proces zapíše dostatek dat k vyplnění přesměrovaného datového proudu, závisí na nadřazené sadě. Podřízený proces čeká na další operaci zápisu, dokud nadřazený objekt nepřečte z úplného datového proudu nebo datový proud zavře. Podmínka vzájemného zablokování způsobí, že volající a podřízený proces čekají na dokončení operace a ani jeden z nich nemůže pokračovat. Zablokování se můžete vyhnout vyhodnocením závislostí mezi volajícím a podřízeným procesem.
Poslední dva příklady v této části používají metodu Start ke spuštění spustitelného souboru s názvem Write500Lines.exe. Následující příklad obsahuje zdrojový kód.
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.
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.
Následující příklad ukazuje, jak číst z přesměrovaného datového proudu chyb a čekat na ukončení podřízeného procesu. Vyhne se stavu vzájemného zablokování voláním p.StandardError.ReadToEnd před p.WaitForExit. Podmínka zablokování může vést k tomu, že nadřazený proces volá p.WaitForExit před p.StandardError.ReadToEnd a podřízený proces zapíše dostatek textu k vyplnění přesměrovaného datového proudu. Nadřazený proces by po neomezenou dobu čekal, než se podřízený proces ukončí. Podřízený proces počká neomezeně dlouho, než se nadřazený objekt přečte z úplného StandardError datového proudu.
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.
Při čtení veškerého textu ze standardního i standardního datového proudu chyb dochází k podobnému problému. Následující kód jazyka C# například provádí operaci čtení v obou datových proudech. Vyhne se konfliktu vzájemného zablokování provedením asynchronních operací čtení ve streamu StandardError . Podmínka zablokování je výsledkem, pokud nadřazený proces volá p.StandardOutput.ReadToEnd a p.StandardError.ReadToEnd podřízený proces zapíše dostatek textu k vyplnění jeho chybového streamu. Nadřazený proces by počkal na neomezenou dobu, než podřízený proces zavře jeho StandardOutput datový proud. Podřízený proces počká neomezeně dlouho, než se nadřazený objekt přečte z úplného StandardError datového proudu.
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.
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.
Pomocí asynchronních operací čtení se můžete těmto závislostem a jejich potenciálnímu zablokování vyhnout. Případně se můžete vyhnout konfliktu vzájemného zablokování vytvořením dvou vláken a čtením výstupu každého datového proudu v samostatném vlákně.
