C# Socket系列三 socket通信的封包和拆包
通过系列二 我们已经实现了socket的简单通信 接下来我们测试一下，在时间应用的场景下，我们会快速且大量的传输数据的情况！
class Program
{
static void Main(string[] args)
{
TCPListener tcp = new TCPListener();
TSocketClient client = new TSocketClient();
; i < ; i++)
{
client.SendMsg(System.Text.UTF8Encoding.Default.GetBytes("Holle Server！"));
}
Console.ReadLine();
}
}
我们通过测试代码快速发送10条消息到服务器去，
我们看看运行结果
这样不难看出，我们的客户端发送了10条消息，但是服务器收到的时候变成了两条消息，回复客户端自然就变成两次回复。
这是为什么呢？
我们修改一下程序一秒钟发送一次消息试试
class Program
{
static void Main(string[] args)
{
TCPListener tcp = new TCPListener();
TSocketClient client = new TSocketClient();
; i < ; i++)
{
Thread.Sleep();
client.SendMsg(System.Text.UTF8Encoding.Default.GetBytes("Holle Server！"));
}
Console.ReadLine();
}
}
运行看看，
这次对了那么分析分析到底为什么呢？这是socket的底层，做的手脚。因为我设置socket的发送和接受缓冲区//10K的缓冲区空间 private int BufferSize = 10 * 1024; 10k的缓冲区，且socket的底层 发送消息会有一定间隙，虽然这个时间很短，但是我们直接for循环发送的话，时间同意很快，因为socket.send()方法并非真实的发送数据而是把数据压入发送缓冲区。那么我们就明白了为什么会出现上面的情况出现了这样的情况我们要怎么解决呢？时间应用场景不可能1秒钟才一条消息啥。我们知道了导致这个问题的原因是因为消息发送是出现了快速压入很多发送消息到待发送缓冲区里面一起发送导致的。这样情况就是粘包了，那么我们是不是可以考虑给每一个消息加入包标识呢？
接下来我们修改一下发送包的数据代码
创建消息的构造体 TSocketMessage
/// <summary>
/// 底层通信消息
/// </summary>
public class TSocketMessage : IDisposable
{
/// <summary>
/// 消息ID
/// </summary>
public int MsgID;
/// <summary>
/// 消息内容
/// </summary>
public byte[] MsgBuffer;
public TSocketMessage(int msgID, byte[] msg)
{
this.MsgID = msgID;
this.MsgBuffer = msg;
}
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool flag1)
{
if (flag1) { this.MsgBuffer = null; }
}
}
接下来我们创建消息包的封装和拆分 MarshalEndian
public class MarshalEndian
{
//用于存储剩余未解析的字节数
);
//默认是utf8的编码格式
private UTF8Encoding utf8 = new UTF8Encoding();
//包头1
const Int16 t1 = 0x55;
//包头2
const Int16 t2 = 0xAA;
//字节数常量 两个包头4个字节，一个消息id4个字节，封装消息长度 long 8个字节
const long ConstLenght = 12L;
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool flag1)
{
if (flag1)
{
IDisposable disposable2 = this.utf8 as IDisposable;
if (disposable2 != null) { disposable2.Dispose(); }
IDisposable disposable = this._LBuff as IDisposable;
if (disposable != null) { disposable.Dispose(); }
}
}
public byte[] Encode(TSocketMessage msg)
{
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms, new UTF8Encoding());
byte[] msgBuffer = msg.MsgBuffer;
#region 封装包头
bw.Write((Int16)t1);
bw.Write((Int16)t2);
#endregion
#region 包协议
if (msgBuffer != null)
{
bw.Write((Int64)(msgBuffer.Length + ));
bw.Write(msg.MsgID);
bw.Write(msgBuffer);
}
); }
#endregion
bw.Close();
ms.Close();
bw.Dispose();
ms.Dispose();
return ms.ToArray();
}
public List<TSocketMessage> GetDcAppMess(byte[] buff, int len)
{
//拷贝本次的有效字节
byte[] _b = new byte[len];
Array.Copy(buff, , _b, , _b.Length);
buff = _b;
)
{
//拷贝之前遗留的字节
this._LBuff.AddRange(_b);
buff = this._LBuff.ToArray();
this._LBuff.Clear();
);
}
List<TSocketMessage> list = new List<TSocketMessage>();
MemoryStream ms = new MemoryStream(buff);
BinaryReader buffers = new BinaryReader(ms, this.utf8);
try
{
byte[] _buff;
Label_0073:
//判断本次解析的字节是否满足常量字节数
if ((buffers.BaseStream.Length - buffers.BaseStream.Position) < ConstLenght)
{
_buff = new byte[(int)(buffers.BaseStream.Length - buffers.BaseStream.Position)];
Array.Copy(buff, (, _buff.Length);
this._LBuff.AddRange(_buff);
return list;
}
#region 包头读取
//循环读取包头
Label_00983:
Int16 tt1 = buffers.ReadInt16();
Int16 tt2 = buffers.ReadInt16();
if (!(tt1 == t1 && tt2 == t2))
{
, SeekOrigin.Current);
goto Label_00983;
}
#endregion
#region 包协议
long offset = buffers.ReadInt64();
#endregion
#region 包解析
//剩余字节数大于本次需要读取的字节数
if (offset < (buffers.BaseStream.Length - buffers.BaseStream.Position))
{
int msgID = buffers.ReadInt32();
_buff = ];
Array.Copy(buff, (, _buff.Length);
list.Add(new TSocketMessage(msgID, _buff));
//设置偏移量 然后继续循环读取
buffers.BaseStream.Seek(offset, SeekOrigin.Current);
goto Label_0073;
}
else if (offset == (buffers.BaseStream.Length - buffers.BaseStream.Position))
{
int msgID = buffers.ReadInt32();
//剩余字节数刚好等于本次读取的字节数
_buff = ];
Array.Copy(buff, (, _buff.Length);
list.Add(new TSocketMessage(msgID, _buff));
}
else
{
//剩余字节数刚好小于本次读取的字节数 存起来，等待接受剩余字节数一起解析
_buff = new byte[(int)(buffers.BaseStream.Length - buffers.BaseStream.Position + ConstLenght)];
Array.Copy(buff, (, _buff.Length);
buff = _buff;
this._LBuff.AddRange(_buff);
}
#endregion
}
catch { }
finally
{
if (buffers != null) { buffers.Dispose(); }
buffers.Close();
if (buffers != null) { buffers.Dispose(); }
ms.Close();
if (ms != null) { ms.Dispose(); }
}
return list;
}
}
接下来我们修改一下 TSocketBase 的 抽象方法
public abstract void Receive(TSocketMessage msg);
在修改接受消息回调函数
/// <summary>
/// 消息解析器
/// </summary>
MarshalEndian mersha = new MarshalEndian();
/// <summary>
/// 接收消息回调函数
/// </summary>
/// <param name="iar"></param>
private void ReceiveCallback(IAsyncResult iar)
{
if (!this.IsDispose)
{
try
{
//接受消息
ReceiveSize = _Socket.EndReceive(iar, out ReceiveError);
//检查状态码
if (!CheckSocketError(ReceiveError) && SocketError.Success == ReceiveError)
{
//判断接受的字节数
)
{
byte[] rbuff = new byte[ReceiveSize];
Array.Copy(this.Buffers, rbuff, ReceiveSize);
var msgs = mersha.GetDcAppMess(rbuff, ReceiveSize);
foreach (var msg in msgs)
{
this.Receive(msg);
}
//重置连续收到空字节数
ZeroCount = ;
//继续开始异步接受消息
ReceiveAsync();
}
else
{
ZeroCount++;
) { this.Close("错误链接"); }
}
}
}
catch (System.Net.Sockets.SocketException) { this.Close("链接已经被关闭"); }
catch (System.ObjectDisposedException) { this.Close("链接已经被关闭"); }
}
}
这样我们完成了在收到消息后对数据包的解析。
修改一下TSocketClient的 Receive 重写方法
/// <summary>
/// 收到消息后
/// </summary>
/// <param name="rbuff"></param>
public override void Receive(TSocketMessage msg)
{
Console.WriteLine("Receive ID：" + msg.MsgID + " Msg：" + System.Text.UTF8Encoding.Default.GetString(msg.MsgBuffer));
if (isServer)
{
this.SendMsg(new TSocketMessage(msg.MsgID, System.Text.UTF8Encoding.Default.GetBytes("Holle Client！")));
}
}
修改测试代码如下
class Program
{
static void Main(string[] args)
{
TCPListener tcp = new TCPListener();
TSocketClient client = new TSocketClient();
; i < ; i++)
{
Thread.Sleep();
client.SendMsg(new TSocketMessage(i, System.Text.UTF8Encoding.Default.GetBytes("Holle Server！")));
}
Console.ReadLine();
}
}
运行结果
接受成功了，那么我们取消暂停状态，快速发送消息试试
class Program
{
static void Main(string[] args)
{
TCPListener tcp = new TCPListener();
TSocketClient client = new TSocketClient();
; i < ; i++)
{
client.SendMsg(new TSocketMessage(i, System.Text.UTF8Encoding.Default.GetBytes("Holle Server！")));
}
Console.ReadLine();
}
}
看看运行结果
瞬间完成了消息发送，也没有再出现第一次运行的那样~！
这样完美的解决了socket通信 在传输上发送粘包问题
谢谢园友发现的问题，
问题是这样的原本的解包和封包的测试代码不够严谨导致解析包出现错误感谢园友发现问题，并提出问题。
附上最新的代码
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace TSocket
{
public class MarshalEndian
{
//用于存储剩余未解析的字节数
);
//默认是utf8的编码格式
private UTF8Encoding utf8 = new UTF8Encoding();
//包头1
const Int16 t1 = 0x55;
//包头2
const Int16 t2 = 0xAA;
//字节数常量 两个包头4个字节，一个消息id4个字节，封装消息长度 int32 4个字节
;
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool flag1)
{
if (flag1)
{
IDisposable disposable2 = this.utf8 as IDisposable;
if (disposable2 != null) { disposable2.Dispose(); }
IDisposable disposable = this._LBuff as IDisposable;
if (disposable != null) { disposable.Dispose(); }
}
}
public byte[] Encode(TSocketMessage msg)
{
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms, new UTF8Encoding());
byte[] msgBuffer = msg.MsgBuffer;
#region 封装包头
bw.Write((Int16)t1);
bw.Write((Int16)t2);
#endregion
#region 包协议
if (msgBuffer != null)
{
bw.Write((Int32)(msgBuffer.Length + ));
bw.Write(msg.MsgID);
bw.Write(msgBuffer);
}
); }
#endregion
bw.Close();
ms.Close();
bw.Dispose();
ms.Dispose();
return ms.ToArray();
}
public List<TSocketMessage> GetDcAppMess(byte[] buff, int len)
{
//拷贝本次的有效字节
byte[] _b = new byte[len];
Array.Copy(buff, , _b, , _b.Length);
buff = _b;
)
{
//拷贝之前遗留的字节
this._LBuff.AddRange(_b);
buff = this._LBuff.ToArray();
this._LBuff.Clear();
);
}
List<TSocketMessage> list = new List<TSocketMessage>();
MemoryStream ms = new MemoryStream(buff);
BinaryReader buffers = new BinaryReader(ms, this.utf8);
try
{
byte[] _buff;
Label_00983:
#region 包头读取
//循环读取包头
//判断本次解析的字节是否满足常量字节数
if ((buffers.BaseStream.Length - buffers.BaseStream.Position) < ConstLenght)
{
_buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position));
this._LBuff.AddRange(_buff);
return list;
}
Int16 tt1 = buffers.ReadInt16();
Int16 tt2 = buffers.ReadInt16();
if (!(tt1 == t1 && tt2 == t2))
{
, SeekOrigin.Current);
goto Label_00983;
}
#endregion
#region 包协议
int offset = buffers.ReadInt32();
#endregion
#region 包解析
//剩余字节数大于本次需要读取的字节数
if (offset <= (buffers.BaseStream.Length - buffers.BaseStream.Position))
{
int msgID = buffers.ReadInt32();
_buff = buffers.ReadBytes(offset - );
list.Add(new TSocketMessage(msgID, _buff));
)
{
goto Label_00983;
}
}
else
{
//剩余字节数刚好小于本次读取的字节数 存起来，等待接受剩余字节数一起解析
_buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position + ConstLenght));
this._LBuff.AddRange(_buff);
}
#endregion
}
catch (Exception ex) { Console.WriteLine(ex); }
finally
{
if (buffers != null) { buffers.Dispose(); }
buffers.Close();
if (buffers != null) { buffers.Dispose(); }
ms.Close();
if (ms != null) { ms.Dispose(); }
}
return list;
}
}
}
C# Socket系列三 socket通信的封包和拆包的更多相关文章
- socket系列之socket服务端与客户端如何通信
上面已经分别介绍了ServerSocket跟Socket的工作步骤,并且从应用层往系统底层剖析其运作原理,我们清楚了他们各自的一块,现在我们将把他们结合起来,看看他们是如何通信的,并详细讨论一下他们之 ...
- java学习小笔记（三.socket通信）【转】
三,socket通信1.http://blog.csdn.net/kongxx/article/details/7288896这个人写的关于socket通信不错,循序渐进式的讲解,用代码示例说明,运用 ...
- 网络编程 TCP协议:三次握手,四次回收,反馈机制 socket套接字通信 粘包问题与解决方法
TCP协议:传输协议,基于端口工作 三次握手,四次挥手 TCP协议建立双向通道. 三次握手, 建连接: 1:客户端向服务端发送建立连接的请求 2:服务端返回收到请求的信息给客户端,并且发送往客户端建立 ...
- C#下利用封包、拆包原理解决Socket粘包、半包问题（新手篇）
介于网络上充斥着大量的含糊其辞的Socket初级教程,扰乱着新手的学习方向,我来扼要的教一下新手应该怎么合理的处理Socket这个玩意儿. 一般来说,教你C#下Socket编程的老师,很少会教你如何解 ...
- 进程间通信系列 之 socket套接字实例
进程间通信系列 之 概述与对比 http://blog.csdn.net/younger_china/article/details/15808685 进程间通信系列 之 共享内存及其实例 ...
- 进程间通信系列 之 socket套接字及其实例
进程间通信系列 之 概述与对比 http://blog.csdn.net/younger_china/article/details/15808685 进程间通信系列 之 共享内存及其实例 ...
- python socket+tcp三次握手四次撒手学习+wireshark抓包
Python代码: server: #!/usr/bin/python # -*- coding: UTF-8 -*- # 文件名:server.py import socket # 导入 socke ...
- UE4 Socket多线程非阻塞通信
转自:https://blog.csdn.net/lunweiwangxi3/article/details/50468593 ue4自带的Fsocket用起来依旧不是那么的顺手,感觉超出了我的理解范 ...
- Python socket套接字通信
一.什么是socket? socket是一个模块, 又称套接字,用来封装 互联网协议(应用层以下的层). 二.为什么要有socket? socket可以实现互联网协议 应用层以下的层 的工作,提高开发 ...
随机推荐
- 一个事务复制的bug--更新丢失 续
阅读本文之前请参考http://www.cnblogs.com/stswordman/p/3258897.html 最近又做了一个case,环境是sql server 2008 R2. 客户添加了一个 ...
- 微信公共平台开发-（.net实现）1--成为开发者
刚换了个新环境,哎这都快一个月了,还没适应过来,还是怀念老地方呀.老板让开发一个基于微信平台的开发项目,而且是用net实现.当时就蒙了,微信就用了一会个人赶脚不好,所以果断不用,现在让开发,而且查了一 ...
- [.net 面向对象编程基础] (11) 面向对象三大特性——封装
[.net 面向对象编程基础] (11) 面向对象三大特性——封装 我们的课题是面向对象编程,前面主要介绍了面向对象的基础知识,而从这里开始才是面向对象的核心部分,即 面向对象的三大特性:封装.继承. ...
- 100天后 - 100-days-later
赛斯·高汀(Seth Godin)的博客: http://sethgodin.typepad.com/seths_blog/2013/04/100-days-later.html 面对着数以千计的图 ...
- Android Fragment add/replace以及backstack
无论Fragment以何种方式加入,都不会影响backstack,backstack由addToBackStack函数决定,只有调用了这个函数,才会将Fragment加入返回栈.这个说法其实不太准确, ...
- ReactMix框架，让你实现一套js代码，基于ReactNative在H5，App都能完美跑起来，Write Once,Run Anywhere
ReactNative框架推出已经有一段时间了,相信很多小伙伴都在尝试实现Write Once, Run Anywhere的梦想,比如淘宝的ReactWeb等等,但是这些框架都局限于因为ReactNa ...
- Canny算子边缘检测(cvCanny)
Canny是常用的边缘检测方法,其特点是试图将独立边的候选像素拼装成轮廓. John Canny于1986年提出Canny算子,它与Marr(LoG)边缘检测方法类似,也属于是先平滑后求导数的方法. ...
- IT传统组织结构及新型扁平化组织
如今互联网企业正凶猛的改变人们衣食住行的方方面面,衣->淘宝,蘑菇街;食->大众点评,口碑;住->去哪,途牛:行->12306, 多次听到互联网的同行介绍他们就是要“快”,快速 ...
- Docker容器入门
为什么要看docker 从去年起就或多或少的接受了docker的熏陶,主要还是Infoq在去年有很多关于docker的实践视频讲座,记得有一篇是<Docker在雪球的技术实践>,当时听的也 ...
- Workflow中InArgument与OutArgument区别
序号 InArgument[In参数] OutArgument[Out参数] 1 可以用VS设计器在xaml中定义[In参数] 可以用VS设计器在xaml中定义[Out参数] 2 在xaml中定义的 ...