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

C#

浏览数:108

2019-6-8

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

 

作者:源之缘