采用管道进行通讯的例子

采用管道进行通讯的例子

作者：肖波
    用Remoting做进程间通讯，效率较低，于是做了一个采用管道技术进行进程间通讯的例子，在1.8G 双核计算机上每秒钟可以发送180M数据。下面给出源码
  
    Server端的管道类

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using Pipe.Win32;

namespace Pipe.Server
{
    public delegate void ReceiveMessageFunc(System.IO.MemoryStream m);
    public delegate void ReceiveMessageErrorFunc(Exception e);

    public class PipeServer : IDisposable
    {
        enum State
        {
            Idle = 0,
            Begining = 1,
            Reading = 2,
        }

        String m_PipeName;
        uint m_Handle;
        uint m_BufferSize;
        State m_State = State.Idle;

        const ulong SYNC_HEAD = 0xf8c7a1ca13db307e;
        const uint NMPWAIT_USE_DEFAULT_WAIT = 0x00000000;
        const int DEFAULT_BUFFER_SIZE = 1024;

        ReceiveMessageFunc m_ReceiveMessage;
        ReceiveMessageErrorFunc m_ReceiveMessageError;

        public ReceiveMessageFunc OnReceiveMessage
        {
            get
            {
                return m_ReceiveMessage;
            }

            set
            {
                m_ReceiveMessage = value;
            }
        }

        public ReceiveMessageErrorFunc OnReceiveMessageError
        {
            get
            {
                return m_ReceiveMessageError;
            }

            set
            {
                m_ReceiveMessageError = value;
            }
        }

        public String PipeName
        {
            get
            {
                return m_PipeName;
            }
        }

        public uint BufferSize
        {
            get
            {
                return m_BufferSize;
            }
        }

        public String PipeUri
        {
            get
            {
                return @"\\.\pipe\" + m_PipeName;
            }
        }

        private bool IsSyncHead(byte[] buf, uint len, out int msgLen)
        {
            msgLen = 0;

            if (len != 12)
            {
                return false;
            }

            if (SYNC_HEAD != BitConverter.ToUInt64(buf, 0))
            {
                return false;
            }

            msgLen = BitConverter.ToInt32(buf, sizeof(ulong));

            if (msgLen < 0)
            {
                return false;
            }

            return true;
        }

        private void ProcessMessage(System.IO.MemoryStream m)
        {
            if (OnReceiveMessage != null)
            {
                m.Position = 0;
                OnReceiveMessage(m);
            }
        }

        private void ThreadProc()
        {
        }

        public PipeServer(String pipeName)
        {
            m_PipeName = pipeName;
            m_BufferSize = DEFAULT_BUFFER_SIZE;
        }

        public PipeServer(String pipeName, uint bufferSize)
        {
            m_PipeName = pipeName;
            m_BufferSize = bufferSize;
        }


