ProcessStartInfo.RedirectStandardError Özellik

Tanım

Bir uygulamanın hata çıktısının StandardError akışa yazılıp yazılmadığını gösteren bir değer alır veya ayarlar.Gets or sets a value that indicates whether the error output of an application is written to the StandardError stream.

public:
 property bool RedirectStandardError { bool get(); void set(bool value); };
public bool RedirectStandardError { get; set; }
member this.RedirectStandardError : bool with get, set
Public Property RedirectStandardError As Boolean

Özellik Değeri

hata çıkışının StandardErroryazılması gerekiyorsa true; Aksi takdirde, false.true if error output should be written to StandardError; otherwise, false. Varsayılan, false değeridir.The default is false.

Örnekler

Aşağıdaki örnek, bir ağ kaynağını eşlemek için Kullanıcı tarafından sağlanan bağımsız değişkenle birlikte net use komutunu kullanır.The following example uses the net use command together with a user-supplied argument to map a network resource. Daha sonra, net komutunun standart hata akışını okur ve bunu konsola yazar.It then reads the standard error stream of the net command and writes it to console.

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 standart hata akışına metin yazdığında, bu metin genellikle konsolda görüntülenir.When a Process writes text to its standard error stream, that text is typically displayed on the console. StandardError akışını yeniden yönlendirerek bir işlemin hata çıkışını işleyebilir veya gizleyebilirsiniz.By redirecting the StandardError stream, you can manipulate or suppress the error output of a process. Örneğin, metni filtreleyebilir, farklı biçimlendirebilir veya çıktıyı hem konsola hem de belirlenen günlük dosyasına yazabilirsiniz.For example, you can filter the text, format it differently, or write the output to both the console and a designated log file.

Not

RedirectStandardError trueolarak ayarlamak istiyorsanız UseShellExecute false ayarlamanız gerekir.You must set UseShellExecute to false if you want to set RedirectStandardError to true. Aksi takdirde StandardError akıştan okumak bir özel durum oluşturur.Otherwise, reading from the StandardError stream throws an exception.

Yeniden yönlendirilen StandardError akışı, zaman uyumlu veya zaman uyumsuz olarak okunabilir.The redirected StandardError stream can be read synchronously or asynchronously. Read, ReadLine ve ReadToEnd gibi yöntemler işlemin hata çıktı akışında zaman uyumlu okuma işlemleri gerçekleştirir.Methods such as Read, ReadLine and ReadToEnd perform synchronous read operations on the error output stream of the process. Bu zaman uyumlu okuma işlemleri, ilişkili Process StandardError akışına yazana veya akışı kapatan sürece tamamlanmaz.These synchronous read operations do not complete until the associated Process writes to its StandardError stream, or closes the stream.

Buna karşılık BeginErrorReadLine, StandardError akışında zaman uyumsuz okuma işlemlerini başlatır.In contrast, BeginErrorReadLine starts asynchronous read operations on the StandardError stream. Bu yöntem, akış çıkışı için belirlenmiş bir olay işleyicisini sağlar ve hemen çağırana döner ve bu da akış çıktısı olay işleyicisine yönlendirilirken diğer işleri gerçekleştirebilir.This method enables a designated event handler for the stream output and immediately returns to the caller, which can perform other work while the stream output is directed to the event handler.

Not

Zaman uyumsuz çıktıyı işleyen uygulama, çıkış arabelleğinin temizlendiğinden emin olmak için Process.WaitForExit yöntemini çağırmalıdır.The application that is processing the asynchronous output should call the Process.WaitForExit method to ensure that the output buffer has been flushed.

