.net 命名管道(NamedPipe) 的使用

命名管道常常用于应用程序之间的通迅，由于不需要进行序列化和反序列化操作，效率还是非常高的。我们今天做个演示看看。

类似于TCP/IP的模式的c/s结构。我们先建立一个服务器端：

           using (NamedPipeServerStream pipeServer =
                new NamedPipeServerStream("testpipe", PipeDirection.Out))//创建连接
            {
                pipeServer.WaitForConnection();//等待连接，程序会阻塞在此处，直到有一个连接到达

                try
                {
                    // Read user input and send that to the client process.
                    using (StreamWriter sw = new StreamWriter(pipeServer))
                    {
                        sw.AutoFlush = true;
                        sw.WriteLine("hello world ");
                    }
                }
                // Catch the IOException that is raised if the pipe is broken
                // or disconnected.
                catch (IOException e)
                {
                    Console.WriteLine("ERROR: {0}", e.Message);
                }
            }

上面的代码很简单，构建NamedPipeServerStream对象，然后调用该对象的WaitForConnection方法等待客户端的连接，一旦连接建立，向客户端写入一个字符串“hello world ”

下面写一个客户端。

            using (NamedPipeClientStream pipeClient =
                        new NamedPipeClientStream(".", "testpipe", PipeDirection.In))
            {
                pipeClient.Connect();

                using (StreamReader sr = new StreamReader(pipeClient))
                {
                    string temp;
                    while ((temp = sr.ReadLine()) != null)
                    {
                        MessageBox.Show(string.Format("Received from server: {0}", temp));
                    }
                }
            }

 客户端构建了一个NamedPipeClientStream 对象，调用Connect方法建立连接，连接通畅后，立即从通道里读取数据，这里会读取到"hello world "字符。

本文结束。太简单了吧。微软都把这些类库封装的很方便了。

---------------------

以下是扩充内容。

既然 命名管道 给我们提供一种通讯方式，那么我们尝试使用这个通讯做个 C/S 结构的消息监听演示。我们利用 命名管道 封装两个类，一个服务类，一个客户机类。使得我们在使用的时候无需考虑通讯的底层实现。

那么我们先看下服务端的类：

/* ----------------------------------------------------------
* @名称    :    
* @描述    :    
* @创建人  :    张云飞
* @创建日期:    2011/7/12 9:57:55
* @修改记录:
* ----------------------------------------------------------*/


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.IO.Pipes;
using System.IO;
using System.Threading;

namespace SimpleCode.NamedPipeLib
{
    public class NamedPipeListenServer
    {
        List<NamedPipeServerStream> _serverPool = new List<NamedPipeServerStream>();
        string _pipName = "test";
        public NamedPipeListenServer(string pipName)
        {
            _pipName = pipName;
        }

        /// <summary>
        /// 创建一个NamedPipeServerStream
        /// </summary>
        /// <returns></returns>
        protected NamedPipeServerStream CreateNamedPipeServerStream()
        {
            NamedPipeServerStream npss = new NamedPipeServerStream(_pipName, PipeDirection.InOut, 10);
            _serverPool.Add(npss);
            Console.WriteLine("启动了一个NamedPipeServerStream " + npss.GetHashCode());
            return npss;
        }

        /// <summary>
        /// 销毁
        /// </summary>
        /// <param name="npss"></param>
        protected void DistroyObject(NamedPipeServerStream npss)
        {
            npss.Close();
            if (_serverPool.Contains(npss))
            {
                _serverPool.Remove(npss);
            }
            Console.WriteLine("销毁一个NamedPipeServerStream " + npss.GetHashCode());
        }

        public void Run()
        {
            using (NamedPipeServerStream pipeServer = CreateNamedPipeServerStream())
            {
                pipeServer.WaitForConnection();
                Console.WriteLine("建立一个连接 " + pipeServer.GetHashCode());

                Action act = new Action(Run);
                act.BeginInvoke(null, null);

                try
                {
                    bool isRun = true;
                    while (isRun)
                    {
                        string str = null;
                        StreamReader sr = new StreamReader(pipeServer);
                        while (pipeServer.CanRead && (null != (str = sr.ReadLine())))
                        {
                            ProcessMessage(str, pipeServer);

                            if (!pipeServer.IsConnected)
                            {
                                isRun = false;
                                break;
                            }
                        }

                        Thread.Sleep(50);
                    }
                }
                // Catch the IOException that is raised if the pipe is broken
                // or disconnected.
                catch (IOException e)
                {
                    Console.WriteLine("ERROR: {0}", e.Message);
                }
                finally
                {
                    DistroyObject(pipeServer);
                }
            }

        }