        public void Listen()
        {
            while (true)
            {
                try
                {

                    m_Handle = NTKernel.CreateNamedPipe(PipeUri, (uint)FileAccess.PIPE_ACCESS_DUPLEX,
                        (uint)PipeMode.PIPE_READMODE_MESSAGE | (uint)PipeMode.PIPE_TYPE_MESSAGE | (uint)PipeMode.PIPE_WAIT,
                        NTKernel.PIPE_UNLIMITED_INSTANCES, m_BufferSize, m_BufferSize, NMPWAIT_USE_DEFAULT_WAIT, new SecurityAttributes());

                    if (m_Handle == NTKernel.INVAILD_HANDLE)
                    {
                        throw new Exception(String.Format("CreateNamedPipe fail, err={0}", NTKernel.GetLastError()));
                    }

                    if (!NTKernel.ConnectNamedPipe(m_Handle, IntPtr.Zero))
                    {
                        uint err = NTKernel.GetLastError();
                        NTKernel.CloseHandle(m_Handle);
                        throw new Exception(String.Format("ConnectNamedPipe fail, err={0}", err));
                    }

                    byte[] buf = new byte[m_BufferSize];

                    uint relSize = 0;
                    int msgLen = 0;
                    int offset = 0;
                    System.IO.MemoryStream m = new System.IO.MemoryStream();

                    while (NTKernel.ReadFile(m_Handle, buf, m_BufferSize, out relSize, IntPtr.Zero))
                    {
                        switch (m_State)
                        {
                            case State.Idle:
                                if (IsSyncHead(buf, relSize, out msgLen))
                                {
                                    m_State = State.Begining;
                                }

                                break;
                            case State.Begining:
                                offset = 0;
                                m = new System.IO.MemoryStream();
                                m.Write(buf, 0, (int)relSize);
                                offset += (int)relSize;
                                if (offset >= msgLen)
                                {
                                    m_State = State.Idle;

                                    if (offset == msgLen)
                                    {
                                        ProcessMessage(m);
                                    }
                                    else
                                    {
                                        if (OnReceiveMessageError != null)
                                        {
                                            OnReceiveMessageError(new Exception("Message overflow!"));
                                        }
                                    }

                                }
                                else
                                {
                                    m_State = State.Reading;
                                }

                                break;
                            case State.Reading:
                                m.Write(buf, 0, (int)relSize);
                                offset += (int)relSize;
                                if (offset >= msgLen)
                                {
                                    m_State = State.Idle;

                                    if (offset == msgLen)
                                    {
                                        ProcessMessage(m);
                                    }
                                    else
                                    {
                                        if (OnReceiveMessageError != null)
                                        {
                                            OnReceiveMessageError(new Exception("Message overflow!"));
                                        }
                                    }
                                }

                                break;

                        }


                    }


                    NTKernel.DisconnectNamedPipe(m_Handle);
                    NTKernel.CloseHandle(m_Handle);
                    System.Threading.Thread.Sleep(10);
                }
                catch (Exception e)
                {
                    if (OnReceiveMessageError != null)
                    {
                        OnReceiveMessageError(e);
                    }
                }
            }
        }

        public void Dispose()
        {
            lock (this)
            {
                if (m_Handle != NTKernel.INVAILD_HANDLE)
                {
                    NTKernel.CloseHandle(m_Handle);
                    m_Handle = NTKernel.INVAILD_HANDLE;
                }
            }
        }

        ~PipeServer()
        {
            Dispose();
        }
    }

}

Client 端的管道类

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using Pipe.Win32;

namespace Pipe.Client
{
    public class PipeClient : IDisposable
    {
        String m_PipeName;
        String m_ComputerName;
        uint m_Handle;
        uint m_BufferSize;
        const ulong SYNC_HEAD = 0xf8c7a1ca13db307e;
        byte[] m_SendBuf;

        Propertys#region Propertys

        public String PipeName
        {
            get
            {
                return m_PipeName;
            }
        }

        public String ComputerName
        {
            get
            {
                return m_ComputerName;
            }

            set
            {
                m_ComputerName = value;
            }
        }

        public uint BufferSize
        {
            get
            {
                return m_BufferSize;
            }
        }

        public String PipeUri
        {
            get
            {
                if (m_ComputerName != null)
                {
                    return @"\\" + m_ComputerName + @"\pipe\" + m_PipeName;
                }
                else
                {
                    return @"\\.\pipe\" + m_PipeName;
                }
            }
        }

        #endregion

        private void Connect()
        {
            int file_not_find_times = 0;

            while (true)
            {
                m_Handle = NTKernel.CreateFile(PipeUri, (uint)FileAccess.GENERIC_READ | (uint)FileAccess.GENERIC_WRITE,
                    0, new SecurityAttributes(), (uint)CreateMode.OPEN_EXISTING, 0, 0);

                if (m_Handle == NTKernel.INVAILD_HANDLE)
                {
                    uint err = NTKernel.GetLastError();

                    if (err == NTKernel.ERROR_FILE_NOT_FOUND)
                    {
                        if (file_not_find_times++ < 2000)
                        {
                            System.Threading.Thread.Sleep(20);
                            continue;
                        }
                    }

                    if (err == NTKernel.ERROR_PIPE_BUSY)
                    {
                        NTKernel.WaitNamedPipeA(PipeUri, 20);
                        continue;
                    }
                    else
                    {
                        throw new Exception(String.Format("Create File for pipe fail, err={0}", NTKernel.GetLastError()));
                    }
                }

                break;
            }

        }

