C++和C#进程之间通过命名管道通信（附源码）—下

C++和C#进程之间通过命名管道通信（附源码）—下

接上篇：

我采用的是C#开发的一个windows应用程序（pipe_server_csharp）作为服务器端，而MFC开发的应用程序（NamedPipeClient_vc）作为客户端。客户端和服务器端要进行频繁的大量的通信，常见的是文本信息和曲线数据，例如，一共有10条曲线，每条曲线有1000000条double数据。

服务器端：

服务器端是用在VS2005中用C#开发的一个名为pipe_server_csharp的应用程序，只有一个名为frmServer的主界面。

由于管道的相关API函数都是属于kernel32.dll函数，C#中不能直接调用，所以必须将所要用到的API函数全部封装在一个类NamedPipeNative中。 至于如何调用这些API函数，有兴趣的朋友可以上网搜索，或者看我的另一篇文章《C#中怎么调用命名管道的WinAPI》。

NamedPipeNative类中几个主要函数如下（大家可以对比这些重写的API函数和原来的函数有什么变化）：

[DllImport("kernel32.dll", SetLastError=true)]

public static extern IntPtr CreateNamedPipe

(

String lpName,                                          // pipe name

uint dwOpenMode,                                   // pipe open mode

uint dwPipeMode,                                   // pipe-specific modes

uint nMaxInstances,                                // maximum number of instances

uint nOutBufferSize,                           // output buffer size

uint nInBufferSize,                                // input buffer size

uint nDefaultTimeOut,                          // time-out interval

IntPtr pipeSecurityDescriptor        // SD

);

[DllImport("kernel32.dll", SetLastError=true)]

public static extern bool ConnectNamedPipe

(

IntPtr hHandle,                                         // handle to named pipe

Overlapped lpOverlapped                   // overlapped structure

);

[DllImport("kernel32.dll", SetLastError=true)]

public static extern IntPtr CreateFile

(

String lpFileName,                          // file name

uint dwDesiredAccess,                       // access mode

uint dwShareMode,                                  // share mode

SecurityAttributes attr,                  // SD

uint dwCreationDisposition,          // how to create

uint dwFlagsAndAttributes,           // file attributes

uint hTemplateFile);                      // handle to template file

[DllImport("kernel32.dll", SetLastError=true)]

public static extern bool ReadFile

(

IntPtr hHandle,    // handle to file

byte[] lpBuffer,// data buffer字节流

uint nNumberOfBytesToRead,// number of bytes to read

byte[] lpNumberOfBytesRead,// number of bytes read

uint lpOverlapped// overlapped buffer

);

[DllImport("kernel32.dll", SetLastError=true)]

public static extern bool WriteFile

(

IntPtr hHandle,    // handle to file

byte[] lpBuffer,// data buffer字节流

uint nNumberOfBytesToWrite, // number of bytes to write

byte[] lpNumberOfBytesWritten,   // number of bytes written

uint lpOverlapped // overlapped buffer

);

还有其他一些常量：

public const uint PIPE_ACCESS_DUPLEX = 0x00000003;

public const uint PIPE_ACCESS_OUTBOUND = 0x00000002;

public const uint PIPE_TYPE_BYTE = 0x00000000;

public const uint PIPE_TYPE_MESSAGE = 0x00000004;

在此不一一列举了。

封装之后，在C#中就可以直接调用这些函数和常量了。

另外，创建了一个类CMyPipe，封装了服务器管道的属性和方法，如创建管道，读写数据等：

namespace pipe_server_csharp

{

    public class CMyPipe

    {

        private string m_PipeName;//管道名全称

        public string PipeName

        {

            get { return m_PipeName; }

            set { m_PipeName = value; }

        }

        private IntPtr m_HPipe;//管道句柄

        public IntPtr HPipe

        {

            get { return m_HPipe; }

            set { m_HPipe = value; }

        }

        public CMyPipe()//无参构造函数

        {

            m_HPipe = (IntPtr)NamedPipeNative.INVALID_HANDLE_VALUE;

            m_PipeName = "\\\\.\\pipe\\robinTest";

        }

        public CMyPipe(string pipeName)//有参构造函数

        {

            m_HPipe = (IntPtr)NamedPipeNative.INVALID_HANDLE_VALUE;

            m_PipeName = pipeName;

        }

        ~CMyPipe()//析构函数

        {

            Dispose();

        }

        public void Dispose()

        {

            lock (this)

            {

                if (m_HPipe != (IntPtr)NamedPipeNative.INVALID_HANDLE_VALUE)

                {

                    NamedPipeNative.CloseHandle(m_HPipe);

                    m_HPipe = (IntPtr)NamedPipeNative.INVALID_HANDLE_VALUE;

                }

            }

        }

        public void CreatePipe()//创建管道

