.NET uygulamalarında yönlendirilmiş konsol çıktısında kapalı boruyu algıla

Question

Uygulama çıkış başka bir programa borulu sahip olduğunda

.NET Console sınıfı ve varsayılan TextWriter uygulaması (Console.Out olarak mevcuttur ve dolaylı olarak, örneğin Console.WriteLine() olarak) herhangi bir hata sinyali değildir ve diğer program sona erer ve uygulama öncesi boru kapatır bitti. Bu, uygulamanın gerekenden daha uzun süre çalışabileceği ve çıktıların bir karadeliğe yazılabileceği anlamına gelir.

Yönlendirme borusunun diğer ucunun kapanmasını nasıl algılayabilirim?

Daha ayrıntılı bir açıklama şöyledir:

İşte problemi gösteren bir çift örnek program. Oldukça yavaş tamsayılar baskılar sürü Produce hesaplama etkisini simüle etmek için:

using System; 
class Produce 
{ 
    static void Main() 
    { 
     for (int i = 0; i < 10000; ++i) 
     { 
      System.Threading.Thread.Sleep(100); // added for effect 
      Console.WriteLine(i); 
     } 
    } 
} 

Consume sadece girişin ilk 10 satırları okur ve daha sonra çıkar:

using System; 
class Consume 
{ 
    static void Main() 
    { 
     for (int i = 0; i < 10; ++i) 
      Console.ReadLine(); 
    } 
} 

bu iki program derlendiği durumda ve

Produce | Consume 

... o Consume sonlandırıldı süre sonra çalıştıran Produce tutar gözlenebilir: şöyle kapatıldığı ikinci borulu çıkış.

Gerçekte, Consume programım Unix tarzı head'dir ve Produce programım hesaplamak için maliyetli olan verileri yazdırır. Borunun diğer ucu bağlantıyı kapattığında çıkışı sonlandırmak istiyorum.

Bunu .NET'te nasıl yapabilirim?

(ben bariz alternatif çıkışını sınırlamak için bir komut satırı argümanı geçmek olduğunu biliyoruz ve gerçekten de ben şu anda yapıyorum, ama yine de ben olmak istiyorum çünkü bunun nasıl bilmek istiyorum . okumasını sonlandırmak için zaman hakkında daha yapılandırılabilir kararları verebilecek; head önce grep aracılığıyla örneğin boru)

GÜNCELLEME: Bu .NET System.IO.__ConsoleStream uygulamasıdır korkunç benziyor kodlanmış hatalarını görmezden 0x6D (ERROR_BROKEN_PIPE) ve 0xE8 (ERROR_NO_DATA). Bu muhtemelen konsol akışını yeniden yapılandırmam gerektiği anlamına gelir. Sigh ...)

Answer 1

Bu olayı için ben yazmak zorunda benim Win32 dosya tanıtıcıları üzerinde kendi temel akışı uygulaması. Bu, asenkron destek, arabelleğe alma veya arama yapma gereği duymadığım için çok zor değildi.

Ne yazık ki, güvenli olmayan kodun kullanılması gerekir, ancak genellikle yerel olarak ve tam güvenle çalışacak olan konsol uygulamaları için bir sorun değildir.

İşte çekirdek akışı var: Gerekirse

class HandleStream : Stream 
{ 
    SafeHandle _handle; 
    FileAccess _access; 
    bool _eof; 

    public HandleStream(SafeHandle handle, FileAccess access) 
    { 
     _handle = handle; 
     _access = access; 
    } 

    public override bool CanRead 
    { 
     get { return (_access & FileAccess.Read) != 0; } 
    } 

    public override bool CanSeek 
    { 
     get { return false; } 
    } 

    public override bool CanWrite 
    { 
     get { return (_access & FileAccess.Write) != 0; } 
    } 

    public override void Flush() 
    { 
     // use external buffering if you need it. 
    } 

    public override long Length 
    { 
     get { throw new NotSupportedException(); } 
    } 

    public override long Position 
    { 
     get { throw new NotSupportedException(); } 
     set { throw new NotSupportedException(); } 
    } 

    static void CheckRange(byte[] buffer, int offset, int count) 
    { 
     if (offset < 0 || count < 0 || (offset + count) < 0 
      || (offset + count) > buffer.Length) 
      throw new ArgumentOutOfRangeException(); 
    } 

    public bool EndOfStream 
    { 
     get { return _eof; } 
    } 

    public override int Read(byte[] buffer, int offset, int count) 
    { 
     CheckRange(buffer, offset, count); 
     int result = ReadFileNative(_handle, buffer, offset, count); 
     _eof |= result == 0; 
     return result; 
    } 

    public override void Write(byte[] buffer, int offset, int count) 
    { 
     int notUsed; 
     Write(buffer, offset, count, out notUsed); 
    } 

    public void Write(byte[] buffer, int offset, int count, out int written) 
    { 
     CheckRange(buffer, offset, count); 
     int result = WriteFileNative(_handle, buffer, offset, count); 
     _eof |= result == 0; 
     written = result; 
    } 

    public override long Seek(long offset, SeekOrigin origin) 
    { 
     throw new NotSupportedException(); 
    } 

