Process.StandardOutput Process.StandardOutput Process.StandardOutput Process.StandardOutput Property

Définition

Obtient un flux utilisé pour lire la sortie textuelle de l'application.Gets a stream used to read the textual output of the application.

public:
 property System::IO::StreamReader ^ StandardOutput { System::IO::StreamReader ^ get(); };
[System.ComponentModel.Browsable(false)]
public System.IO.StreamReader StandardOutput { get; }
member this.StandardOutput : System.IO.StreamReader
Public ReadOnly Property StandardOutput As StreamReader

Valeur de propriété

StreamReader qui peut être utilisé pour lire le flux de sortie standard de l'application.A StreamReader that can be used to read the standard output stream of the application.

Exceptions

Le flux StandardOutput n’a pas été défini pour la redirection ; vérifiez que les propriétés RedirectStandardOutput et UseShellExecute ont respectivement pour valeur true et false.The StandardOutput stream has not been defined for redirection; ensure RedirectStandardOutput is set to true and UseShellExecute is set to false.

ou-or- Le flux StandardOutput a été ouvert pour des opérations de lecture asynchrones avec BeginOutputReadLine().The StandardOutput stream has been opened for asynchronous read operations with BeginOutputReadLine().

Exemples

L’exemple suivant exécute la commande ipconfig. exe et redirige sa sortie standard vers la fenêtre de console de l’exemple.The following example runs the ipconfig.exe command and redirects its standard output to the example's console window.

using namespace System;
using namespace System::IO;
using namespace System::Diagnostics;

int main()
{
    Process^ process = gcnew Process();
    process->StartInfo->FileName = "ipconfig.exe";
    process->StartInfo->UseShellExecute = false;
    process->StartInfo->RedirectStandardOutput = true;
    process->Start();

    // Synchronously read the standard output of the spawned process-> 
    StreamReader^ reader = process->StandardOutput;
    String^ output = reader->ReadToEnd();

    // Write the redirected output to this application's window.
    Console::WriteLine(output);

    process->WaitForExit();
    process->Close();

    Console::WriteLine("\n\nPress any key to exit");
    Console::ReadLine();
    return 0;
}
using System;
using System.IO;
using System.Diagnostics;

class StandardOutputExample
{
    public static void Main()
    {
        using (Process process = new Process())
        {
            process.StartInfo.FileName = "ipconfig.exe";
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardOutput = true;
            process.Start();

            // Synchronously read the standard output of the spawned process. 
            StreamReader reader = process.StandardOutput;
            string output = reader.ReadToEnd();

            // Write the redirected output to this application's window.
            Console.WriteLine(output);

            process.WaitForExit();
        }

        Console.WriteLine("\n\nPress any key to exit.");
        Console.ReadLine();
    }
}
Imports System.IO
Imports System.Diagnostics

Module Module1
    Sub Main()
        Using process As New Process()
            process.StartInfo.FileName = "ipconfig.exe"
            process.StartInfo.UseShellExecute = False
            process.StartInfo.RedirectStandardOutput = True
            process.Start()

            ' Synchronously read the standard output of the spawned process. 
            Dim reader As StreamReader = process.StandardOutput
            Dim output As String = reader.ReadToEnd()
            Console.WriteLine(output)

            process.WaitForExit()
        End Using

        Console.WriteLine(Environment.NewLine + Environment.NewLine + "Press any key to exit.")
        Console.ReadLine()
    End Sub
End Module

Remarques

Quand un Process écrit du texte dans son flux standard, ce texte est normalement affiché sur la console.When a Process writes text to its standard stream, that text is normally displayed on the console. En redirigeant le StandardOutput flux, vous pouvez manipuler ou supprimer la sortie d’un processus.By redirecting the StandardOutput stream, you can manipulate or suppress the output of a process. 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é.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Notes

Pour utiliser StandardOutput, vous devez affecter ProcessStartInfo.UseShellExecute à falsela valeur, et vous ProcessStartInfo.RedirectStandardOutput devez trueaffecter à la valeur.To use StandardOutput, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardOutput to true. Sinon, la lecture à StandardOutput partir du flux lève une exception.Otherwise, reading from the StandardOutput stream throws an exception.

Le StandardOutput flux Redirigé peut être lu de façon synchrone ou asynchrone.The redirected StandardOutput stream can be read synchronously or asynchronously. Les méthodes telles Readque ReadLine, et ReadToEnd effectuent des opérations de lecture synchrones sur le flux de sortie du processus.Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the output stream of the process. Ces opérations de lecture synchrones ne se terminent Process pas tant que StandardOutput les écritures associées n’ont pas été écrites dans son flux, ou fermé le flux.These synchronous read operations do not complete until the associated Process writes to its StandardOutput stream, or closes the stream.

En revanche, BeginOutputReadLine démarre les opérations de lecture asynchrones sur le StandardOutput flux.In contrast, BeginOutputReadLine starts asynchronous read operations on the StandardOutput stream. Cette méthode active un gestionnaire d’événements désigné pour la sortie de flux et retourne immédiatement à l’appelant, qui peut effectuer d’autres tâches pendant que la sortie du flux est dirigée vers le gestionnaire d’événements.This method enables a designated event handler for the stream output and immediately returns to the caller, which can perform other work while the stream output is directed to the event handler.