        {

            m_HPipe = NamedPipeNative.CreateNamedPipe(m_PipeName,

                            NamedPipeNative.PIPE_ACCESS_DUPLEX,         // 数据双工通信

                            NamedPipeNative. PIPE_TYPE_MESSAGE | NamedPipeNative.PIPE_WAIT,                            100,                         // 最大实例个数

                            128,                           // 流出数据缓冲大小

                            128,                           // 流入数据缓冲大小

                            150,                         // 超时，毫秒

                            IntPtr.Zero                  // 安全信息

                            );

            if (m_HPipe.ToInt32() == NamedPipeNative.INVALID_HANDLE_VALUE)

            {

                frmServer.ActivityRef.AppendText("创建命名管道失败" );

                frmServer.ActivityRef.AppendText(Environment.NewLine);

                return;

            }

            frmServer.ActivityRef.AppendText("创建命名管道完毕" );

            frmServer.ActivityRef.AppendText(Environment.NewLine);          

        }

        public void ReadCurveData()//读取曲线数据

        {

            int nCurvesToRead = 0;

            nCurvesToRead = ReadInt(HPipe);//先读取需要读取的曲线条数,如

            frmServer.CurveDataList.Clear();

            for (int j = 1; j <= nCurvesToRead; j++)

            {

                string curveName = ReadString(HPipe);//读取该曲线名称

                int nCount = 0;

                nCount = ReadInt(HPipe);//读取该曲线的数据总数（数组大小）

                double[] readData = new double[nCount];

                for (int i = 0; i < nCount; i++)

                {

                    readData[i] = ReadDouble(HPipe);//顺序读取曲线的数据

                }

                CCurve newCurve = new CCurve();

                newCurve.CurveName = curveName;

                newCurve.CurveData = readData;

                frmServer.CurveDataList.Add(newCurve);

            }

        }

        public void ReadTextInfo()//读取文本信息

        {

            string textInfo = ReadString(HPipe);//读取该曲线名称

            frmServer.ActivityRef.AppendText(textInfo + Environment.NewLine);

            frmServer.ActivityRef.AppendText(Environment.NewLine);

        }

        public void ReadData()

        {

            //read data

            int flag = -1;

            flag = ReadInt(HPipe);//获取当前要读取的数据的信息

            if (flag == 0)//flag==0表示读取曲线数据

            {

                ReadCurveData();

            }

            else if (flag == 1)//flag==1表示读取文本信息

            {

                ReadTextInfo();

            }

        }

//写字符串，由于字符串的大小不同，所以先将字符串的大小写入，然后写字符串内容，对应的，

//在c++端，读字符串时先读取字符数组大小，从而给字符数组开辟相应的空间，然后读取字符串内容。

        public bool WriteString(IntPtr HPipe, string str)

        {

            byte[] Val = System.Text.Encoding.UTF8.GetBytes(str);

            byte[] dwBytesWrite = new byte[4];

            int len = Val.Length;

            byte[] lenBytes = System.BitConverter.GetBytes(len);

            if (NamedPipeNative.WriteFile(HPipe, lenBytes, 4, dwBytesWrite, 0))

                return (NamedPipeNative.WriteFile(HPipe, Val, (uint)len, dwBytesWrite, 0));

            else

                return false;

        }

        public string ReadString(IntPtr HPipe)

        {

            string Val = "";

            byte[] bytes = ReadBytes(HPipe);

            if (bytes != null)

            {

                Val = System.Text.Encoding.UTF8.GetString(bytes);

            }

            return Val;

        }

        public byte[] ReadBytes(IntPtr HPipe)

        {

            //传字节流

            byte[] szMsg = null;

            byte[] dwBytesRead = new byte[4];

            byte[] lenBytes = new byte[4];

            int len;

            if (NamedPipeNative.ReadFile(HPipe, lenBytes, 4, dwBytesRead, 0))//先读大小

            {

                len = System.BitConverter.ToInt32(lenBytes, 0);

                szMsg = new byte[len];

                if (!NamedPipeNative.ReadFile(HPipe, szMsg, (uint)len, dwBytesRead, 0))

                {

                    //frmServer.ActivityRef.AppendText("读取数据失败");

                    return null;

                }

            }

            return szMsg;

        }

        public float ReadFloat(IntPtr HPipe)

        {

            float Val = 0;

            byte[] bytes = new byte[4]; //单精度需4个字节存储

            byte[] dwBytesRead = new byte[4];

            if (!NamedPipeNative.ReadFile(HPipe, bytes, 4, dwBytesRead, 0))

            {

                //frmServer.ActivityRef.AppendText("读取数据失败");

                return 0;

            }

            Val = System.BitConverter.ToSingle(bytes, 0);

            return Val;

        }

        public double ReadDouble(IntPtr HPipe)

