Udostępnij za pośrednictwem


Process.StandardOutput Właściwość

Definicja

Pobiera strumień używany do odczytywania tekstowych danych wyjściowych aplikacji.

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

Wartość właściwości

Element StreamReader , który może służyć do odczytywania standardowego strumienia wyjściowego aplikacji.

Atrybuty

Wyjątki

Strumień StandardOutput nie został zdefiniowany dla przekierowania; upewnij się RedirectStandardOutput , że ustawiono wartość true i UseShellExecute ustawiono wartość false.

-lub-

Strumień StandardOutput został otwarty dla asynchronicznych operacji odczytu za pomocą polecenia BeginOutputReadLine().

Przykłady

Poniższy przykład uruchamia polecenie ipconfig.exe i przekierowuje standardowe dane wyjściowe do okna konsoli przykładu.

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

Uwagi

Process Gdy tekst jest zapisywany w standardowym strumieniu, tekst jest zwykle wyświetlany w konsoli programu . Przekierowując StandardOutput strumień, można manipulować lub pomijać dane wyjściowe procesu. Można na przykład filtrować tekst, formatować go inaczej lub zapisywać dane wyjściowe zarówno w konsoli, jak i w wyznaczonym pliku dziennika.

Uwaga

Aby użyć StandardOutputelementu , musisz ustawić falsewartość ProcessStartInfo.UseShellExecute i musisz ustawić truewartość ProcessStartInfo.RedirectStandardOutput . W przeciwnym razie odczyt ze strumienia StandardOutput zgłasza wyjątek.

Przekierowany StandardOutput strumień można odczytywać synchronicznie lub asynchronicznie. Metody takie jak Read, ReadLinei ReadToEnd wykonują synchroniczne operacje odczytu na strumieniu wyjściowym procesu. Te synchroniczne operacje odczytu nie są wykonywane, dopóki skojarzony z nim ProcessStandardOutput zapis nie zostanie zamknięty lub nie zamknie strumienia.

Z kolei BeginOutputReadLine operacje odczytu asynchronicznego są uruchamiane w strumieniu StandardOutput . Ta metoda umożliwia wyznaczoną procedurę obsługi zdarzeń dla danych wyjściowych strumienia i natychmiast wraca do elementu wywołującego, co może wykonać inną pracę, gdy dane wyjściowe strumienia są kierowane do programu obsługi zdarzeń.

Synchroniczne operacje odczytu wprowadzają zależność między odczytywaniem elementu wywołującego ze strumienia StandardOutput a procesem podrzędnym zapisu w tym strumieniu. Te zależności mogą powodować warunki zakleszczenia. Gdy obiekt wywołujący odczytuje z przekierowanego strumienia procesu podrzędnego, jest on zależny od elementu podrzędnego. Obiekt wywołujący czeka na operację odczytu do momentu zapisania podrzędnego do strumienia lub zamknięcia strumienia. Gdy proces podrzędny zapisuje wystarczającą ilość danych, aby wypełnić przekierowany strumień, jest zależny od elementu nadrzędnego. Proces podrzędny czeka na następną operację zapisu, dopóki element nadrzędny nie odczytuje z pełnego strumienia lub zamknie strumień. Warunek zakleszczenia powoduje, że wywołanie i proces podrzędny czekają na siebie nawzajem, aby ukończyć operację, i nie można kontynuować. Można uniknąć zakleszczeń, oceniając zależności między obiektem wywołującym a procesem podrzędnym.

W dwóch ostatnich przykładach w tej sekcji użyto Start metody , aby uruchomić plik wykonywalny o nazwie Write500Lines.exe. Poniższy przykład zawiera kod źródłowy.

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.

W poniższym przykładzie pokazano, jak odczytywać z przekierowanego strumienia i czekać na zakończenie procesu podrzędnego. W tym przykładzie nie ma warunku zakleszczenia przez wywołanie p.StandardOutput.ReadToEnd metody przed p.WaitForExit. Warunek zakleszczenia może spowodować wywołanie p.WaitForExit procesu nadrzędnego przed i p.StandardOutput.ReadToEnd proces podrzędny zapisuje wystarczająco dużo tekstu, aby wypełnić przekierowany strumień. Proces nadrzędny będzie czekać na zakończenie procesu podrzędnego przez czas nieokreślony. Proces podrzędny czekałby na czas nieokreślony, aż element nadrzędny będzie odczytywał z pełnego StandardOutput strumienia.

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%
'      '

Podobny problem występuje podczas odczytywania całego tekstu zarówno ze standardowych strumieni danych wyjściowych, jak i standardowych błędów. Poniższy przykład wykonuje operację odczytu na obu strumieniach. Pozwala uniknąć warunku zakleszczenia, wykonując asynchroniczne operacje odczytu w strumieniu StandardError . Warunek zakleszczenia jest wynikiem wywołań p.StandardOutput.ReadToEnd procesu nadrzędnego, po którym następuje p.StandardError.ReadToEnd proces podrzędny, a proces podrzędny zapisuje wystarczająco dużo tekstu, aby wypełnić strumień błędu. Proces nadrzędny będzie czekać na czas nieokreślony, aż proces podrzędny zamknie strumień StandardOutput . Proces podrzędny czekałby na czas nieokreślony, aż element nadrzędny będzie odczytywał z pełnego StandardError strumienia.

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.

Możesz użyć asynchronicznych operacji odczytu, aby uniknąć tych zależności i ich potencjału zakleszczenia. Alternatywnie można uniknąć stanu zakleszczenia, tworząc dwa wątki i odczytując dane wyjściowe każdego strumienia w osobnym wątku.

Uwaga

Nie można mieszać asynchronicznych i synchronicznych operacji odczytu na przekierowanym strumieniu. Po otwarciu przekierowanego strumienia obiektu Process w trybie asynchronicznym lub synchronicznym wszystkie dalsze operacje odczytu na tym strumieniu muszą być w tym samym trybie. Na przykład nie należy wykonywać wywołania BeginOutputReadLine metody ReadLine w strumieniu StandardOutput ani odwrotnie. Można jednak odczytywać dwa różne strumienie w różnych trybach. Możesz na przykład wywołać BeginOutputReadLine metodę , a następnie wywołać ReadLineStandardError strumień.

Dotyczy

Zobacz też