C#网络编程数据传输中封装数据帧头的方法

　　在C/S端编程的时候，经常要在C端和S端之间传数据时自定义一下报文的帧头，如果是在C/C++，封装帧头是一件很简单的事情，直接把unsigned char *强转为struct就行，但是在C#中，并没有提供直接从struct到byte[]的转换，这个时候就需要用到Marshal等非托管的方法了。

自定义帧

---

我们可以在C#中写出如下代码：

 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = ,Size = )]
 [Serializable()]
  public struct DatagramHeaderFrame
 {
             // MessageType类型：
             public MessageType MsgType;

             //一个四个字节的特征码
             public uint FeatureCode;

             //用于标识报文的长度，用于校验
             public int MessageLength;
   }

　　首先我们说明一下，StructLayout是一个用于管理struct的布局特性，

CharSet指示在默认情况下是否应将类中的字符串数据字段作为 LPWSTR 或 LPSTR 进行封送处理；

Pack控制类或结构的数据字段在内存中的对齐方式。

Size指示类或结构的绝对大小。

　　LayoutKind是布局的类型，这个枚举有三个值：

Auto，运行库自动为非托管内存中的对象的成员选择适当的布局。 使用此枚举成员定义的对象不能在托管代码的外部公开。 尝试这样做将引发异常。

Explicit，在未管理内存中的每一个对象成员的精确位置是被显式控制的，服从于 StructLayoutAttribute. Pack 字段的设置。每个成员必须使用 FieldOffsetAttribute 指示该字段在类型中的位置。在MSDN文档中为我们展示了下面的一个例子：

 [StructLayout(LayoutKind.Explicit)]
 public struct Rect
 {
    [FieldOffset()] public int left;
    [FieldOffset()] public int top;
    [FieldOffset()] public int right;
    [FieldOffset()] public int bottom;
 }   

Sequential，对象的成员按照它们在被导出到非托管内存时出现的顺序依次布局。 这些成员根据在 StructLayoutAttribute. Pack 中指定的封装进行布局，并且可以是不连续的。

　　Serialzable是一个用于指示对象是否能序列化的特性，简单的来说序列化的用处就是，比如我客户端给你传一定的数据，这个数据不是标准的类型的时候，如果我们不使用序列化的时候，我们就要把数据的每个部分都转成二进制然后存储，就很麻烦，而且容易出错，所以C#就提供了这样一个机制给程序员简单使用并且转成二进制（或者其他格式）来使用（使用formatter），而且当一个对象没有被标明为可序列化的时候，我们使用formatter的时候会报错，具体怎么使用请查看MSDN文档即可。比如文档有这样一段代码：

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Soap;
//using System.Runtime.Serialization.Formatters.Binary;

public class Test {
   public static void Main()  {

      //Creates a new TestSimpleObject object.
      TestSimpleObject obj = new TestSimpleObject();

      Console.WriteLine("Before serialization the object contains: ");
      obj.Print();

      //Opens a file and serializes the object into it in binary format.
      Stream stream = File.Open("data.xml", FileMode.Create);
      SoapFormatter formatter = new SoapFormatter();

      //BinaryFormatter formatter = new BinaryFormatter();

      formatter.Serialize(stream, obj);
      stream.Close();

      //Empties obj.
      obj = null;

      //Opens file "data.xml" and deserializes the object from it.
      stream = File.Open("data.xml", FileMode.Open);
      formatter = new SoapFormatter();

      //formatter = new BinaryFormatter();

      obj = (TestSimpleObject)formatter.Deserialize(stream);
      stream.Close();

      Console.WriteLine("");
      Console.WriteLine("After deserialization the object contains: ");
      obj.Print();
   }
}

// A test object that needs to be serialized.
[Serializable()]
public class TestSimpleObject  {

    public int member1;
    public string member2;
    public string member3;
    public double member4;

    // A field that is not serialized.
    [NonSerialized()] public string member5; 

    public TestSimpleObject() {

        member1 = ;
        member2 = "hello";
        member3 = "hello";
        member4 = 3.14159265;
        member5 = "hello world!";
    }

    public void Print() {

        Console.WriteLine("member1 = '{0}'", member1);
        Console.WriteLine("member2 = '{0}'", member2);
        Console.WriteLine("member3 = '{0}'", member3);
        Console.WriteLine("member4 = '{0}'", member4);
        Console.WriteLine("member5 = '{0}'", member5);
    }
}

封装和解析

---

