（二）一个工作任务引起的乱战——C++程序编译为dll，让C#调用

C++程序编译为C#可调用的dll的过程：

1.新建一个Win32 Console Application 项目，项目名为：DLLDemo,下一步选择Application type为DLL;

2.在Source Files文件夹的DLLDemo.cpp文件中加入代码：

extern "C" _declspec(dllexport) int Add(int a,int b){

    return a+b;

}

这个函数将在C#中调用。

3.build项目。

会在D:\\visualStudio\\Projects\\DLLDemo\\Debug看到DLLDemo.dll文件，该文件就是要被C#调用的dll。

C#调用C++dll的方法：

using System;

using System.Collections.Generic;

using System.Text;

using System.Runtime.InteropServices;



namespace InteropDemo

{

    class Program

    {

        [DllImport("D:\\visualStudio\\Projects\\DLLDemo\\Debug\\DLLDemo.dll", EntryPoint = "Add", CallingConvention = CallingConvention.Cdecl)]

        public static extern int Add(int a, int b); //DllImport请参照MSDN



        static void Main(string[] args)

        {

            Console.WriteLine(Add(1, 2));

            Console.Read();

        }

    }

}

 【运行结果】：

3

注意：CallingConvention = CallingConvention.Cdecl参数很重要，如果没有错，会抛异常。

这是Windows下c++程序编译成dll供c#调用的方法，可惜还是不能解决工作任务，因为那个api是Linux下的源码。于是，我只能自己写代码，包装请求参数，发消息。下面的文字是我处理工作任务的过程，可以跳过不看，因为没有处理成功，对你们可能没有太大的帮助。

现在介绍下服务接入文档，其请求包要求如下：

上图请求包中参数m_sContent的格式如下：

如果自己包装请求，这里存在两个问题不知道怎么解决：

首先，两图中结构体每个成员的需要限定长度；

其次，在请求包中m_sContent本来是规定为string类型的，又做了另一个规定为结构体，这中间存在一个转换问题，理解不透。

在处理这个问题的过程中，我采用了三种方法：

首先定义的结构体为：

//请求包结构体定义

        public struct ReqPackage

        {

            public string m_cVersion;//协议的版本号

            public uint m_dwNeedRst;//是否需要返回

            public uint m_dwCmd;//请求的服务类型

            public uint m_dwContentLen;//内容有效长度

            public string m_sContent;//内容为请求命令或者返回的相关信息

            public uint m_dwPkgSeq;//upd包序列号，tcp下为0

        };



        //消息内容结构体定义

        public struct MsgReq

        {

            public uint m_iFuid;// 用户ID

            public int m_iMask;//发送屏蔽码*

            public int m_iMsgLen;//消息的有效长度

            public string m_sMsgContent;//消息

        }

1.将两个结构体转化为byte[]然后处理长度。处理过程有误，没有成功；后来发现这段代码也有错误，不能这样处理。

  //将请求包各参数按长度组合好

        public byte[] ReqPackageTo(ReqPackage reqPackage)

        {

            byte[] structudp = StructToBytes(reqPackage);

            List<byte> bufferIn = new List<byte>();

            var parametersVer = new byte[4];

            parametersVer = BitConverter.GetBytes(structudp[0]);

            bufferIn.AddRange(parametersVer);

            for (int i = 1; i < structudp.Length; i++)

            {

                if (i != 4)

                {

                    var parameters = new byte[4];

                    parameters = BitConverter.GetBytes(structudp[i]);

                    bufferIn.AddRange(parameters);

                }

                else//消息内容实际长度以m_dwContentLen为准，最大长度为846字节

                {

                    uint sizeCon = reqPackage.m_dwContentLen;

                    var parametersCon = new byte[sizeCon];

                    parametersCon = System.Text.Encoding.Default.GetBytes(reqPackage.m_sContent);

                    bufferIn.AddRange(parametersCon);

                }



            }

            return bufferIn.ToArray();

        }





        //将消息内容各参数按长度组合好

        public byte[] MsgReqTo(MsgReq msgReq)

        {

            byte[] structMsg = StructToBytes(msgReq);

            List<byte> bufferIn = new List<byte>();

            for (int i = 1; i < structMsg.Length; i++)

            {

                if (i != 3)

                {

                    var parameters = new byte[4];

                    parameters = BitConverter.GetBytes(structMsg[i]);

                    bufferIn.AddRange(parameters);

                }

                else//消息内容实际长度以m_iMsgLen为准，最大长度为846字节

                {

                    int sizeCon = msgReq.m_iMsgLen;



                    var parametersCon = new byte[sizeCon];

                    parametersCon = parametersCon = System.Text.Encoding.Default.GetBytes(msgReq.m_sMsgContent);

                    bufferIn.AddRange(parametersCon);

                }



            }

            return bufferIn.ToArray();

        } 