    public override void SetLength(long value) 
    { 
     throw new NotSupportedException(); 
    } 

    [return: MarshalAs(UnmanagedType.Bool)] 
    [DllImport("kernel32", SetLastError=true)] 
    static extern unsafe bool ReadFile(
     SafeHandle hFile, byte* lpBuffer, int nNumberOfBytesToRead, 
     out int lpNumberOfBytesRead, IntPtr lpOverlapped); 

    [return: MarshalAs(UnmanagedType.Bool)] 
    [DllImport("kernel32.dll", SetLastError=true)] 
    static extern unsafe bool WriteFile(
     SafeHandle hFile, byte* lpBuffer, int nNumberOfBytesToWrite, 
     out int lpNumberOfBytesWritten, IntPtr lpOverlapped); 

    unsafe static int WriteFileNative(SafeHandle hFile, byte[] buffer, int offset, int count) 
    { 
     if (buffer.Length == 0) 
      return 0; 

     fixed (byte* bufAddr = &buffer[0]) 
     { 
      int result; 
      if (!WriteFile(hFile, bufAddr + offset, count, out result, IntPtr.Zero)) 
      { 
       // Using Win32Exception just to get message resource from OS. 
       Win32Exception ex = new Win32Exception(Marshal.GetLastWin32Error()); 
       int hr = ex.NativeErrorCode | unchecked((int) 0x80000000); 
       throw new IOException(ex.Message, hr); 
      } 

      return result; 
     } 
    } 

    unsafe static int ReadFileNative(SafeHandle hFile, byte[] buffer, int offset, int count) 
    { 
     if (buffer.Length == 0) 
      return 0; 

     fixed (byte* bufAddr = &buffer[0]) 
     { 
      int result; 
      if (!ReadFile(hFile, bufAddr + offset, count, out result, IntPtr.Zero)) 
      { 
       Win32Exception ex = new Win32Exception(Marshal.GetLastWin32Error()); 
       int hr = ex.NativeErrorCode | unchecked((int) 0x80000000); 
       throw new IOException(ex.Message, hr); 
      } 
      return result; 
     } 
    } 
} 

BufferedStream tamponlama için etrafına sarılmış, ancak konsol çıkış için, TextWriter zaten karakter düzeyinde ara belleğe alma yapacağız ve sadece yenisatırlar üzerine yıkar.

Akım, FormatMessage'un kendisini aramak yerine bir hata iletisi çıkarmak için Win32Exception'u kötüye kullanır.

static class ConsoleStreams 
{ 
    enum StdHandle 
    { 
     Input = -10, 
     Output = -11, 
     Error = -12, 
    } 

    [DllImport("kernel32.dll", SetLastError = true)] 
    static extern IntPtr GetStdHandle(int nStdHandle); 

    static SafeHandle GetStdHandle(StdHandle h) 
    { 
     return new SafeFileHandle(GetStdHandle((int) h), true); 
    } 

    public static HandleStream OpenStandardInput() 
    { 
     return new HandleStream(GetStdHandle(StdHandle.Input), FileAccess.Read); 
    } 

    public static HandleStream OpenStandardOutput() 
    { 
     return new HandleStream(GetStdHandle(StdHandle.Output), FileAccess.Write); 
    } 

    public static HandleStream OpenStandardError() 
    { 
     return new HandleStream(GetStdHandle(StdHandle.Error), FileAccess.Write); 
    } 

    static TextReader _in; 
    static StreamWriter _out; 
    static StreamWriter _error; 

    public static TextWriter Out 
    { 
     get 
     { 
      if (_out == null) 
      { 
       _out = new StreamWriter(OpenStandardOutput()); 
       _out.AutoFlush = true; 
      } 
      return _out; 
     } 
    } 

    public static TextWriter Error 
    { 
     get 
     { 
      if (_error == null) 
      { 
       _error = new StreamWriter(OpenStandardError()); 
       _error.AutoFlush = true; 
      } 
      return _error; 
     } 
    } 

    public static TextReader In 
    { 
     get 
     { 
      if (_in == null) 
       _in = new StreamReader(OpenStandardInput()); 
      return _in; 
     } 
    } 
} 

nihai sonuç borunun diğer ucunda sonra çıkış konsolu yazma sonlandırıldı olduğu:

Yapı Bu akım üzerinde, I/O konsolu için bir basit bir sarıcı yazmak mümkün olduğu bağlantı, mesaj ile güzel istisna sonuçları: boru yakalamak ve 01 göz ardı ederek

kapatılıyor

en dış seviyede, gitmek güzelim gibi görünüyor.

Answer 2

ERROR_BROKEN_PIPE ve ERROR_NO_DATA hatalarını bildirmeden, __ConsoleStream'in size yararı olmadığını kabul ediyorum. Neden bunu bırakmayı seçtiklerini merak ediyorum. __ConsoleStream bir oldukça eski, ama yine de alakalı liste için aşağıdaki linki kontrol, birlikte takip etmek isteyenler için

...

http://www.123aspx.com/Rotor/RotorSrc.aspx?rot=42958