c++ send tcp ___ server c# byte转结构

 head heads = (head)BytesToStuct(_recvDataBuffer, typeof(head));

        [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
        public struct head
        {
            public uint id;
            public uint test;
        }

        public object BytesToStuct(byte[] bytes, Type type)
        {
            //得到结构体的大小
            int size = System.Runtime.InteropServices.Marshal.SizeOf(type);
            //byte数组长度小于结构体的大小
            if (size > bytes.Length)
            {
                //返回空
                return null;
            }
            //分配结构体大小的内存空间
            IntPtr structPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(size);
            //将byte数组拷到分配好的内存空间
            System.Runtime.InteropServices.Marshal.Copy(bytes, 0, structPtr, size);
            //将内存空间转换为目标结构体
            object obj = System.Runtime.InteropServices.Marshal.PtrToStructure(structPtr, type);
            //释放内存空间
            System.Runtime.InteropServices.Marshal.FreeHGlobal(structPtr);
            //返回结构体
            return obj;
        }

 

 

 最近由于项目原因，与合作方进行socket通信，由于合作方用的是C#，发现以前屡试不爽的C++进程间用的数据结构套接字通信遇到了问题：

1. 数据错位
2. 字符串无效
3. long类型出错

一顿搜索，发现了原因出自C#与C++的区别：

C/C++	C#	长度
short	short	2Bytes
int	int	4Bytes
long(该类型在传递的时候常常会弄混)	int	4Bytes
bool	bool	1Byte
char(Ascii码字符)	byte	1Byte
wchar_t（Unicode字符，该类型与C#中的Char兼容）	char	2Bytes
float	float	4Bytes
double	double	8Bytes

    所以与C#进行数据结构通信时，首先要核对数据结构中的有区别的数据类型，不然很容易产生错位。

    其次，发现C#在以数据结构进行发送和接收时，拷贝内存的时候，会很蛋疼的自己对数据结构中的类型名称进行按名字排序：

例如：

double dLocationX1;// 

                double dLocationX2;// 

double dLocationY1;// 

      double dLocationY2;// 

double dLocationZ;//

c#默认的拷贝顺序是：

double dLocationX1;// 

double dLocationY1;// 

                double dLocationX2;// 

double dLocationY2;// 

double dLocationZ;//

 

    所以比较笨的解决办法是，把所有定义好的数据结构先手动进行按名字排序！~~ 

    当然了，方法也有，请看网上的代码示例：

 

1、仿照C++结构体写出C#的结构来 
using System.Runtime.InteropServices;

[Serializable] // 指示可序列化
[StructLayout(LayoutKind.Sequential, Pack = 1)] // 按1字节对齐
public struct Operator
{
public ushort id;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)] // 声明一个字符数组，大小为11
public char[] name;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 9)]
public char[] pass;
public Operator(string user, string pass) // 初始化
{
this.id = 10000;
this.name = user.PadRight(11, '\0').ToCharArray();
this.pass = pass.PadRight(9, '\0').ToCharArray();
}
}

2、注意C#与C++数据类型的对应关系 (可参考上表)

 

C++与C#的数据类型对应关系表 
API数据类型 类型描述 C#类型 API数据类型 类型描述 C#类型 
WORD 16位无符号整数 ushort CHAR 字符 char 
LONG 32位无符号整数 int DWORDLONG 64位长整数 long 
DWORD 32位无符号整数 uint HDC 设备描述表句柄 int 
HANDLE 句柄,32位整数 int HGDIOBJ GDI对象句柄 int 
UINT 32位无符号整数 uint HINSTANCE 实例句柄 int 
BOOL 32位布尔型整数 bool HWM 窗口句柄 int 
LPSTR 指向字符的32位指针 string HPARAM 32位消息参数 int 
LPCSTR 指向常字符的32位指针 String LPARAM 32位消息参数 int 
BYTE 字节 byte WPARAM 32位消息参数 int 

整个结构的字节数是22bytes。 

对应的C++结构体是： 

typedef struct
{
WORD id; 
CHAR name[11];
CHAR password[9];
}Operator;

3、发送的时候先要把结构转换成字节数组 

 

using System.Runtime.InteropServices; 

/// 将结构转换为字节数组
/// 结构对象
/// 字节数组
public byte[] StructToBytes(object obj)
{
//得到结构体的大小
int size = Marshal.SizeOf(obj);
//创建byte数组
byte[] bytes = new byte[size];
//分配结构体大小的内存空间
IntPtr structPtr = Marshal.AllocHGlobal(size);
//将结构体拷到分配好的内存空间
Marshal.StructureToPtr(obj, structPtr, false);
//从内存空间拷到byte数组
Marshal.Copy(structPtr, bytes, 0, size);
//释放内存空间
Marshal.FreeHGlobal(structPtr);
//返回byte数组
return bytes;
}

接收的时候需要把字节数组转换成结构 

/// byte数组转结构
/// 
/// byte数组
/// 结构类型
/// 转换后的结构
public object BytesToStruct(byte[] bytes, Type type)
{
//得到结构的大小
int size = Marshal.SizeOf(type);
Log(size.ToString(), 1);
//byte数组长度小于结构的大小
if (size > bytes.Length)
{
//返回空
return null;
}
//分配结构大小的内存空间
IntPtr structPtr = Marshal.AllocHGlobal(size);
//将byte数组拷到分配好的内存空间
Marshal.Copy(bytes, 0, structPtr, size);
//将内存空间转换为目标结构
object obj = Marshal.PtrToStructure(structPtr, type);
//释放内存空间
Marshal.FreeHGlobal(structPtr);
//返回结构
return obj;
}

4、实际操作： 

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;

byte[] Message = StructToBytes(new Operator("user","pass")); // 将结构转换成字节数组

TcpClient socket = new TcpClient();

socket.Connect(ip,port);

NetworkStream ns = Socket.GetStream();

ns.Write(Message,0,Message.Length); // 发送

byte[] Recv = new byte[1024]; // 缓冲

int NumberOfRecv = 0;

IList newRecv = new List();
ns.ReadTimeout = 3000;
try
{
do
{
// 接收响应
NumberOfRecv = ns.Read(Recv, 0, Recv.Length);
for (int i = 0; i < NumberOfRecv; i++)
newRecv.Add(Recv);
}
while (ns.DataAvailable);
byte[] resultRecv = new byte[newRecv.Count];
newRecv.CopyTo(resultRecv, 0);

Operator MyOper = new Operator();

MyOper = (Operator)BytesToStruct(resultRecv, MyOper.GetType()); // 将字节数组转换成结构

在这里取值的时候可能会出现只能取到一个字段，剩余的取不到的问题，怎么回事我也搞不懂，反正我的解决办法就是按照字节的顺序从resultRecv里分别取出对应的字段的字节数组，然后解码，例如： 

Operator.name是11个字节，最后一位是0，Operator.id是2个字节，那么从第3位到第12位的字节就是Operator.name的内容，取出另存为一个数组MyOperName，Encoding.Default.GetString(MyOperName)就是MyOper.name的内容。 

 

可以看到，该仁兄在接收解析的时候，还是被C#的默认排序给黑到了，这里还是建议暂时用比较笨的方法，等待大牛出来好方法：

  所以比较笨的解决办法是，把所有定义好的数据结构先手动进行按名字排序！~~