        {

            double Val = 0;

            byte[] bytes = new byte[8]; //双精度需8个字节存储

            byte[] dwBytesRead = new byte[4];

            if (!NamedPipeNative.ReadFile(HPipe, bytes, 8, dwBytesRead, 0))

            {

                //frmServer.ActivityRef.AppendText("读取数据失败");

                return 0;

            }

            Val = System.BitConverter.ToDouble(bytes, 0);

            return Val;

        }

        public int ReadInt(IntPtr HPipe)

        {

            int Val = 0;

            byte[] bytes = new byte[4]; //整型需4个字节存储

            byte[] dwBytesRead = new byte[4];

            if (!NamedPipeNative.ReadFile(HPipe, bytes, 4, dwBytesRead, 0))

            {

                //frmServer.ActivityRef.AppendText("读取数据失败");

                return 0;

            }

            Val = System.BitConverter.ToInt32(bytes, 0);

            return Val;

        }

    }

}

主程序，读取和显示通信信息：

    public partial class frmServer : Form

    {

        public static System.Windows.Forms.TextBox ActivityRef;//显示信息      

        public static ArrayList CurveDataList = new ArrayList();//存储数据

        public static string PipeName = "robinTest";

        public static string ServeName = ".";

        public static string FullPipeName = "\\\\"+ServeName+"\\pipe\\"+PipeName;//管道全名

        public static CMyPipe ThePipe;//管道实例

        private Thread hThread;//线程

        public frmServer()

        {

            InitializeComponent();

            frmServer.ActivityRef = this.txtMessage;

            Control.CheckForIllegalCrossThreadCalls = false;//不捕获线程错误调用，这样线程就可以别的线程中创建的东西，这样做也会破坏了线程的安全

            ThePipe = new CMyPipe(FullPipeName);

            ThePipe.CreatePipe();//创建管道

            hThread = new Thread(new ThreadStart(PipeProcess));

            hThread.IsBackground = true;

            hThread.Name = "Main Pipe Thread";

            hThread.Start();// 启动线程.监听管道，进行通信

            Thread.Sleep(1000);

        }

        public void PipeProcess()

        {

            bool ret = false;

            try

            {

                while (true)

                {

                    ret = NamedPipeNative.ConnectNamedPipe(ThePipe.HPipe, null);//连接到管道

                    if (!ret)

                    {

                        if (NamedPipeNative.GetLastError() == NamedPipeNative.ERROR_PIPE_CONNECTED)  // 客户还在连接中

                        {

                            frmServer.ActivityRef.AppendText("连接正常,客户还在连接中……" + Environment.NewLine);//此处会出错，因为线程调用的问题

                            ret = true;

                        }

                        if (NamedPipeNative.GetLastError() == NamedPipeNative.ERROR_NO_DATA)         // 客户已经关闭

                        {

                            frmServer.ActivityRef.AppendText("客户已经关闭，等待客户…………" + Environment.NewLine);

                            NamedPipeNative.DisconnectNamedPipe(ThePipe.HPipe);

                            continue;

                        }

                    }

                    else

                    {

                        frmServer.ActivityRef.AppendText("有客户接入" + Environment.NewLine);                       

                    }

                    ThePipe.ReadData();//读取数据

                }

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.ToString());

            }

            finally

            {

                frmServer.ActivityRef.AppendText("线程退出！");

            }

        }

    }

　　客户机端：

客户端是在VS6.0中用MFC开发的一个单界面应用程序，名为NamedPipeClient_vc。在vc6.0中可以直接调用API函数，不需要封装。

当然，按照惯例，还是将客户端的命名管道相关的属性和方法封装成类CMyPipe,如下：

CString PipeName = "robinTest";

CString ServerName = ".";

CString FullPipeName="\\\\"+ServerName+"\\pipe\\"+PipeName;

CMyPipe::CMyPipe()

{

       m_pThread=NULL;

}

CMyPipe::~CMyPipe()

{

       if(m_pThread)

       {

              if(TerminateThread(m_pThread->m_hThread,0))

              {

                     if(m_pThread)

                            delete      m_pThread;

                     m_pThread = NULL;

              }

       }

}

//客户端和服务器端建立连接

void CMyPipe::ClientCreateFile()

{

       BOOL ret = ::WaitNamedPipe(FullPipeName, 5000);

       if (!ret)

       {

              //ClientMsg="管道忙或者没有启动……\n";

              return;

       }

       m_hPipe  = ::CreateFile(FullPipeName,

              GENERIC_READ|GENERIC_WRITE,

              FILE_SHARE_READ|FILE_SHARE_WRITE,

              NULL,

              OPEN_EXISTING,

              FILE_ATTRIBUTE_NORMAL,

              NULL);

    if (m_hPipe == INVALID_HANDLE_VALUE)

       {

             

        char szErr[256] = "";

        DWORD dwErr = GetLastError();

              sprintf(szErr, "%l", dwErr);

        //ClientMsg=szErr;

        return;

    }

      

       //ClientMsg="打开管道了\n";

}

