C#的命名管道(named pipe)

命名管道是一种从一个进程到另一个进程用内核对象来进行信息传输。和一般的管道不同，命名管道可以被不同进程以不同的方式方法调用（可以跨权限、跨语言、跨平台）。只要程序知道命名管道的名字，发送到命名管道里的信息可以被一切拥有指定授权的程序读取，但对不具有制定授权的。命名管道是一种FIFO（先进先出，First-In First-Out）对象。

我们可以使用命名管道在2个不同的进程中进行通信而不需要通过一般的IO读写文件来获取信息。

在C#中可以简单的这么用用来接收消息

using System.IO.Pipes;

private volatile NamedPipeServerStream _OutputNamedPipe;
_OutputNamedPipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 254);
private void BeginReceiveOutput()
{
    try
    {
        _OutputNamedPipe.WaitForConnection();
        using (var reader = new StreamReader(_OutputNamedPipe))
        {
            _OutputMessage = reader.ReadLine();
         }
     }
     catch
     {
     }
}    

在vbscript里可以这样来发消息

Dim fs, pipe
Set fs = CreateObject("Scripting.FileSystemObject")
Set pipe = fs.OpenTextFile("\\.\pipe\PipeName", , False, )
pipe.WriteLine("This is a message from vbs")
pipe.Close

更为严谨的写法

     class Server
     {
         static void Main(string[] args)
         {
             var running = true;

             while (running) // loop only for 1 client
             {
                 using (var server = new NamedPipeServerStream("PIPE_NAME", PipeDirection.InOut))
                 {
                     server.WaitForConnection();

                     Console.WriteLine("Client connected");

                     using (var pipe = new PipeStream(server))
                     {
                         pipe.Send("handshake");

                         Console.WriteLine(pipe.Receive());

                         server.WaitForPipeDrain();
                         server.Flush();
                     }
                 }
             }

             Console.WriteLine("server closed");
             Console.Read();
         }
     }

     class Client
     {
         static void Main(string[] args)
         {
             using (var client = new NamedPipeClientStream(".", "PIPE_NAME", PipeDirection.InOut))
             {
                 client.Connect();

                 using (var pipe = new PipeStream(client))
                 {
                     Console.WriteLine("Message: " + pipe.Receive());

                     pipe.Send("Hello!!!");
                 }
             }

             Console.Read();
         }
     }

     public class PipeStream : IDisposable
     {
         private readonly Stream _stream;
         private readonly Reader _reader;
         private readonly Writer _writer;

         public PipeStream(Stream stream)
         {
             _stream = stream;

             _reader = new Reader(_stream);
             _writer = new Writer(_stream);
         }

         public string Receive()
         {
             return _reader.ReadLine();
         }

         public void Send(string message)
         {
             _writer.WriteLine(message);
             _writer.Flush();
         }

         public void Dispose()
         {
             _reader.Dispose();
             _writer.Dispose();

             _stream.Dispose();
         }

         private class Reader : StreamReader
         {
             public Reader(Stream stream)
                 : base(stream)
             {

             }

             protected override void Dispose(bool disposing)
             {
                 base.Dispose(false);
             }
         }

         private class Writer : StreamWriter
         {
             public Writer(Stream stream)
                 : base(stream)
             {

             }

             protected override void Dispose(bool disposing)
             {
                 base.Dispose(false);
             }
         }
     }