.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[];

协议总的包体：

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 列表
 }

NetValuePair 定义如下：

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

        public NetValuePair()
        {

        }
    }

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

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 自带的序列化类处理要高效的多，大家可以对比下。

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

            WriteInt32(stream, bytes.Length);
            stream.Write(bytes, 0, bytes.Length);
        }

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

传输

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

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

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 传送文件

 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字符串，再传送。