ProcessStartInfo.RedirectStandardOutput Egenskap

public:
 property bool RedirectStandardOutput { bool get(); void set(bool value); };

public bool RedirectStandardOutput { get; set; }

member this.RedirectStandardOutput : bool with get, set

Public Property RedirectStandardOutput As Boolean

Egenskapsvärde

trueom utdata ska skrivas till StandardOutput, annars . false Standardvärdet är false.

Exempel

// Run "csc.exe /r:System.dll /out:sample.exe stdstr.cs". UseShellExecute is false because we're specifying
// an executable directly and in this case depending on it being in a PATH folder. By setting
// RedirectStandardOutput to true, the output of csc.exe is directed to the Process.StandardOutput stream
// which is then displayed in this console window directly.
using (Process compiler = new Process())
{
    compiler.StartInfo.FileName = "csc.exe";
    compiler.StartInfo.Arguments = "/r:System.dll /out:sample.exe stdstr.cs";
    compiler.StartInfo.UseShellExecute = false;
    compiler.StartInfo.RedirectStandardOutput = true;
    compiler.Start();

    Console.WriteLine(compiler.StandardOutput.ReadToEnd());

    compiler.WaitForExit();
}

' Run "vbc.exe /reference:Microsoft.VisualBasic.dll /out:sample.exe stdstr.vb". UseShellExecute is False 
' because we're specifying an executable directly and in this case depending on it being in a PATH folder. 
' By setting RedirectStandardOutput to True, the output of csc.exe is directed to the Process.StandardOutput 
' stream which is then displayed in this console window directly.    
Using compiler As New Process()
    compiler.StartInfo.FileName = "vbc.exe"
    compiler.StartInfo.Arguments = "/reference:Microsoft.VisualBasic.dll /out:sample.exe stdstr.vb"
    compiler.StartInfo.UseShellExecute = False
    compiler.StartInfo.RedirectStandardOutput = True
    compiler.Start()

    Console.WriteLine(compiler.StandardOutput.ReadToEnd())

    compiler.WaitForExit()
End Using

Kommentarer

När en Process text skrivs till standardströmmen visas den texten vanligtvis i konsolen. Genom att ange RedirectStandardOutput att true dataströmmen ska omdirigeras StandardOutput kan du ändra eller utelämna utdata från en process. Du kan till exempel filtrera texten, formatera den på ett annat sätt eller skriva utdata till både konsolen och en angiven loggfil.

Den omdirigerade StandardOutput strömmen kan läsas synkront eller asynkront. Metoder som Read, ReadLineoch ReadToEnd utför synkrona läsåtgärder i processens utdataström. Dessa synkrona läsåtgärder slutförs inte förrän de associerade Process skrivningarna till dataströmmen StandardOutput eller stänger strömmen.

Däremot BeginOutputReadLine startar asynkrona läsåtgärder på StandardOutput strömmen. Den här metoden aktiverar en utsedd händelsehanterare (se OutputDataReceived) för strömmens utdata och återgår omedelbart till anroparen, vilket kan utföra annat arbete medan strömutdata dirigeras till händelsehanteraren.

Synkrona läsåtgärder introducerar ett beroende mellan anroparen som läser från StandardOutput strömmen och den underordnade processen som skriver till strömmen. Dessa beroenden kan orsaka dödlägen. När anroparen läser från den omdirigerade strömmen av en underordnad process är den beroende av det underordnade. Anroparen väntar på läsåtgärden tills den underordnade skrivningen till strömmen eller stänger strömmen. När den underordnade processen skriver tillräckligt med data för att fylla den omdirigerade dataströmmen är den beroende av den överordnade dataströmmen. Den underordnade processen väntar på nästa skrivåtgärd tills den överordnade läser från den fullständiga strömmen eller stänger strömmen. Deadlock-villkoret resulterar när anroparen och den underordnade processen väntar på att varandra ska slutföra en åtgärd och ingen av dem kan fortsätta. Du kan undvika dödlägen genom att utvärdera beroenden mellan anroparen och den underordnade processen.

De två sista exemplen Start i det här avsnittet använder metoden för att starta en körbar fil med namnetWrite500Lines.exe. Följande exempel innehåller källkoden.

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.

I följande exempel visas hur du läser från en omdirigerad ström och väntar tills den underordnade processen avslutas. Exemplet undviker ett dödlägesvillkor genom att anropa p.StandardOutput.ReadToEnd före p.WaitForExit. Ett dödläge kan uppstå om den överordnade processen anropar p.WaitForExit före p.StandardOutput.ReadToEnd och den underordnade processen skriver tillräckligt med text för att fylla den omdirigerade strömmen. Den överordnade processen väntar på obestämd tid för att den underordnade processen ska avslutas. Den underordnade processen skulle vänta på obestämd tid för att den överordnade ska läsa från hela StandardOutput dataströmmen.

using System;
using System.Diagnostics;

public class Example2
{
    public static void Main()
    {
        var p = new Process();
        p.StartInfo.UseShellExecute = false;
        p.StartInfo.RedirectStandardOutput = true;
        p.StartInfo.FileName = "Write500Lines.exe";
        p.Start();

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

        Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'");
    }
}
// The example displays the following output:
//      Successfully wrote 500 lines.
//
//      The last 50 characters in the output stream are:
//      'ritten: 99,80%
//      Line 500 of 500 written: 100,00%
//      '

Imports System.Diagnostics'

Public Module Example
   Public Sub Main()
      Dim p As New Process()
      p.StartInfo.UseShellExecute = False  
      p.StartInfo.RedirectStandardOutput = 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.StandardOutput.ReadToEnd()  
      p.WaitForExit()

      Console.WriteLine($"The last 50 characters in the output stream are:\n'{output.Substring(output.Length - 50)}'")
   End Sub
End Module
' The example displays the following output:
'      Successfully wrote 500 lines.
'
'      The last 50 characters in the output stream are:
'      'ritten: 99,80%
'      Line 500 of 500 written: 100,00%
'      '

Det finns ett liknande problem när du läser all text från både standardutdata och standardfelströmmar. I följande exempel utförs en läsåtgärd på båda strömmarna. Det undviker dödläget genom att utföra asynkrona läsåtgärder i dataströmmen StandardError . Ett dödläge resulterar i att den överordnade processen anropar p.StandardOutput.ReadToEnd följt av p.StandardError.ReadToEnd och den underordnade processen skriver tillräckligt med text för att fylla sin felström. Den överordnade processen väntar på obestämd tid för att den underordnade processen ska stänga strömmen StandardOutput . Den underordnade processen skulle vänta på obestämd tid för att den överordnade ska läsa från hela StandardError dataströmmen.

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.

Du kan använda asynkrona läsåtgärder för att undvika dessa beroenden och deras dödlägespotential. Alternativt kan du undvika dödläget genom att skapa två trådar och läsa utdata från varje ström i en separat tråd.

Se även

• UseShellExecute
• StandardOutput