.net 平台下， Socket通讯协议中间件设计思路

.net 平台下，实现通讯处理有很多方法（见下表），各有利弊：

序号	实现方式	特点
1	WCF	优点：封装好，方便。缺点：难学，不跨平台
2	RocketMQ，SuperSocket等中间件	优点：轻便 缺点：用户群体少
3	直接使用winsocket	优点：全部在自己掌控之下，协议灵活。缺点：实现时间长，易于出错。

本人开发socket通讯多年了，一直干着“重复发明轮子”工作，这种工作方式效率低下，容易出错！

重复的事情做多了，也会出现“灵光“！何不自己设计一套中间件，在此基础上，再设计应用层协议。就可以避免“重复发明轮子”。

先看下图，协议栈：

本文讲述的就是绿色部分如何设计。

这层协议设计原则有：

1.  要简单 有两层意思：一是协议简单；再者使用起来简单。并且可以满足大部分应用场景。
2. 可以跨平台  .net core本身可以跨平台。 如果对方使用c、c++开发，用其他语言实现该协议也不难。
3. 隐藏底层细节 应用层，处理对象都是.net类，而不是字节流。
4. 可以大数据传输  无论传输多大的数据，不必考虑分包合包处理。

设计思路

总的原则是，传输的是.net平台下的类，而不是字节流。直接处理.net类要比字节流要方便，安全很多。

.net平台下类型很多，我提取了最常用的几种，达到即简单，又满足大部分应用场景的要求。

可以传输的类型有：int、string、short、long，byte；

以及对应链表类型: List<int>、List<string>、List<short>、List<long>、byte[];

 

协议总的包体：

 

?

1 2 3 4 5

public class NetPacket     {         public int PacketType { get; set; } // 包类型         public int Param1 { get; set; }     // 参数1 ，可以根据实际情况使用         public int Param2 { get; set; }     // 参数2 ，可以根据实际情况使用        public List<NetValuePair> Items { get; set; } //传输的key value 列表<br> }

 

NetValuePair 定义如下：

?

1 2 3 4 5 6 7 8 9 10

public class NetValuePair {     public string Key { get; set; }     public NetValueBase Value { get; set; }       public NetValuePair()     {       } }

　NetValueBase 包含子类型，分别对应string、int等。以string类型举例：

?

1 2 3 4 5 6 7 8 9

public class NetValueBase     {         public EN_DataType ValueType { get;protected set; }           public virtual object GetValue()         {             return null;         }     }

　　

public class NetValueString: NetValueBase
    {
        public string Value { get; set; } = string.Empty;
        public override object GetValue()
        {
            return Value;
        }

        public NetValueString()
        {
            ValueType = EN_DataType.en_string;
        }

        public NetValueString(string value)
        {
            ValueType = EN_DataType.en_string;
            Value = value;
        }
    }

NetValueString值最终要以字节流方式传送出去，采用如下方式序列化：
string值采用utf8传输，先将字符串转换成字节流；分别写入字节流的长度，实际的字节流；
在序列化中，没用多余字段。比.net 自带的序列化类处理要高效的多，大家可以对比下。

?

1 2 3 4 5 6 7

internal static void WriteStringValue(Stream stream, string value)        {            byte[] bytes = Encoding.UTF8.GetBytes(value);              WriteInt32(stream, bytes.Length);            stream.Write(bytes, 0, bytes.Length);        }

其它类型的序列化，与此类似，不在累述。反序列化如何操作，也不难想像。

传输

序列化后的数据要发送出去，需要下一层来处理。

这层的主要功能就是分包和合包。（数据很小的时候就不需要分包了）

?

1 2 3 4 5 6 7 8

public class RawNetPacket     {         public static int HeadLen = 14;         public UInt16 PacketLen;         public UInt32 PacketId;   //一个完整的包 唯一id         public UInt32 TotalNO;    //共有多少个包         public UInt32 PacketNO;   //包序列号         public byte[] Body;     //承载NetPacket序列化的数据，有可能分包发送}

 具体如何分包和合包，可以参考附件源码。

使用举例

1 传送文件

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

private NetPacket GetPacketByFile(string fileName)        {            using (FileStream stream = new FileInfo(fileName).OpenRead())            {                NetPacket result = new NetPacket();                result.PacketType = 2;                result.Param1 = 2;                result.Param2 = 3;                result.Items = new List<NetValuePair>();                  //string                NetValuePair pair = new NetValuePair();                pair.Key = "文件名称";                pair.Value = new NetValueString(fileName);                result.Items.Add(pair);                  //byte                pair = new NetValuePair();                pair.Key = "文件二进制数据";                NetValueListByte fileBuffer = new NetValueListByte();                fileBuffer.Value = new byte[stream.Length];                stream.Read(fileBuffer.Value, 0, Convert.ToInt32(stream.Length));                  pair.Value = fileBuffer;                result.Items.Add(pair);                return result;            }        }

 

　2 传输对象

  可以将对象序列化为json字符串，再传送。