        private void WriteBuf(byte[] buf)
        {
            uint relSize;

            if (!NTKernel.WriteFile(m_Handle, buf, (uint)buf.Length, out relSize, IntPtr.Zero))
            {
                throw new Exception(String.Format("Send message to pipe fail, err={0}", NTKernel.GetLastError()));
            }
        }

        public void Close()
        {
            lock (this)
            {
                if (m_Handle != NTKernel.INVAILD_HANDLE)
                {
                    bool ret = NTKernel.CloseHandle(m_Handle);
                    m_Handle = NTKernel.INVAILD_HANDLE;
                }
            }
        }

        public PipeClient(String pipeName, uint bufferSize)
        {
            m_PipeName = pipeName;
            m_BufferSize = bufferSize;
            m_Handle = NTKernel.INVAILD_HANDLE;
            m_SendBuf = new byte[bufferSize];
        }

        public void Dispose()
        {
            Close();
        }

        public void Send(byte[] buf)
        {
            if (m_Handle == NTKernel.INVAILD_HANDLE)
            {
                Connect();
            }

            //Build Message Head
            byte[] syncHead = BitConverter.GetBytes(SYNC_HEAD);
            byte[] length = BitConverter.GetBytes(buf.Length);
            byte[] lengthBuf = new byte[syncHead.Length + length.Length];
            
            syncHead.CopyTo(lengthBuf, 0);
            
            for (int i = syncHead.Length; i < lengthBuf.Length; i++)
            {
                lengthBuf[i] = length[i - syncHead.Length];
            }

            WriteBuf(lengthBuf);

            //write content
            if (buf.Length < m_BufferSize)
            {
                WriteBuf(buf);
            }
            else
            {
                //the length of buf lardge than m_BufferSize

                int offset = 0;

                int len = Math.Min((int)m_BufferSize, buf.Length - offset);

                byte[] sendbuf;

                while (len > 0)
                {
                    if (len == m_BufferSize)
                    {
                        sendbuf = m_SendBuf;
                    }
                    else
                    {
                        sendbuf = new byte[len];
                    }

                    System.IO.MemoryStream m = new System.IO.MemoryStream(sendbuf);
                    m.Write(buf, offset, len);
                    m.Close();
                    offset += len;
                    len = Math.Min((int)m_BufferSize, buf.Length - offset);
                    WriteBuf(sendbuf);
                }
            }
        }

        ~PipeClient()
        {
            Dispose();
        }
    }
}

NTKernel.cs
这个程序文件Client 和 Server 都要，封装了相应的API函数

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;


namespace Pipe.Win32
{

    Data Structures#region Data Structures

    public enum WaitForState : uint
    {
        WAIT_ABANDONED = 0x00000080,
        WAIT_OBJECT_0 = 0x00000000,
        WAIT_TIMEOUT = 0x00000102,
    }

