Process.StandardOutput Proprietà

public:
 property System::IO::StreamReader ^ StandardOutput { System::IO::StreamReader ^ get(); };

public System.IO.StreamReader StandardOutput { get; }

[System.ComponentModel.Browsable(false)]
public System.IO.StreamReader StandardOutput { get; }

member this.StandardOutput : System.IO.StreamReader

[<System.ComponentModel.Browsable(false)>]
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.

Attributi

BrowsableAttribute

Eccezioni

Esempio

L'esempio seguente esegue il comando ipconfig.exe e reindirizza l'output standard alla finestra della console dell'esempio.

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

Commenti

Quando un Process testo scrive nel flusso standard, questo testo viene normalmente visualizzato nella console. Reindirizzando il flusso, è possibile modificare o eliminare l'output StandardOutput di un processo. Ad esempio, è possibile filtrare il testo, formattarlo in modo diverso o scrivere l'output nella console e in un file di log designato.

Il flusso reindirizzato StandardOutput può essere letto in modo sincrono o asincrono. Metodi come Read, ReadLinee ReadToEnd eseguono operazioni di lettura sincrone nel flusso di output del processo. Queste operazioni di lettura sincrone non vengono completate fino a quando le scritture StandardOutput associate Process al flusso non vengono completate o chiude il flusso.

Al contrario, BeginOutputReadLine avvia operazioni di lettura asincrone nel StandardOutput flusso. Questo metodo abilita un gestore eventi designato per l'output del flusso e restituisce immediatamente al chiamante, che può eseguire altre operazioni mentre l'output del flusso viene indirizzato al gestore eventi.

Le operazioni di lettura sincrone introducono una dipendenza tra la lettura del chiamante dal StandardOutput flusso e il processo figlio che scrive in tale flusso. Queste dipendenze possono causare condizioni di deadlock. Quando il chiamante legge dal flusso reindirizzato di un processo figlio, dipende dal figlio. Il chiamante attende l'operazione di lettura fino a quando il figlio scrive nel flusso o chiude il flusso. Quando il processo figlio scrive dati sufficienti per riempire il flusso reindirizzato, dipende dall'elemento padre. Il processo figlio attende l'operazione di scrittura successiva fino a quando l'elemento padre legge dal flusso completo o chiude il flusso. La condizione deadlock risulta quando il chiamante e il processo figlio attendono l'uno dall'altro per completare un'operazione e nessuno può procedere. È possibile evitare deadlock valutando le dipendenze tra il chiamante e il processo figlio.

Gli ultimi due esempi di questa sezione usano il Start metodo per avviare un eseguibile denominato Write500Lines.exe. L'esempio seguente contiene il codice sorgente.

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.

Nell'esempio seguente viene illustrato come leggere da un flusso reindirizzato e attendere l'uscita del processo figlio. Nell'esempio viene evitata una condizione di deadlock chiamando p.StandardOutput.ReadToEnd prima p.WaitForExitdi . Una condizione di deadlock può causare se il processo padre chiama p.WaitForExit prima p.StandardOutput.ReadToEnd e il processo figlio scrive testo sufficiente per riempire il flusso reindirizzato. Il processo padre attende in modo indefinito l'uscita dal processo figlio. Il processo figlio attende in modo indefinito che l'elemento padre venga letto dal flusso completo 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%
'      '

Si verifica un problema simile quando si legge tutto il testo sia dall'output standard che dai flussi di errore standard. Nell'esempio seguente viene eseguita un'operazione di lettura in entrambi i flussi. Evita la condizione di deadlock eseguendo operazioni di lettura asincrone nel StandardError flusso. Una condizione di deadlock restituisce se il processo padre chiama p.StandardOutput.ReadToEnd e p.StandardError.ReadToEnd il processo figlio scrive testo sufficiente per riempire il flusso di errori. Il processo padre attende in modo indefinito il processo figlio per chiudere StandardOutput il flusso. Il processo figlio attende in modo indefinito che l'elemento padre venga letto dal flusso completo 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.

È possibile usare operazioni di lettura asincrone per evitare queste dipendenze e il potenziale di deadlock. In alternativa, è possibile evitare la condizione di deadlock creando due thread e leggendo l'output di ogni flusso in un thread separato.

Si applica a

Vedi anche

• StandardInput
• StandardError
• RedirectStandardOutput