Zaman uyumlu okuma işlemleri, çağıran StandardError akıştan okuma ve alt işlemi bu akışa yazma arasında bir bağımlılık ortaya çıkarabilir.Synchronous read operations introduce a dependency between the caller reading from the StandardError stream and the child process writing to that stream. Bu bağımlılıklar kilitlenme koşullarına neden olabilir.These dependencies can cause deadlock conditions. Çağıran bir alt işlemin yeniden yönlendirilen akışından okurken, alt öğeye bağımlıdır.When the caller reads from the redirected stream of a child process, it is dependent on the child. Çağıran, alt akışa yazana veya akışı kapatan sürece okuma işlemini bekler.The caller waits for the read operation until the child writes to the stream or closes the stream. Alt işlem, yeniden yönlendirilen akışını dolduracak kadar veri yazdığında, üst öğeye bağımlıdır.When the child process writes enough data to fill its redirected stream, it is dependent on the parent. Alt işlem, üst öğe tam akıştan okunana veya akışı kapatana kadar sonraki yazma işlemini bekler.The child process waits for the next write operation until the parent reads from the full stream or closes the stream. Kilitlenme durumu, çağıran ve alt işlemin bir işlemi tamamlaması için beklemesi ve hiçbir zaman devam edebilmesi durumunda oluşur.The deadlock condition results when the caller and child process wait for each other to complete an operation, and neither can continue. Arayan ve alt işlem arasındaki bağımlılıkları değerlendirerek kilitlenmeleri önleyebilirsiniz.You can avoid deadlocks by evaluating dependencies between the caller and child process.

Bu bölümdeki son iki örnek, Write500Lines. exeadlı bir yürütülebilir dosyayı başlatmak için Start yöntemini kullanır.The last two examples in this section use the Start method to launch an executable named Write500Lines.exe. Aşağıdaki örnek, kaynak kodunu içerir.The following example contains its source code.

using System;
using System.IO;

public class Example
{
   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 örnek, yeniden yönlendirilen bir hata akışından nasıl okunacağını ve alt işlemin çıkış için beklendiğini gösterir.The following example shows how to read from a redirected error stream and wait for the child process to exit. p.WaitForExitönce p.StandardError.ReadToEnd çağırarak bir kilitlenme koşulunu önler.It avoids a deadlock condition by calling p.StandardError.ReadToEnd before p.WaitForExit. Bir kilitlenme koşulu, üst işlemin p.StandardError.ReadToEnd önce p.WaitForExit çağırması ve alt işlemin yeniden yönlendirilen akışı doldurması için yeterli metin yazıyorsa elde edilebilir.A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardError.ReadToEnd and the child process writes enough text to fill the redirected stream. Üst işlem alt işlemin çıkması için sonsuza kadar bekler.The parent process would wait indefinitely for the child process to exit. Alt işlem, üst öğenin tam StandardError akışından okunmasını sonsuza kadar bekler.The child process would wait indefinitely for the parent to read from the full StandardError stream.

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 çıkışın hem de standart hata akışlarındaki tüm metinleri okurken benzer bir sorun vardır.There is a similar issue when you read all text from both the standard output and standard error streams. Aşağıdaki C# kod, örneğin, her iki akışda bir okuma işlemi gerçekleştirir.The following C# code, for example, performs a read operation on both streams. StandardError akışında zaman uyumsuz okuma işlemleri gerçekleştirerek kilitlenme koşulunu önler.It avoids the deadlock condition by performing asynchronous read operations on the StandardError stream. Bir kilitlenme koşulu, üst işlemin p.StandardError.ReadToEnd p.StandardOutput.ReadToEnd ve ardından alt işlem hata akışını dolduracak kadar metin yazdığında oluşur.A deadlock condition results if the parent process calls p.StandardOutput.ReadToEnd followed by p.StandardError.ReadToEnd and the child process writes enough text to fill its error stream. Üst işlem alt işlemin StandardOutput akışını kapatması sonsuza kadar bekler.The parent process would wait indefinitely for the child process to close its StandardOutput stream. Alt işlem, üst öğenin tam StandardError akışından okunmasını sonsuza kadar bekler.The child process would wait indefinitely for the parent to read from the full StandardError stream.

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ıklardan ve bunların kilitlenme potansiyelini önlemek için zaman uyumsuz okuma işlemleri kullanabilirsiniz.You can use asynchronous read operations to avoid these dependencies and their deadlock potential. Alternatif olarak, iki iş parçacığı oluşturarak ve her akışın çıkışını ayrı bir iş parçacığında okuyarak kilitlenme durumunu önleyebilirsiniz.Alternately, you can avoid the deadlock condition by creating two threads and reading the output of each stream on a separate thread.

Şunlara uygulanır

Ayrıca bkz.