    public enum EventAccess : uint
    {
        STANDARD_RIGHTS_REQUIRED = 0x000F0000,
        SYNCHRONIZE = 0x00100000,
        EVENT_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3),
        EVENT_MODIFY_STATE = 0x0002,
    }

    public enum PipeMode
    {
        PIPE_TYPE_MESSAGE = 0x00000004,
        PIPE_READMODE_MESSAGE = 0x00000002,
        PIPE_WAIT = 0x00000000,
    }

    public enum CreateMode : uint
    {
        OPEN_EXISTING = 3,
    }

    public enum FileAccess : uint
    {
        GENERIC_READ = 0x80000000,
        GENERIC_WRITE = 0x40000000,
        PIPE_ACCESS_DUPLEX = 0x00000003,
        ReadOnly = 2,
        ReadWrite = 4
    }

    [StructLayoutAttribute(LayoutKind.Sequential)]
    public struct SECURITY_DESCRIPTOR
    {
        public byte revision;
        public byte size;
        public short control;
        public IntPtr owner;
        public IntPtr group;
        public IntPtr sacl;
        public IntPtr dacl;

    }

    enum TOKEN_INFORMATION_CLASS
    {
        TokenUser = 1,
        TokenGroups,
        TokenPrivileges,
        TokenOwner,
        TokenPrimaryGroup,
        TokenDefaultDacl,
        TokenSource,
        TokenType,
        TokenImpersonationLevel,
        TokenStatistics,
        TokenRestrictedSids,
        TokenSessionId,
        TokenGroupsAndPrivileges,
        TokenSessionReference,
        TokenSandBoxInert,
        TokenAuditPolicy,
        TokenOrigin
    }

    public struct TOKEN_USER
    {
        public SID_AND_ATTRIBUTES User;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct SID_AND_ATTRIBUTES
    {

        public IntPtr Sid;
        public int Attributes;
    }

    enum SID_NAME_USE
    {
        SidTypeUser = 1,
        SidTypeGroup,
        SidTypeDomain,
        SidTypeAlias,
        SidTypeWellKnownGroup,
        SidTypeDeletedAccount,
        SidTypeInvalid,
        SidTypeUnknown,
        SidTypeComputer
    }

    [StructLayout(LayoutKind.Sequential)]
    public class SecurityAttributes : IDisposable
    {
        [DllImport("advapi32.dll", SetLastError = true)]
        static extern bool SetSecurityDescriptorDacl(IntPtr sd, bool daclPresent, IntPtr dacl, bool daclDefaulted);


        [DllImport("advapi32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        static extern bool InitializeSecurityDescriptor(IntPtr pSecurityDescriptor, uint dwRevision);

        [DllImport("advapi32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        static extern bool OpenThreadToken(
            IntPtr ThreadHandle,
            uint DesiredAccess,
            bool OpenAsSelf,
            out IntPtr TokenHandle);

        [DllImport("advapi32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        public static extern bool OpenProcessToken(
            IntPtr ProcessHandle,
            uint DesiredAccess,
            out IntPtr TokenHandle);

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

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

        [DllImport("advapi32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        static extern bool GetTokenInformation(
            IntPtr TokenHandle,
            TOKEN_INFORMATION_CLASS TokenInformationClass,
            IntPtr TokenInformation,
            uint TokenInformationLength,
            out uint ReturnLength);

        [DllImport("advapi32", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        static extern bool ConvertSidToStringSid(
            IntPtr Sid,
            out IntPtr ptrSid);

        [DllImport("advapi32", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        static extern bool ConvertStringSidToSid(
          out IntPtr ptrSid,
          out IntPtr Sid
        );



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

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        static extern bool LookupAccountName(
            string lpSystemName,
            string lpAccountName,
            IntPtr Sid,
            out uint cbSid,
            IntPtr ReferencedDomainName,
            out uint cchReferencedDomainName,
            out SID_NAME_USE peUse);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern uint GetLengthSid(IntPtr pSid);

        [DllImport("advapi32.dll")]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        public static extern bool InitializeAcl(ref IntPtr pAcl, int nAclLength, int dwAclRevision);

        [DllImport("advapi32.dll")]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        public static extern bool AddAccessAllowedAce(ref IntPtr pAcl, int dwAceRevision, uint AccessMask, IntPtr pSid);

        private int nLength;
        private IntPtr lpSecurityDescriptor;
        private int bInheritHandle;

        public SecurityAttributes()
        {

            //Get SecurityAttributes size
            nLength = Marshal.SizeOf(typeof(SecurityAttributes));

            //Inherit handle
            bInheritHandle = 1;

            //Create a NULL DACL 
            SECURITY_DESCRIPTOR sd = new SECURITY_DESCRIPTOR();

            //Alloc memory for security descriptor
            lpSecurityDescriptor = Marshal.AllocCoTaskMem(Marshal.SizeOf(sd));

            //Struct to Ptr
            Marshal.StructureToPtr(sd, lpSecurityDescriptor, false);

            InitializeSecurityDescriptor(lpSecurityDescriptor, 1);
            SetSecurityDescriptorDacl(lpSecurityDescriptor, true, IntPtr.Zero, false);
        }

        public void Dispose()
        {
            lock (this)
            {
                if (lpSecurityDescriptor != IntPtr.Zero)
                {
                    Marshal.FreeCoTaskMem(lpSecurityDescriptor);
                    //Marshal.FreeHGlobal(lpSecurityDescriptor);
                    lpSecurityDescriptor = IntPtr.Zero;
                }
            }
        }

        ~SecurityAttributes()
        {
            Dispose();
        }

    }

    #endregion

    public class NTKernel
    {
        public const uint PIPE_UNLIMITED_INSTANCES = 255;
        public const uint INVAILD_HANDLE = 0xFFFFFFFF;
        public const uint ERROR_FILE_NOT_FOUND = 2;
        public const uint ERROR_PIPE_BUSY = 231;

        internal const uint INFINITE = 0xFFFFFFFF;


        [DllImport("kernel32", EntryPoint = "GetLastError", SetLastError = true, CharSet = CharSet.Unicode)]
        public static extern uint GetLastError();

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern uint CreateNamedPipe(string lpName, uint dwOpenMode,
           uint dwPipeMode, uint nMaxInstances, uint nOutBufferSize, uint nInBufferSize,
           uint nDefaultTimeOut, SecurityAttributes lpSecurityAttributes);

        [DllImport("kernel32.dll")]
        public static extern bool ConnectNamedPipe(uint hNamedPipe,
           IntPtr lpOverlapped);

        [DllImport("kernel32.dll")]
        public static extern bool DisconnectNamedPipe(uint hNamedPipe);
        
        [DllImport("kernel32.dll", SetLastError=true)] 
        public static extern int WaitNamedPipeA (string lpNamedPipeName, int nTimeOut);

        [DllImport("kernel32.dll")]
        public static extern bool ReadFile(uint hFile, byte[] lpBuffer,
           uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, IntPtr lpOverlapped);

        [DllImport("kernel32.dll")]
        public static extern bool WriteFile(uint hFile, byte[] lpBuffer,
           uint nNumberOfBytesToWrite, out uint lpNumberOfBytesWritten,
           IntPtr lpOverlapped);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool CloseHandle(uint hHandle);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        public static extern uint CreateFile(
              string lpFileName,
              uint dwDesiredAccess,
              uint dwShareMode,
              SecurityAttributes lpSecurityAttributes,
              uint dwCreationDisposition,
              uint dwFlagsAndAttributes,
              int hTemplateFile
              );

        Mutex#region Mutex
        [DllImport("kernel32.dll")]
        internal static extern IntPtr CreateMutex(SecurityAttributes lpEventAttributes, bool bInitialOwner, string lpName);

        [DllImport("kernel32.dll")]
        internal static extern bool ReleaseMutex(IntPtr hHandle);

        #endregion


        Semaphore#region Semaphore

        [DllImport("kernel32", EntryPoint = "CreateSemaphore", SetLastError = true, CharSet = CharSet.Unicode)]
        internal static extern uint CreateSemaphore(SecurityAttributes auth, int initialCount, int maximumCount, string name);

        [DllImport("kernel32", EntryPoint = "WaitForSingleObject", SetLastError = true, CharSet = CharSet.Unicode)]
        internal static extern uint WaitForSingleObject(uint hHandle, uint dwMilliseconds);

        [DllImport("kernel32", EntryPoint = "ReleaseSemaphore", SetLastError = true, CharSet = CharSet.Unicode)]
        [return: MarshalAs(UnmanagedType.VariantBool)]
        internal static extern bool ReleaseSemaphore(uint hHandle, int lReleaseCount, out int lpPreviousCount);

        #endregion

        Event#region Event

        [DllImport("kernel32.dll")]
        internal static extern IntPtr CreateEvent(SecurityAttributes lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);

        [DllImport("Kernel32.dll", SetLastError = true)]
        internal static extern IntPtr OpenEvent(uint dwDesiredAccess, bool bInheritHandle, string lpName);

        [DllImport("kernel32.dll")]
        internal static extern bool SetEvent(IntPtr hEvent);

        [DllImport("kernel32.dll")]
        internal static extern bool ResetEvent(IntPtr hEvent);

        [DllImport("kernel32.dll")]
        static extern bool PulseEvent(IntPtr hEvent);

        #endregion

    }

    class Mutex : IDisposable
    {
        IntPtr m_Handle;

        public Mutex(SecurityAttributes lpEventAttributes, bool bInitialOwner, string lpName)
        {
            m_Handle = NTKernel.CreateMutex(lpEventAttributes, bInitialOwner, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                uint err = NTKernel.GetLastError();
                throw new Exception(String.Format("Create Event fail, error={0}",
                    err));
            }
        }

        public Mutex(bool bInitialOwner, string lpName)
        {
            m_Handle = NTKernel.CreateMutex(null, bInitialOwner, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                uint err = NTKernel.GetLastError();
                throw new Exception(String.Format("Create Event fail, error={0}",
                    err));
            }
        }

        public bool WaitOne(uint dwMilliseconds)
        {
            WaitForState waitForState = (WaitForState)NTKernel.WaitForSingleObject((uint)m_Handle, dwMilliseconds);

            if (waitForState == WaitForState.WAIT_OBJECT_0)
            {
                return true;
            }
            else if (waitForState == WaitForState.WAIT_TIMEOUT)
            {
                return false;
            }
            else
            {
                throw new System.Threading.AbandonedMutexException();
            }


        }

        public bool WaitOne()
        {
            return WaitOne(NTKernel.INFINITE);
        }

        public void ReleaseMutex()
        {
            NTKernel.ReleaseMutex(m_Handle);
        }

        public void Close()
        {
            lock (this)
            {
                if (m_Handle != IntPtr.Zero)
                {
                    if (NTKernel.CloseHandle((uint)m_Handle))
                    {
                        m_Handle = IntPtr.Zero;
                    }
                }
            }
        }

        ~Mutex()
        {
            Dispose();
        }

        IDisposable Members#region IDisposable Members

        public void Dispose()
        {
            Close();
        }

        #endregion

    }

    public class Event : IDisposable
    {
        IntPtr m_Handle;

        public Event()
        {
        }

        public Event(SecurityAttributes lpEventAttributes, bool bManualReset, bool bInitialState, string lpName)
        {
            m_Handle = NTKernel.CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                uint err = NTKernel.GetLastError();
                throw new Exception(String.Format("Create Event fail, error={0}",
                    err));
            }
        }

        public bool Open(EventAccess dwDesiredAccess, bool bInheritHandle, string lpName)
        {
            m_Handle = NTKernel.OpenEvent((uint)dwDesiredAccess, bInheritHandle, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public WaitForState WaitFor(uint dwMilliseconds)
        {
            return (WaitForState)NTKernel.WaitForSingleObject((uint)m_Handle, dwMilliseconds);
        }

        public WaitForState WaitFor()
        {
            return WaitFor(NTKernel.INFINITE);
        }

        public void SetEvent()
        {
            NTKernel.SetEvent(m_Handle);
        }

        public void Release()
        {
            NTKernel.ResetEvent(m_Handle);
        }

        public void Close()
        {
            lock (this)
            {
                if (m_Handle != IntPtr.Zero)
                {
                    if (NTKernel.CloseHandle((uint)m_Handle))
                    {
                        m_Handle = IntPtr.Zero;
                    }
                }
            }
        }

        ~Event()
        {
            Dispose();
        }

        IDisposable Members#region IDisposable Members

        public void Dispose()
        {
            Close();
        }

        #endregion
    }
}

客户端调用

            byte[] buf = new byte[10240];
            Pipe.Client.PipeClient client = new Pipe.Client.PipeClient("test", 102400);

            for (int i = 0; i < 10000; i++)
            {
                try
                {
                    client.Send(buf);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
                finally
                {
                }
            }

服务器调用

        static bool begin = true;
        static System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
        static int count = 0;
        static object lockObj = new object();

        static void ReceiveMessage(System.IO.MemoryStream m)
        {
            //Console.WriteLine(msg.Event);

            lock (lockObj)
            {

                if (begin)
                {
                    watch.Start();
                    begin = false;
                }

                count++;

                if (count == 10000)
                {
                    watch.Stop();
                    float len = m.Length;

                    Console.WriteLine(String.Format("{0} MB", (len * 10000 * 1000 / watch.ElapsedMilliseconds) / (1024 * 1024)));
                    Console.WriteLine(String.Format("{0} ms", watch.ElapsedMilliseconds));
               
                }
            }
        }

        static void ReceiveMessageError(Exception e)
        {
            Console.WriteLine(e.Message);
        }

        static void Main(string[] args)
        {
            Pipe.Server.PipeServer server = new Pipe.Server.PipeServer("Test", 102400);
            server.OnReceiveMessage = ReceiveMessage;
            server.OnReceiveMessageError = ReceiveMessageError;
            server.Listen();


        }

源码下载位置