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

Definizione

Ottiene un flusso usato per leggere l'output dell'applicazione.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

Valore della proprietà

Oggetto StreamReader che può essere usato per leggere il flusso di output standard dell'applicazione.A StreamReader that can be used to read the standard output stream of the application.

Eccezioni

Il flusso StandardOutput non è stato definito per il reindirizzamento; assicurarsi che RedirectStandardOutput sia impostato su true e che UseShellExecute sia impostato su false.The StandardOutput stream has not been defined for redirection; ensure RedirectStandardOutput is set to true and UseShellExecute is set to false.

In alternativa-or- Il flusso StandardOutput è stato aperto per operazioni di lettura asincrona con BeginOutputReadLine().The StandardOutput stream has been opened for asynchronous read operations with BeginOutputReadLine().

Esempi

Nell'esempio seguente viene eseguito il comando ipconfig.exe e reindirizza l'output standard alla finestra della console di esempio.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
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

Commenti

Quando un Process scrive il testo nel relativo flusso standard, che sia in genere visualizzato nella console.When a Process writes text to its standard stream, that text is normally displayed on the console. Mediante il reindirizzamento di StandardOutput flusso, è possibile modificare o eliminare l'output di un processo.By redirecting the StandardOutput stream, you can manipulate or suppress the output of a process. Ad esempio, è possibile filtrare il testo, formattarla in modo diverso o scrivere l'output in un file di registro designato sia la console.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Nota

Per utilizzare StandardOutput, è necessario impostare ProcessStartInfo.UseShellExecute al false, ed è necessario impostare ProcessStartInfo.RedirectStandardOutput a true.To use StandardOutput, you must set ProcessStartInfo.UseShellExecute to false, and you must set ProcessStartInfo.RedirectStandardOutput to true. In caso contrario, la lettura dal StandardOutput flusso genera un'eccezione.Otherwise, reading from the StandardOutput stream throws an exception.

Reindirizzato StandardOutput flusso può essere letto in modo sincrono o asincrono.The redirected StandardOutput stream can be read synchronously or asynchronously. I metodi come Read, ReadLine, e ReadToEnd eseguire operazioni di lettura sincrone nel flusso di output del processo.Methods such as Read, ReadLine, and ReadToEnd perform synchronous read operations on the output stream of the process. Questi sincrono letti operazioni non vengono completate finché l'oggetto associato Process scrive relativo StandardOutput streaming, o chiude il flusso.These synchronous read operations do not complete until the associated Process writes to its StandardOutput stream, or closes the stream.

Al contrario, BeginOutputReadLine operazioni di lettura asincrona viene avviata nel StandardOutput flusso.In contrast, BeginOutputReadLine starts asynchronous read operations on the StandardOutput stream. Questo metodo consente a un gestore eventi designato per l'output del flusso e torna immediatamente al chiamante, che può eseguire altre operazioni mentre il flusso output viene indirizzato al gestore dell'evento.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.

Operazioni introducono una dipendenza tra la lettura dal chiamante di lettura sincrona la StandardOutput flusso e il processo figlio la scrittura in tale flusso.Synchronous read operations introduce a dependency between the caller reading from the StandardOutput stream and the child process writing to that stream. Queste dipendenze possono causare condizioni di deadlock.These dependencies can result in deadlock conditions. Quando il chiamante legge dal flusso di reindirizzamento di un processo figlio, è dipendente dal figlio.When the caller reads from the redirected stream of a child process, it is dependent on the child. Il chiamante attende l'operazione di lettura fino a quando l'elemento figlio scrive nel flusso o chiude il flusso.The caller waits on the read operation until the child writes to the stream or closes the stream. Quando il processo figlio scrive dati sufficienti per riempire il relativo flusso reindirizzata, dipende dal padre.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. Il processo figlio resta in attesa durante la successiva operazione di scrittura fino a quando l'elemento padre legge dal flusso completo o chiude il flusso.The child process waits on the next write operation until the parent reads from the full stream or closes the stream. La condizione di deadlock quando il chiamante e il processo figlio di attesa tra loro per completare un'operazione e non può continuare.The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. È possibile evitare i deadlock valutando le dipendenze tra il chiamante e il processo figlio.You can avoid deadlocks by evaluating dependencies between the caller and child process.

Gli ultimi due esempi in questa sezione si usa la Start metodo per avviare un eseguibile denominato Write500Lines.exe.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. L'esempio seguente contiene il codice sorgente.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.

Nell'esempio seguente viene illustrato come leggere da un flusso reindirizzato e attendere il chiusura del processo figlio.The following example shows how to read from a redirected stream and wait for the child process to exit. L'esempio consente di evitare una condizione di deadlock chiamando p.StandardOutput.ReadToEnd prima di p.WaitForExit.The example avoids a deadlock condition by calling p.StandardOutput.ReadToEnd before p.WaitForExit. Una condizione di deadlock può verificarsi se il processo padre chiama p.WaitForExit prima di p.StandardOutput.ReadToEnd e il processo figlio scrive testo sufficiente a riempire reindirizzato.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. Il processo padre verrebbe attendere in modo indefinito la terminazione del processo figlio.The parent process would wait indefinitely for the child process to exit. Il processo figlio sarebbe indefinitamente in attesa per l'elemento padre da cui leggere l'intero StandardOutput flusso.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%
'      '

Si verifica un problema simile quando si legge tutto il testo da flussi di errore e output standard.There is a similar issue when you read all text from both the standard output and standard error streams. Nell'esempio seguente esegue un'operazione di lettura su entrambi i flussi.The following example performs a read operation on both streams. Evita la condizione di deadlock mediante l'esecuzione asincrona di operazioni di lettura su di StandardError flusso.It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Una condizione di deadlock dei risultati, se il processo padre chiama p.StandardOutput.ReadToEnd seguita da p.StandardError.ReadToEnd e il processo figlio scrive testo sufficiente a riempire il flusso di errore.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. Il processo padre viene attesa indefinita per il chiusura del processo figlio relativa StandardOutput flusso.The parent process would wait indefinitely for the child process to close its StandardOutput stream. Il processo figlio sarebbe indefinitamente in attesa per l'elemento padre da cui leggere l'intero StandardError flusso.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.

È possibile usare operazioni di lettura asincrona per evitare queste dipendenze e i deadlock potenziale.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. In alternativa, è possibile evitare la condizione di deadlock creando due thread e leggere l'output di ogni flusso in un thread separato.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Nota

È possibile combinare le operazioni di lettura sincrone e asincrone su un flusso reindirizzato.You cannot mix asynchronous and synchronous read operations on a redirected stream. Una volta reindirizzato di un' Process viene aperto in modalità asincrona o sincrona, tutte le successive lettura operazioni su tale flusso devono essere la stessa modalità.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. Ad esempio, non seguire BeginOutputReadLine con una chiamata a ReadLine nel StandardOutput flusso, o viceversa.For example, do not follow BeginOutputReadLine with a call to ReadLine on the StandardOutput stream, or vice versa. Tuttavia, è possibile leggere due flussi diversi in modi diversi.However, you can read two different streams in different modes. Ad esempio, è possibile chiamare BeginOutputReadLine e quindi chiamare ReadLine per il StandardError flusso.For example, you can call BeginOutputReadLine and then call ReadLine for the StandardError stream.

Sicurezza

LinkDemand
per un'attendibilità totale per il chiamante immediato.for full trust for the immediate caller. Impossibile utilizzare questo membro in codice parzialmente attendibile.This member cannot be used by partially trusted code.

Si applica a

Vedi anche