Process.StandardOutput Özellik

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

Özellik Değeri

StreamReader Uygulamanın standart çıkış akışını okumak için kullanılabilecek bir.

Öznitelikler

BrowsableAttribute

Özel durumlar

Örnekler

Aşağıdaki örnek ipconfig.exe komutunu çalıştırır ve standart çıktısını örneğin konsol penceresine yönlendirir.

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

Açıklamalar

Bir Process metin standart akışına yazıldığında, bu metin normalde konsolda görüntülenir. Akışı yeniden yönlendirerek StandardOutput bir işlemin çıkışını işleyebilir veya gizleyebilirsiniz. Örneğin, metni filtreleyebilir, farklı biçimlendirebilir veya çıkışı hem konsola hem de belirlenmiş bir günlük dosyasına yazabilirsiniz.

Yeniden yönlendirilen StandardOutput akış zaman uyumlu veya zaman uyumsuz olarak okunabilir. , ReadLineve ReadToEnd gibi Readyöntemler, işlemin çıkış akışında zaman uyumlu okuma işlemleri gerçekleştirir. Bu zaman uyumlu okuma işlemleri, ilişkili Process yazma akışına StandardOutput yazılana veya akışı kapatana kadar tamamlanmaz.

Buna karşılık, BeginOutputReadLine akışta StandardOutput zaman uyumsuz okuma işlemleri başlatır. Bu yöntem, akış çıkışı için belirlenmiş bir olay işleyicisini etkinleştirir ve hemen çağırana döner ve akış çıkışı olay işleyicisine yönlendirilirken diğer işleri gerçekleştirebilir.

Zaman uyumlu okuma işlemleri, çağıranın akıştan StandardOutput okuması ile bu akışa yazma alt işlemi arasında bir bağımlılık oluşturur. Bu bağımlılıklar kilitlenme koşullarına neden olabilir. Çağıran bir alt işlemin yeniden yönlendirilen akışından okursa, alt öğeye bağımlıdır. Çağıran, alt öğe akışa yazana veya akışı kapatana kadar okuma işleminde bekler. Alt işlem yeniden yönlendirilen akışını doldurmak için yeterli veri yazdığında, üst öğeye bağımlıdır. Alt işlem, üst öğe tam akıştan okuyana veya akışı kapatana kadar bir sonraki yazma işleminde bekler. Kilitlenme koşulu, çağıranın ve alt işlemin bir işlemi tamamlamak için birbirleri üzerinde beklemesi ve devam etmemesini sağlar. Çağıran ile alt işlem arasındaki bağımlılıkları değerlendirerek kilitlenmeleri önleyebilirsiniz.

Bu bölümdeki son iki örnek, Write500Lines.exeadlı bir yürütülebilir dosyayı başlatmak için yöntemini kullanırStart. Aşağıdaki örnek kaynak kodunu içerir.

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.

Aşağıdaki örnekte, yeniden yönlendirilen bir akıştan okuma ve alt işlemin çıkmasını bekleme işlemleri gösterilmektedir. Örnek, önce p.WaitForExitçağrısı p.StandardOutput.ReadToEnd yaparak kilitlenme koşulundan kaçınıyor. Üst işlem daha önce p.StandardOutput.ReadToEnd çağırırsa p.WaitForExit ve alt işlem yeniden yönlendirilen akışı doldurmak için yeterli metin yazarsa kilitlenme koşulu oluşabilir. Üst işlem, alt işlemin çıkması için süresiz olarak bekler. Üst işlemin tam StandardOutput akıştan okuması için alt işlem süresiz olarak bekler.

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

Hem standart çıktıdan hem de standart hata akışlarından tüm metni okuduğunuzda benzer bir sorun oluşur. Aşağıdaki örnek, her iki akışta da bir okuma işlemi gerçekleştirir. Akışta zaman uyumsuz okuma işlemleri gerçekleştirerek kilitlenme koşulunu StandardError önler. Bir kilitlenme koşulu, üst işlemin çağrıları p.StandardOutput.ReadToEnd ve p.StandardError.ReadToEnd alt işlemin hata akışını doldurmak için yeterli metin yazması durumunda sonuçlanır. Üst işlem, alt işlemin akışını kapatması StandardOutput için süresiz olarak bekler. Üst işlemin tam StandardError akıştan okuması için alt işlem süresiz olarak bekler.

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.

Bu bağımlılıkları ve kilitlenme potansiyellerini önlemek için zaman uyumsuz okuma işlemlerini kullanabilirsiniz. Alternatif olarak, iki iş parçacığı oluşturup her akışın çıkışını ayrı bir iş parçacığında okuyarak kilitlenme durumundan kaçınabilirsiniz.

Şunlara uygulanır

Ayrıca bkz.

• StandardInput
• StandardError
• RedirectStandardOutput