        /// <summary>
        /// 处理消息
        /// </summary>
        /// <param name="str"></param>
        /// <param name="pipeServer"></param>
        protected virtual void ProcessMessage(string str, NamedPipeServerStream pipeServer)
        {
            // Read user input and send that to the client process.
            using (StreamWriter sw = new StreamWriter(pipeServer))
            {
                sw.AutoFlush = true;
                sw.WriteLine("hello world " + str);
            }
        }

        /// <summary>
        /// 停止
        /// </summary>
        public void Stop()
        {
            for (int i = 0; i < _serverPool.Count; i++)
            {
                var item = _serverPool[i];

                DistroyObject(item);
            }
        }
    }
}

我们使用 List<NamedPipeServerStream> _serverPool 做为一个集合容器，记录和保存所有的建立的连接。在Run方法里创建新的 命名管道连接 的实例。注意我们这里使用了一个异步委托。

                Action act = new Action(Run);
                act.BeginInvoke(null, null);
在一个Run方法执行时，异步执行了另一个Run方法，在这个Run方法的实现了阻塞监听，也就是一个新的连接建立后，立即建立一个新的监听连接，使得在处理一个连接的数据时，也可以等待新的客户端连接进入。

Stop方法会遍历所有的连接，保证销毁所有的连接。 ProcessMessage方法是处理客户机发来的消息，我们这里使用了ReadLine方法，也就是我们认为一行作为一个消息的单元。注意这个方法是virtual的，我们可以实现它的重载，以增加新的消息处理方式。

下面是客户端的封装类：

/* ----------------------------------------------------------
* @名称    :    
* @描述    :    
* @创建人  :    张云飞
* @创建日期:    2011/7/12 11:31:30
* @修改记录:
* ----------------------------------------------------------*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO.Pipes;
using System.IO;

namespace SimpleCode.NamedPipeLib
{
    public class NamedPipeClient : IDisposable
    {
        string _serverName;
        string _pipName;
        NamedPipeClientStream _pipeClient;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="serverName">服务器地址</param>
        /// <param name="pipName">管道名称</param>
        public NamedPipeClient(string serverName, string pipName)
        {
            _serverName = serverName;
            _pipName = pipName;

            _pipeClient = new NamedPipeClientStream(serverName, pipName, PipeDirection.InOut);

        }

        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public string Query(string request)
        {
            if (!_pipeClient.IsConnected)
            {
                _pipeClient.Connect(10000);
            }

            StreamWriter sw = new StreamWriter(_pipeClient);
            sw.WriteLine(request);
            sw.Flush();

            StreamReader sr = new StreamReader(_pipeClient);
            string temp;
            string returnVal = "";
            while ((temp = sr.ReadLine()) != null)
            {
                returnVal = temp;
                //nothing
            }
            return returnVal;
        }

        #region IDisposable 成员

        bool _disposed = false;
        public void Dispose()
        {
            if (!_disposed && _pipeClient != null)
            {
                _pipeClient.Dispose();
                _disposed = true;
            }
        }

        #endregion
    }
}

这个类需要注意的是，在构造里构造类命名管道的对象。有意思的地方是Query方法，该方法会接受一个string参数，并且返回一个string对象，实际会将输入参数的内容发送往服务端，将服务端的处理结果做为该方法的返回值。

服务端使用演示：

            NamedPipeListenServer svr = new NamedPipeListenServer("test");
            svr.Run();

客户端使用演示：

            using (NamedPipeClient client = new NamedPipeClient(".","test"))
            {
                MessageBox.Show( client.Query("fff"));
                MessageBox.Show(client.Query("54353"));
            }

呵呵，使用起来更简单和方便了。而且完全不用考虑内部的命名管道连接。

本文完。

完整的代码下载