2.将m_sContent结构体的各个成员单独处理，均先转换为byte[],限定长度，然后转换成一个byte[]，再转换成string（为的是赋值给请求包中m_sContent）。然后将请求包中的各个成员单独处理，均先转换为byte[],限定长度，然后转换成一个byte[]。没有成功；

//将请求包各参数按长度组合好

        public byte[] reqPackBytes(ReqPackage reqp)

        {

            List<byte> bufferIn = new List<byte>();

            var m_cVersion = new byte[1];

            m_cVersion = System.Text.Encoding.Default.GetBytes(reqp.m_cVersion);

            var m_dwCmd = new byte[4];

            m_dwCmd = System.BitConverter.GetBytes(reqp.m_dwCmd);

            var m_dwNeedRst = new byte[4];

            m_dwNeedRst = System.BitConverter.GetBytes(reqp.m_dwNeedRst);

            //var m_dwPkgSeq = new byte[4];

            //m_dwPkgSeq=System.BitConverter.GetBytes(reqp.m_dwPkgSeq);

            var m_dwContentLen = new byte[4];

            m_dwContentLen = System.BitConverter.GetBytes(reqp.m_dwContentLen);

            byte[] m_sContent = System.Text.Encoding.Default.GetBytes(reqp.m_sContent);

            bufferIn.AddRange(m_cVersion);

            bufferIn.AddRange(m_dwCmd);

            bufferIn.AddRange(m_dwNeedRst);

            bufferIn.AddRange(m_dwContentLen);

            bufferIn.AddRange(m_sContent);

            //   bufferIn.AddRange(m_dwPkgSeq);

            return bufferIn.ToArray();

        }





        //将消息内容各参数按长度组合好

        public byte[] msConBytes(MsgReq msgR)

        {

            List<byte> bufferIn = new List<byte>();

            var m_iFuid = new byte[4];

            m_iFuid = System.BitConverter.GetBytes(msgR.m_iFuid);

            var m_iMask = new byte[4];

            m_iMask = System.BitConverter.GetBytes(msgR.m_iMask);

            var m_iMsgLen = new byte[4];

            m_iMsgLen = System.BitConverter.GetBytes(msgR.m_iMsgLen);

            byte[] m_sMsgContent = System.Text.Encoding.Default.GetBytes(msgR.m_sMsgContent);

            bufferIn.AddRange(m_iFuid);

            bufferIn.AddRange(m_iMask);

            bufferIn.AddRange(m_iMsgLen);

            bufferIn.AddRange(m_sMsgContent);

            return bufferIn.ToArray();

        }

3.比较笨的一种方法，手动拼字节。没有成功。

StringBuilder msgBodyBuffer = new StringBuilder(846);//m_sContent

                String msgBody = msgBodyBuffer.ToString();

                byte[] msgBodyBytes = System.Text.Encoding.Default.GetBytes(msgBody);

                byte[] msg = new byte[859];     

                msg[0] = 0x02; // 协议版本

                msg[1] = 0;

                msg[2] = 0;

                msg[3] = 0;

                msg[4] = (byte)1; // 是否响应

                msg[5] = 0;

                msg[6] = 0;

                msg[7] = 0;

                msg[8] = 0;

                msg[9] = 0;

                msg[10] = 0;

                msg[11] = 0; // 请求的服务类型

                msg[12] = (byte)(0x325 & 0xFF); // 请求命令的有效长度, 为什么是0x2D?

                msg[13] = (byte)((0x325 >> 8) & 0xFF);

                msg[14] = 0;

                msg[15] = 0;

                uint uid = 0;

                String uidStr = Fuid;

                if (uidStr != null && uidStr.Length > 0)

                    uid = uint.Parse(uidStr);

                msg[17] = (byte)(uid & 0xFF);

                msg[18] = (byte)((uid >> 8) & 0xFF);

                msg[19] = (byte)((uid >> 16) & 0xFF);

                msg[20] = (byte)((uid >> 24) & 0xFF);

                msg[21] = 0;

                msg[22] = 0;

                msg[23] = 0;

                msg[24] = (byte)1; // 发送屏蔽码

                int length = msgBodyBytes.Length;

                if (length > 834)

                    length = 834;

                msg[25] = 0;

                msg[26] = 0;

                msg[27] = (byte)(length & 0xFF);  // 消息的有效长度

                msg[28] = (byte)((length >> 8) & 0xFF);

                Array.Copy(msgBodyBytes, 0, msg, 28, length);

整了不少时间还没整出来，备受打击。希望能找到解决方法。

下一文将介绍udp通信。