ProcessStartInfo.RedirectStandardError Özellik

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

true hata çıktısı olarak StandardErroryazılmalıdır; aksi takdirde , false. Varsayılan değer: false.

Örnekler

Aşağıdaki örnek, bir ağ kaynağını eşlemek için komutunu kullanıcı tarafından sağlanan bağımsız değişkenle birlikte kullanır net use . 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 yazdığında, bu metin genellikle 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.

Yeniden yönlendirilen StandardError akış zaman uyumlu veya zaman uyumsuz olarak okunabilir. gibi ReadReadLine yöntemler ve ReadToEnd işlemin hata çıktı akışında zaman uyumlu okuma işlemleri gerçekleştirir. İlişkili yazma işlemi akışına yazılana StandardError veya akışı kapatana kadar Process bu zaman uyumlu okuma işlemleri 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 akış çıkışı olay işleyicisine yönlendirilirken diğer işleri gerçekleştirebilen çağırana hemen döner.

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şlemini 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şlemini bekler. Kilitlenme koşulu, çağıran ve alt işlem birbirinin bir işlemi tamamlamasını beklediğinde ve hiçbiri devam etmediğinde sonuçlanabilir. Ç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. daha önce p.WaitForExitçağırarak p.StandardError.ReadToEnd kilitlenme durumunu önler. Ü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 çıkış hem de standart hata akışlarından tüm metinleri okuduğunuzda benzer bir sorun oluşur. Örneğin aşağıdaki C# kodu her iki akışta da okuma işlemi gerçekleştirir. Akışta zaman uyumsuz okuma işlemleri gerçekleştirerek kilitlenme koşulunu StandardError önler. Üst işlem tarafından çağrılması p.StandardOutput.ReadToEndp.StandardError.ReadToEnd ve alt işlemin hata akışını doldurmak için yeterli metin yazması durumunda kilitlenme koşulu oluşur. Ü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.

• UseShellExecute
• StandardError