ProcessStartInfo.RedirectStandardError Tulajdonság
Definíció
Fontos
Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.
Lekéri vagy beállít egy értéket, amely jelzi, hogy egy alkalmazás hibakimenete a StandardError streambe van-e írva.
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 BooleanTulajdonság értéke
trueha a hibakimenetet a következőre StandardErrorkell írni: ; ellenkező esetben. false Az alapértelmezett érték a false.
Példák
Az alábbi példa egy felhasználó által megadott argumentummal együtt használja a net use parancsot egy hálózati erőforrás leképezéséhez. Ezután beolvassa a net parancs szabványos hibafolyamát, és a konzolra írja.
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
Megjegyzések
Amikor egy Process szöveget ír a szokásos hibastreambe, az általában megjelenik a konzolon. A StandardError stream átirányításával módosíthatja vagy letilthatja egy folyamat hibakimenetét. Szűrheti például a szöveget, formázhatja másként, vagy a kimenetet a konzolra és a kijelölt naplófájlba is írhatja.
Note
UseShellExecute Ha be szeretné állítani a false következőt RedirectStandardErrortrue: . Ellenkező esetben a StandardError streamből való olvasás kivételt eredményez.
Az átirányított StandardError stream szinkronizálva vagy aszinkron módon olvasható. Az olyan metódusok, mint a Read, ReadLine és ReadToEnd szinkron olvasási műveleteket hajtanak végre a folyamat hibakimenetén. Ezek a szinkron olvasási műveletek addig nem fejeződnek be, amíg a társított Process írás nem fejeződik be a streambe StandardError , vagy nem zárja be a streamet.
Ezzel szemben BeginErrorReadLine elindítja az aszinkron olvasási műveleteket a StandardError streamen. Ez a módszer lehetővé teszi egy kijelölt eseménykezelőt a stream kimenetéhez, és azonnal visszatér a hívóhoz, amely más műveleteket is végrehajthat, miközben a stream kimenete az eseménykezelőhöz lesz irányítva.
Note
Az aszinkron kimenetet feldolgozó alkalmazásnak meg kell hívnia a Process.WaitForExit metódust, hogy a kimeneti puffer kiürítve legyen.
A szinkron olvasási műveletek függőséget vezetnek be a hívó és a gyermekfolyamat között, amely az StandardError adott streambe ír. Ezek a függőségek holtponti feltételeket okozhatnak. Amikor a hívó egy gyermekfolyamat átirányított adatfolyamából olvas, az a gyermektől függ. A hívó megvárja az olvasási műveletet, amíg a gyermek be nem ír a streambe, vagy bezárja a streamet. Ha a gyermekfolyamat elegendő adatot ír az átirányított adatfolyam kitöltéséhez, az a szülőtől függ. A gyermekfolyamat megvárja a következő írási műveletet, amíg a szülő be nem olvas a teljes streamből, vagy bezárja a streamet. A holtpont állapota akkor jön létre, amikor a hívó és a gyermekfolyamat megvárja egymást a művelet végrehajtására, és egyik sem folytatódhat. Elkerülheti a holtpontokat a hívó és a gyermekfolyamat közötti függőségek kiértékelésével.
Ebben a szakaszban az utolsó két példa egy Startnevű végrehajtható fájl elindítására használja a metódust. Az alábbi példa a forráskódját tartalmazza.
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.
Az alábbi példa bemutatja, hogyan olvasható egy átirányított hibastreamből, és várja meg, amíg a gyermekfolyamat kilép. Ez elkerüli a holtpont feltételt a hívás p.StandardError.ReadToEnd előtt p.WaitForExit. Holtpont-állapot akkor fordulhat elő, ha a szülőfolyamat korábban p.WaitForExit hív, p.StandardError.ReadToEnd és a gyermekfolyamat elegendő szöveget ír az átirányított stream kitöltéséhez. A szülőfolyamat határozatlan ideig várakozna, amíg a gyermekfolyamat kilép. A gyermekfolyamat határozatlan ideig várakozna, amíg a szülő felolvassa a teljes StandardError adatfolyamot.
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.
Hasonló probléma merül fel, ha az összes szöveget a standard kimenetből és a standard hibastreamekből is olvassa. A következő C#-kód például olvasási műveletet hajt végre mindkét streamen. Elkerüli a holtpont állapotát a stream aszinkron olvasási StandardError műveleteinek végrehajtásával. A holtpont feltétel akkor jelenik meg, ha a szülőfolyamat meghívja p.StandardOutput.ReadToEnd őket, p.StandardError.ReadToEnd és a gyermekfolyamat elegendő szöveget ír a hibastream kitöltéséhez. A szülőfolyamat határozatlan ideig várakozna, amíg a gyermekfolyamat bezárja a streamet StandardOutput . A gyermekfolyamat határozatlan ideig várakozna, amíg a szülő felolvassa a teljes StandardError adatfolyamot.
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.
Aszinkron olvasási műveletekkel elkerülheti ezeket a függőségeket és azok holtpont-potenciálját. Alternatív megoldásként elkerülheti a holtpont feltételét úgy, hogy két szálat hoz létre, és beolvassa az egyes streamek kimenetét egy külön szálon.