　　要解析一个struct并且把他变成bytes，需要用到非托管的方法：

        public static byte[] StructToBytes(object structObj)
        {
            int size = Marshal.SizeOf(structObj);
            IntPtr buffer = Marshal.AllocHGlobal(size);
            try
            {
                Marshal.StructureToPtr(structObj, buffer, false);
                byte[] bytes = new byte[size];
                Marshal.Copy(buffer, bytes, , size);
                return bytes;
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }

要把bytes变成sturct，反过来即可：

         public static object BytesToStruct(byte[] bytes, Type strcutType)
         {
             int size = Marshal.SizeOf(strcutType);
             IntPtr buffer = Marshal.AllocHGlobal(size);
             try
             {
                 Marshal.Copy(bytes, , buffer, size);
                 return Marshal.PtrToStructure(buffer, strcutType);
             }
             finally
             {
                 Marshal.FreeHGlobal(buffer);
             }
         }

下面演示一下在socket上传输报文+帧头：

         public static byte[] PackingMessageToBytes
             (MessageType messageType, uint featureCode, int messageLength, byte[] msgBytes)
         {
             DatagramHeaderFrame frame = new DatagramHeaderFrame();
             frame.MsgType = messageType;
             frame.FeatureCode = featureCode;
             frame.MessageLength = messageLength;

             byte[] header = StructToBytes(frame);

             byte[] datagram = new byte[header.Length + msgBytes.Length];
             header.CopyTo(datagram, );
             msgBytes.CopyTo(datagram, FrameSize);

             return datagram;
         }

         /// <summary>
         /// 封装消息和报文
         /// </summary>
         /// <param name="headerFrame">报文帧头</param>
         /// <param name="message">报文</param>
         /// <param name="encoding">编码器</param>
         /// <returns></returns>
         public static byte[] PackingMessageToBytes
             (DatagramHeaderFrame headerFrame, byte[] msgBytes)
         {
             byte[] header = StructToBytes(headerFrame);

             byte[] datagram = new byte[header.Length + msgBytes.Length];
             header.CopyTo(datagram, );
             msgBytes.CopyTo(datagram, FrameSize);

             return datagram;

接收端代码节选：

 DatagramHeaderFrame headerFrame = new DatagramHeaderFrame();
 headerFrame.MsgType = messageType;
 headerFrame.MessageLength = bytes.Length;
 byte[] datagram = PackingMessageToBytes(headerFrame, bytes);

 GetStream().BeginWrite(datagram, , datagram.Length, HandleDatagramWritten, this);

发送端代码节选：

 DatagramHeaderFrame headerFrame = new DatagramHeaderFrame();
 byte[] datagramBytes = new byte[];

 byte[] datagramBuffer = (byte[])ar.AsyncState;
 byte[] recievedBytes = new byte[numberOfRecievedBytes];

 Buffer.BlockCopy(datagramBuffer, , recievedBytes, , numberOfRecievedBytes);
                 PrasePacking(recievedBytes, numberOfRecievedBytes, ref headerFrame, ref datagramBytes);

 GetStream().BeginRead(datagramBuffer, , datagramBuffer.Length, HandleDatagramReceived, datagramBuffer);

C++端解析和封装的代码（用Qt写的）

 QByteArray TcpHeaderFrameHelper::bindHeaderAndDatagram(const TcpHeaderFrame &header,const QByteArray &realDataBytes)
 {
     QByteArray byteArray, temp;
     temp.resize();

     unsignedToQByteArray((unsigned)header.messageType, temp);
     byteArray += temp;

     unsignedToQByteArray((unsigned)header.featureCode, temp);
     byteArray += temp;

     unsignedToQByteArray((unsigned)header.messageLength, temp);
     byteArray += temp;

     byteArray +=realDataBytes;
     return byteArray;
 }

 void TcpHeaderFrameHelper::praseHeaderAndDatagram(const QByteArray &dataBytes,TcpHeaderFrame &headerFrame,QByteArray &realDataBytes)
 {
     realDataBytes.resize(dataBytes.size() - TcpHeaderFrameHelper::headerSize);
     headerFrame.messageType = qByteArrayToInt(dataBytes.left());
     headerFrame.featureCode = qByteArrayToInt(dataBytes.mid(,));
     headerFrame.messageLength = qByteArrayToInt(dataBytes.mid(,));

     realDataBytes = dataBytes.mid(, dataBytes.size());
 }

 unsigned TcpHeaderFrameHelper::qByteArrayToInt(QByteArray bytes)
 {
     int result = ;
     result |= ((bytes[]) & 0x000000ff);
     result |= ((bytes[] << ) & 0x0000ff00);
     result |= ((bytes[] << ) & 0x00ff0000);
     result |= ((bytes[] << ) & 0xff000000); 

     return result;
 }

 void TcpHeaderFrameHelper::unsignedToQByteArray(unsigned num, QByteArray &bytes)
 {
     bytes.resize();
     bytes[] = (char)( 0x000000ff & num);
     bytes[] = (char)((0x0000ff00 & (num)) >> );
     bytes[] = (char)((0x00ff0000 & (num)) >> );
     bytes[] = (char)((0xff000000 & (num)) >> );
 }