Process.StandardError Özellik

Tanım

Ad Alanı:

System.Diagnostics

Bütünleştirilmiş Kod:

System.Diagnostics.Process.dll

Kaynak:

Process.cs

Uygulamanın hata çıkışını okumak için kullanılan bir akış alır.

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

public System.IO.StreamReader StandardError { get; }

member this.StandardError : System.IO.StreamReader

Public ReadOnly Property StandardError As StreamReader

Özellik Değeri

StreamReader

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

Özel durumlar

InvalidOperationException

Akış StandardError yeniden yönlendirme için tanımlanmadı; olarak ayarlandığından true ve UseShellExecute olarak ayarlandığından falseemin olunRedirectStandardError.

-veya-

Akışı StandardError ile BeginErrorReadLine()zaman uyumsuz okuma işlemleri için açıldı.

Örnekler

Aşağıdaki örnek, bir ağ kaynağını eşlemek net use için komutunu kullanıcı tarafından sağlanan bağımsız değişkenle birlikte kullanır. Ardından net komutunun standart hata akışını okur ve konsola yazar.

Process^ myProcess = gcnew Process;
ProcessStartInfo^ myProcessStartInfo = gcnew ProcessStartInfo( "net ",String::Concat( "use ", args[ 0 ] ) );

myProcessStartInfo->UseShellExecute = false;
myProcessStartInfo->RedirectStandardError = true;
myProcess->StartInfo = myProcessStartInfo;
myProcess->Start();

StreamReader^ myStreamReader = myProcess->StandardError;
// Read the standard error of net.exe and write it on to console.
Console::WriteLine( myStreamReader->ReadLine() );
myProcess->Close();

using (Process myProcess = new Process())
{
    ProcessStartInfo myProcessStartInfo = new ProcessStartInfo("net ", "use " + args[0]);

    myProcessStartInfo.UseShellExecute = false;
    myProcessStartInfo.RedirectStandardError = true;
    myProcess.StartInfo = myProcessStartInfo;
    myProcess.Start();

    StreamReader myStreamReader = myProcess.StandardError;
    // Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine());
}

Using myProcess As New Process()
    Dim myProcessStartInfo As New ProcessStartInfo("net ", "use " + args(0))

    myProcessStartInfo.UseShellExecute = False
    myProcessStartInfo.RedirectStandardError = True
    myProcess.StartInfo = myProcessStartInfo
    myProcess.Start()

    Dim myStreamReader As StreamReader = myProcess.StandardError
    ' Read the standard error of net.exe and write it on to console.
    Console.WriteLine(myStreamReader.ReadLine())
End Using

Açıklamalar

Bir Process metin standart hata akışına yazıldığında, bu metin normalde konsolda görüntülenir. Akışı yeniden yönlendirerek StandardError bir işlemin hata çı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.

Not

kullanmak StandardErroriçin olarak ve ProcessStartInfo.UseShellExecutefalseolarak ayarlamanız ProcessStartInfo.RedirectStandardErrortruegerekir. Aksi takdirde, akıştan StandardError okuma bir özel durum oluşturur.

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

Buna karşılık, BeginErrorReadLine akışta StandardError 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 StandardError 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 hata akışından okuma ve alt işlemin çıkmasını bekleme işlemleri gösterilmektedir. önce p.WaitForExitçağrısı p.StandardError.ReadToEnd yaparak kilitlenme durumundan kaçınıyor. Üst işlem daha önce p.StandardError.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 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.RedirectStandardError = true;  
      p.StartInfo.FileName = "Write500Lines.exe";  
      p.Start();  

      // To avoid deadlocks, always read the output stream first and then wait.  
      string output = p.StandardError.ReadToEnd();  
      p.WaitForExit();

      Console.WriteLine($"\nError stream: {output}");
   }
}
// The end of the output produced by the example includes the following:
//      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.RedirectStandardError = 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.StandardError.ReadToEnd()  
        p.WaitForExit()

        Console.WriteLine($"{vbCrLf}Error stream: {output}")
    End Sub
End Module
' The end of the output produced by the example includes the following:
'      Error stream:
'      Successfully wrote 500 lines.

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.

Not

Yeniden yönlendirilen akışta zaman uyumsuz ve zaman uyumlu okuma işlemlerini karıştıramazsınız. Bir öğesinin yeniden yönlendirilen akışı Process zaman uyumsuz veya zaman uyumlu modda açıldıktan sonra, bu akıştaki diğer tüm okuma işlemlerinin aynı modda olması gerekir. Örneğin, akışta StandardError çağrısıyla ReadLine takip BeginErrorReadLine etmeyin veya tam tersi. Ancak, farklı modlarda iki farklı akışı okuyabilirsiniz. Örneğin, akışı çağırabilir BeginOutputReadLine ve ardından çağırabilirsiniz ReadLineStandardError .

Ayrıca bkz.

• StandardInput
• StandardOutput
• RedirectStandardError