//写字符串

void CMyPipe::WriteString(char *szMsg)

{

       DWORD  dwSize = strlen(szMsg)+1, dwBytesWritten = 0;

       BOOL ret =WriteFile(m_hPipe, &dwSize, 4, &dwBytesWritten, NULL);

       if (ret)

       {

              BOOL ret2=WriteFile(m_hPipe, szMsg, dwSize, &dwBytesWritten, NULL);

       }

}

//写单精度

void CMyPipe::WriteFloat(float szMsg)

{

       DWORD  dwSize = 4, dwBytesWritten = 0;

       BOOL ret=WriteFile(m_hPipe, &szMsg, dwSize, &dwBytesWritten, NULL);

}

//写双精度

void CMyPipe::WriteDouble(double szMsg)

{

       DWORD  dwSize = 8, dwBytesWritten = 0;

       BOOL ret=WriteFile(m_hPipe, &szMsg, dwSize, &dwBytesWritten, NULL);

}

//写整型

void CMyPipe::WriteInt(int szMsg)

{

       DWORD  dwSize = 4, dwBytesWritten = 0;

       BOOL ret=WriteFile(m_hPipe, &szMsg, dwSize, &dwBytesWritten, NULL);

}

void CMyPipe::ClosePipe()

{

       CloseHandle(m_hPipe);

}

//读字符串

char * CMyPipe::ReadString()

{

       char *readStr;

       DWORD  drSize=0, dwBytesRead = 0;

       BOOL ret =ReadFile(m_hPipe, &drSize, 4, &dwBytesRead, NULL);

       if (ret)

       {

              readStr=new char[drSize];

              BOOL ret2=ReadFile(m_hPipe, readStr, drSize, &dwBytesRead, NULL);

       }

       return readStr;

}

int CMyPipe::ReadInt()

{

       int intRead=0;

       DWORD  drSize=4, dwBytesRead = 0;

       BOOL ret =ReadFile(m_hPipe, &intRead, drSize, &dwBytesRead, NULL);

       return intRead;

}

float CMyPipe::ReadFloat()

{

       float floatRead=0;

       DWORD  drSize=4, dwBytesRead = 0;

       BOOL ret =ReadFile(m_hPipe, &floatRead, drSize, &dwBytesRead, NULL);

       return floatRead;

}

double CMyPipe::ReadDouble()

{

       double floatRead=0;

       DWORD  drSize=8, dwBytesRead = 0;

       BOOL ret =ReadFile(m_hPipe, &floatRead, drSize, &dwBytesRead, NULL);

       return floatRead;

}

而主程序NamedPipeClient_vcDlg.cpp如下：

CMyPipe thePipe;

//连接服务器管道

void CNamedPipeClient_vcDlg::OnOpen()

{

       // TODO: Add your control notification handler code here

       thePipe.ClientCreateFile();

}

//发送数据

void CNamedPipeClient_vcDlg::OnWrite()

{

       // TODO: Add your control notification handler code here

       WriteData();

}

//关闭管道

void CNamedPipeClient_vcDlg::OnClose()

{

       // TODO: Add your control notification handler code here

       thePipe.ClosePipe();

}

//写曲线数据（注意写入的顺序，读的时候也要按照这个顺序）

void CNamedPipeClient_vcDlg::WriteCurveData()

{

       int nCurvesToWrite=10;

       thePipe.WriteInt(nCurvesToWrite);//先写入要传递的曲线总条数

       for (int j = 1; j <= nCurvesToWrite; j++)

       {

              char *curveName= "curve";//

              thePipe.WriteString(curveName);//写该曲线名称

              int nCount = 10000;//该曲线的数据总数（数组大小）

              thePipe.WriteInt(nCount);

              double *writeData=new double[nCount];

              for (int i = 0; i < nCount; i++)

              {

                     writeData[i]=i;//给每个曲线数据赋初值

                     thePipe.WriteDouble(writeData[i]);//顺序写曲线的数据

              }

       }

}

//写文本信息

void CNamedPipeClient_vcDlg::WriteTextInfo(char *textInfo)

{

       thePipe.WriteString(textInfo);

}

void CNamedPipeClient_vcDlg::WriteData()

{

       int flag=1;//传递的信息的标识，0表示曲线数据，1表示文本信息

       if (flag==0)

       {

              thePipe.WriteInt(flag);

              WriteCurveData();

       }

       else if (flag==1)

       {

              thePipe.WriteInt(flag);

              char * charWrite="hedafasfddsafdsafdsafdsafdsafsafdsafdsafdsafsaaaa";

              WriteTextInfo(charWrite);

       }

}