Process.StandardOutput Proprietà
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Ottiene un flusso usato per leggere l'output dell'applicazione.
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.StreamReaderPublic ReadOnly Property StandardOutput As StreamReaderValore della proprietà
Oggetto StreamReader che può essere usato per leggere il flusso di output standard dell'applicazione.
- Attributi
Eccezioni
Il flusso StandardOutput non è stato definito per il reindirizzamento; assicurarsi che RedirectStandardOutput sia impostato su true e che UseShellExecute sia impostato su false.
-oppure-
Il flusso StandardOutput è stato aperto per operazioni di lettura asincrona con BeginOutputReadLine().
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.
Nota
Per usare StandardOutput, è necessario impostare ProcessStartInfo.UseShellExecute su falsee è necessario impostare ProcessStartInfo.RedirectStandardOutput su true. In caso contrario, la lettura dal flusso genera un'eccezione StandardOutput .
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.
Nota
Non è possibile combinare operazioni di lettura asincrone e sincrone in un flusso reindirizzato. Una volta aperto il flusso reindirizzato di un Process oggetto in modalità asincrona o sincrona, tutte le operazioni di lettura aggiuntive su tale flusso devono trovarsi nella stessa modalità. Ad esempio, non seguire BeginOutputReadLine con una chiamata al ReadLineStandardOutput flusso o viceversa. Tuttavia, è possibile leggere due flussi diversi in modalità diverse. Ad esempio, è possibile chiamare e quindi chiamare BeginOutputReadLineReadLine il StandardError flusso.
