Partager via


ProcessStartInfo.RedirectStandardOutput Propriété

Définition

Obtient ou définit une valeur qui indique si la sortie textuelle d’une application est écrite dans le flux StandardOutput.

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

Valeur de propriété

true si la sortie doit être écrite dans StandardOutput ; sinon, false. La valeur par défaut est false.

Exemples

// Run "cl.exe /cld stdstr.cpp /link /out:sample.exe". 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 cl.exe is directed to the Process.StandardOutput stream
// which is then displayed in this console window directly.    
Process^ compiler = gcnew Process;
compiler->StartInfo->FileName = "cl.exe";
compiler->StartInfo->Arguments = "/clr stdstr.cpp /link /out:sample.exe";
compiler->StartInfo->UseShellExecute = false;
compiler->StartInfo->RedirectStandardOutput = true;
compiler->Start();

Console::WriteLine( compiler->StandardOutput->ReadToEnd() );

compiler->WaitForExit();
// 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

Remarques

Lorsqu’un Process texte écrit dans son flux standard, ce texte s’affiche généralement sur la console. En définissant sur RedirectStandardOutputtrue pour rediriger le StandardOutput flux, vous pouvez manipuler ou supprimer la sortie d’un processus. Par exemple, vous pouvez filtrer le texte, le mettre en forme différemment ou écrire la sortie dans la console et dans un fichier journal désigné.

Notes

Vous devez définir UseShellExecute sur false si vous souhaitez définir sur trueRedirectStandardOutput . Sinon, la lecture à partir du StandardOutput flux lève une exception.

Le flux redirigé StandardOutput peut être lu de manière synchrone ou asynchrone. Des méthodes telles que Read, ReadLineet ReadToEnd effectuent des opérations de lecture synchrone sur le flux de sortie du processus. Ces opérations de lecture synchrone ne se terminent pas tant que les écritures associées Process dans son StandardOutput flux ne sont pas terminées ou que le flux ne ferme pas.

En revanche, démarre les BeginOutputReadLine opérations de lecture asynchrones sur le StandardOutput flux. Cette méthode active un gestionnaire d’événements désigné (voir OutputDataReceived) pour la sortie du flux et retourne immédiatement à l’appelant, qui peut effectuer d’autres travaux pendant que la sortie du flux est dirigée vers le gestionnaire d’événements.

Notes

L’application qui traite la sortie asynchrone doit appeler la WaitForExit méthode pour s’assurer que la mémoire tampon de sortie a été vidée.

Les opérations de lecture synchrone introduisent une dépendance entre la lecture de l’appelant à partir du StandardOutput flux et l’écriture du processus enfant dans ce flux. Ces dépendances peuvent provoquer des conditions d’interblocage. Lorsque l’appelant lit à partir du flux redirigé d’un processus enfant, il dépend de l’enfant. L’appelant attend l’opération de lecture jusqu’à ce que l’enfant écrive dans le flux ou ferme le flux. Lorsque le processus enfant écrit suffisamment de données pour remplir son flux redirigé, il dépend du parent. Le processus enfant attend l’opération d’écriture suivante jusqu’à ce que le parent lise à partir du flux complet ou ferme le flux. La condition d’interblocage se produit lorsque l’appelant et le processus enfant attendent l’un de l’autre pour terminer une opération, et aucun des deux ne peut continuer. Vous pouvez éviter les interblocages en évaluant les dépendances entre l’appelant et le processus enfant.

Les deux derniers exemples de cette section utilisent la Start méthode pour lancer un exécutable nommé Write500Lines.exe. L’exemple suivant contient son code source.

using System;
using System.IO;

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:
//      The last 50 characters in the output stream are:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//'
//
//      Error stream: 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:
'      The last 50 characters in the output stream are:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'
'
'      Error stream: Successfully wrote 500 lines.

L’exemple suivant montre comment lire à partir d’un flux redirigé et attendre que le processus enfant se termine. L’exemple évite une condition d’interblocage en appelant p.StandardOutput.ReadToEnd avant p.WaitForExit. Une condition d’interblocage peut se produire si le processus parent appelle p.WaitForExit avant p.StandardOutput.ReadToEnd et si le processus enfant écrit suffisamment de texte pour remplir le flux redirigé. Le processus parent attendrait indéfiniment que le processus enfant se termine. Le processus enfant attendrait indéfiniment que le parent lise à partir du flux complet StandardOutput .

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:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//      '
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:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'      '

Il existe un problème similaire lorsque vous lisez tout le texte à partir des flux d’erreur standard et de sortie standard. L’exemple suivant effectue une opération de lecture sur les deux flux. Il évite la condition d’interblocage en effectuant des opérations de lecture asynchrones sur le StandardError flux. Une condition d’interblocage se produit si le processus parent appelle p.StandardOutput.ReadToEnd suivi de p.StandardError.ReadToEnd et si le processus enfant écrit suffisamment de texte pour remplir son flux d’erreurs. Le processus parent attendrait indéfiniment que le processus enfant ferme son StandardOutput flux. Le processus enfant attendrait indéfiniment que le parent lise à partir du flux complet StandardError .

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:
//      ' 49,800.20%
//      Line 500 of 500 written: 49,900.20%
//      '
//
//      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:
'      ' 49,800.20%
'      Line 500 of 500 written: 49,900.20%
'      '
'
'      Error stream: Successfully wrote 500 lines.

Vous pouvez utiliser des opérations de lecture asynchrones pour éviter ces dépendances et leur potentiel d’interblocage. Vous pouvez également éviter la condition d’interblocage en créant deux threads et en lisant la sortie de chaque flux sur un thread distinct.

S’applique à

Voir aussi