c# socket通信，定义消息体长度同步接收数据
因为没有文件上传，没有大的字节传输，数据过来就放到队列，所以没有用异步，使用同步方式接收数据。
原理：
1.前面四个字节是消息头，存放消息体长度；
2.后面字节定义消息体；
3.服务端收到消息后，先获取消息头部，如果不够继续接收；如果够了则根据头部计算出消息体长度；
4.根据消息头标记的长度获取消息体，如果不够，继续接收；如果够了或者有多余，重新获取消息头部，不停的循环；
private void Receive(Socket socket, string ip) { Task.Factory.StartNew(() => { var pack = new BytePkg(); while (true) { try { //如果socket已经断开，结束循环 if (!socket.Connected) { _logger.Warn($"IP:{ip},socket已断开，停止接收数据;"); break; } byte[] prevBytes = new byte[1024];//单次最多可接收的字节 int len = socket.Receive(prevBytes, prevBytes.Length, SocketFlags.None); var bytes = prevBytes.Take(len).ToArray();//实际接收的字节 this.RcvHeadData(pack, bytes); } catch (Exception ex) { _logger.Error($"IP:{ip},接收socket数据异常,message:{ex.Message},stackTrace:{ex.StackTrace};"); } } }); }
/// <summary> /// 接收消息头 /// </summary> /// <param name="pack"></param> /// <param name="bytes"></param> private void RcvHeadData(BytePkg pack, byte[] bytes) { var len = bytes.Length; pack.headIndex += len; if (pack.headIndex < pack.headLen) { for (int x = 0; x < len; x++) { pack.headBuff[pack.headIndex - len + x] = bytes[x]; }; } else { var actualHeadLen = pack.headIndex - len;//head的实际长度 var skipHeadLen = pack.headLen - actualHeadLen;//需要补上的长度；head定义长度 - head的实际长度 = body需要跳过的长度 for (int x = 0; x < skipHeadLen; x++) { pack.headBuff[actualHeadLen + x] = bytes[x]; } //★★★★★开始处理消息体部分★★★★★ var bodyLen = len;//身体长度 if (skipHeadLen > 0) { bodyLen = len - skipHeadLen;//第一次，获取剩余部分的长度 pack.InitBodyBuff();//第一次，需要初始化body } this.RcvBodyData(pack, bytes.Skip(skipHeadLen).Take(bodyLen).ToArray()); } } /// <summary> /// 接收消息体 /// </summary> /// <param name="pack"></param> /// <param name="bytes"></param> private void RcvBodyData(BytePkg pack, byte[] bytes) { var len = bytes.Length; pack.bodyIndex += len; if (pack.bodyIndex < pack.bodyLen) { for (int x = 0; x < len; x++) { pack.bodyBuff[pack.bodyIndex - len + x] = bytes[x]; }; } else { var actualBodyLen = pack.bodyIndex - len;//body的实际长度 var skipBodyLen = pack.bodyLen - actualBodyLen;//需要补上的长度；body定义长度 - body的实际长度 = 本次需要获取的body长度 for (int x = 0; x < skipBodyLen; x++) { pack.bodyBuff[actualBodyLen + x] = bytes[x]; } //处理接收到的数据 NetMsg msg = ByteHelper.DeSerialize<NetMsg>(pack.bodyBuff); this.OnReceiveMsg(msg); //重置消息包 pack.ResetData(); //★★★★★开始处理消息头部分★★★★★ this.RcvHeadData(pack, bytes.Skip(skipBodyLen).ToArray()); } }
如果不放心，可以在该加日志的地方加日志，观察代码的逻辑是否正确。说明：这是借鉴一个叫做PESocket的开源项目改的。
下面是用到的相关类：
/// <summary> /// 消息接收类 /// </summary> public class BytePkg { public int headLen = 4; public byte[] headBuff = null; public int headIndex = 0; public int bodyLen = 0; public byte[] bodyBuff = null; public int bodyIndex = 0; public BytePkg() { headBuff = new byte[4]; } public void InitBodyBuff() { bodyLen = BitConverter.ToInt32(headBuff, 0); bodyBuff = new byte[bodyLen]; } public void ResetData() { headIndex = 0; bodyLen = 0; bodyBuff = null; bodyIndex = 0; } }
/// <summary> /// 字节辅助类 /// </summary> public class ByteHelper { public static byte[] PackNetMsg<T>(T msg) where T : NetMsg { return PackLenInfo(Serialize(msg)); } public static byte[] PackLenInfo(byte[] data) { int len = data.Length; byte[] pkg = new byte[len + 4]; byte[] head = BitConverter.GetBytes(len); head.CopyTo(pkg, 0); data.CopyTo(pkg, 4); return pkg; } public static byte[] Serialize<T>(T pkg) where T : NetMsg { using (MemoryStream ms = new MemoryStream()) { BinaryFormatter bf = new BinaryFormatter(); bf.Serialize(ms, pkg); ms.Seek(0, SeekOrigin.Begin); return ms.ToArray(); } } public static T DeSerialize<T>(byte[] bs) where T : NetMsg { using (MemoryStream ms = new MemoryStream(bs)) { BinaryFormatter bf = new BinaryFormatter(); T pkg = (T)bf.Deserialize(ms); return pkg; } } }
/// <summary> /// 自定义请求数据格式 /// </summary> [Serializable] public class NetMsg { public string EPCstring; public DateTime Time; public string IP; public string CommandType; }
1.客户端：先将实体序列化，转为字节数组，然后同步发送即可，无需异步发送
2.服务端：
先想办法获取消息头
如果消息头一直没满，那就一直获取
如果消息头满了，就计算出消息体长度，并向下获取消息体
再想办法获取消息体
根据消息头包含的消息体长度，获取消息体
如果消息体一直没满，那就一直获取
如果消息体满了，那就重新获取消息头