Les opérations de lecture synchrones introduisent une dépendance entre l' StandardOutput appelant lisant à partir du flux et le processus enfant qui écrit dans ce flux.Synchronous read operations introduce a dependency between the caller reading from the StandardOutput stream and the child process writing to that stream. Ces dépendances peuvent entraîner des conditions de blocage.These dependencies can result in deadlock conditions. Lorsque l’appelant lit à partir du flux Redirigé d’un processus enfant, il est dépendant de l’enfant.When the caller reads from the redirected stream of a child process, it is dependent on the child. L’appelant attend l’opération de lecture jusqu’à ce que l’enfant écrit dans le flux ou ferme le flux.The caller waits on the read operation until the child writes to the stream or closes the stream. Lorsque le processus enfant écrit suffisamment de données pour remplir son flux Redirigé, il est dépendant du parent.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. Le processus enfant attend lors de l’opération d’écriture suivante jusqu’à ce que le parent Lise à partir du flux complet ou ferme le flux.The child process waits on the next write operation until the parent reads from the full stream or closes the stream. La condition de blocage se produit lorsque l’appelant et le processus enfant attendent les uns les autres pour terminer une opération, et ni continuer.The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. Vous pouvez éviter les interblocages en évaluant les dépendances entre l’appelant et le processus enfant.You can avoid deadlocks by evaluating dependencies between the caller and child process.

Les deux derniers exemples de cette section utilisent la Start méthode pour lancer un exécutable nommé Write500Lines. exe.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. L’exemple suivant contient son code source.The following example contains its source code.

using System;
using System.IO;

public class Example
{
   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 un flux Redirigé et attendre la fin du processus enfant.The following example shows how to read from a redirected stream and wait for the child process to exit. L’exemple évite une condition de blocage en appelant p.StandardOutput.ReadToEnd Before p.WaitForExit.The example avoids a deadlock condition by calling p.StandardOutput.ReadToEnd before p.WaitForExit. Une condition de blocage peut se produire si le processus p.WaitForExit parent p.StandardOutput.ReadToEnd appelle avant et que le processus enfant écrit suffisamment de texte pour remplir le flux Redirigé.A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardOutput.ReadToEnd and the child process writes enough text to fill the redirected stream. Le processus parent attend indéfiniment que le processus enfant se termine.The parent process would wait indefinitely for the child process to exit. Le processus enfant attend indéfiniment que le parent Lise le flux complet StandardOutput .The child process would wait indefinitely for the parent to read from the full StandardOutput stream.

using System;
using System.Diagnostics;

public class Example
{
   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%
'      '

Un problème similaire se produit lorsque vous lisez tout le texte de la sortie standard et des flux d’erreurs standard.There is a similar issue when you read all text from both the standard output and standard error streams. L’exemple suivant effectue une opération de lecture sur les deux flux.The following example performs a read operation on both streams. Elle évite la condition de blocage en effectuant des opérations de lecture StandardError asynchrones sur le flux.It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Une condition de blocage se produit si le processus p.StandardOutput.ReadToEnd parent appelle p.StandardError.ReadToEnd suivi de et le processus enfant écrit suffisamment de texte pour remplir son flux d’erreurs.A deadlock condition results if the parent process calls p.StandardOutput.ReadToEnd followed by p.StandardError.ReadToEnd and the child process writes enough text to fill its error stream. Le processus parent attend indéfiniment que le processus enfant ferme son StandardOutput flux.The parent process would wait indefinitely for the child process to close its StandardOutput stream. Le processus enfant attend indéfiniment que le parent Lise le flux complet StandardError .The child process would wait indefinitely for the parent to read from the full StandardError stream.

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 de blocage.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. Vous pouvez également éviter la condition de blocage en créant deux threads et en lisant la sortie de chaque flux sur un thread distinct.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Notes

Vous ne pouvez pas mélanger des opérations de lecture asynchrones et synchrones sur un flux Redirigé.You cannot mix asynchronous and synchronous read operations on a redirected stream. Une fois que le flux Redirigé d' Process un a été ouvert en mode asynchrone ou synchrone, toutes les opérations de lecture supplémentaires sur ce flux doivent être dans le même mode.Once the redirected stream of a Process is opened in either asynchronous or synchronous mode, all further read operations on that stream must be in the same mode. Par exemple, ne suivez BeginOutputReadLine pas un appel à ReadLine sur le StandardOutput flux, ou vice versa.For example, do not follow BeginOutputReadLine with a call to ReadLine on the StandardOutput stream, or vice versa. Toutefois, vous pouvez lire deux flux différents dans différents modes.However, you can read two different streams in different modes. Par exemple, vous pouvez appeler BeginOutputReadLine , puis appeler ReadLine pour le StandardError flux.For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

Sécurité

LinkDemand
pour une confiance totale pour l’appelant immédiat.for full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code d'un niveau de confiance partiel.This member cannot be used by partially trusted code.

S’applique à

Voir aussi