C#下利用封包、拆包原理解决Socket粘包、半包问题(新手篇)
介于网络上充斥着大量的含糊其辞的Socket初级教程,扰乱着新手的学习方向,我来扼要的教一下新手应该怎么合理的处理Socket这个玩意儿。
一般来说,教你C#下Socket编程的老师,很少会教你如何解决Socket粘包、半包问题。
更甚至,某些师德有问题的老师,根本就没跟你说过Socket的粘包、半包问题是什么玩意儿。
直到有一天,你的Socket程序在传输信息时出现了你预期之外的结果(多余的信息、不完整的信息、乱码、Bug等等)。
任你喊了一万遍“喔嚓”,依旧是不知道问题出在哪儿!
好了,不说废话了,进入正题,包教包会,学不会,送路费。
如果你读到这篇文章了,想必你已经遇到了以上问题,情况再理想一点儿,其实你在原理上已经知道怎么解决这个问题了,只是不知道怎么动手。
那么,首先,你需要新建一个【消息协议类】,这个类我们暂定由5大属性组成,分别是:
【(①=1个byte)(②=1个byte])(③=1个int)(④=1个byte[])(⑤=1个byte[])】
解释一下这个【消息协议类】:
(①=1个byte):这个属性占1个字节,可以放一个0到254的正整数,我称作1号标志;
(②=1个byte):这个属性占1个字节,可以放一个0到254的正整数,我称作2号标志。
那么1号标志和2号标志就有多达255×255个组合,我们用它来自定义这个消息对象的标志,比如,0-0表示登录请求消息,1-1表示物理攻击,1-2表示魔法攻击,3-0表示坐标移动;
(③=1个int):这个属性占4个字节,可以放一个0到2147483647的正整数,它表示后面(④=1个byte[])的长度,即实际发送的实质内容的长度;
(④=1个byte[]):这个属性存着你要发送的全部实质内容消息体的字节,所以,你的消息体需要被转化为字节数组才可存放进去;
(⑤=1个byte[]):这个属性存着一条完整信息之外【多余的消息体字节】。那么问题来了,什么是【多余的消息体字节】?先不忙往下看,自己思考一下这个问题,再继续往下看。
然后我们来解释一下这个【消息协议类】具体怎么用。
1,【消息发送方】先定义【消息协议类】①②属性,也就是随便写2个数,至于这两数代表什么含义,你自己定就行,这是为了消息接收方接受到消息后根据这个码来执行相应的逻辑;
2,【消息发送方】再将消息“装入”【消息协议类】的④属性,即实质消息内容;那么③属性也就随之有了,因为有了实质消息就算的出它的长度,这应该不难理解吧;
3,【消息发送方】将封装好的【消息协议类】转为byte[],发送给【消息接收方】,我们把这道工序称作【封包】;
------------------------------------------------------
4,【消息接收方】接收到【消息发送方】发来的byte[]时,先判断这个byte[]长度是否大于6,为什么是6?其实就是否大于①属性+②属性+③属性的长度之和(2个byte是2字节,1个int是4字节,2+6=6),
如果byte[]长度小于6,说明没收到有效消息,则【消息接收方】就循环继续接收;
5,【消息接收方】接收到【消息发送方】发来的byte[]长度如果大于等于6了!!则将byte[]还原为【消息协议类】对象;
6,循环判断【消息发送方】发来的byte[]长度减去6之后的值是否大于等于【消息协议类】对象③的值,如果大于等于,则把④属性拆出来,这就得到了一个刚刚好完整的消息,不多也不少。我们就把这道工序称作【拆包】。,
7,那么⑤这个【多余的消息体字节】是干嘛用的呢??上一步当中,如果byte[]信息刚好是一个完整长度,自然用不到⑤了,但是在网络传输中byte[]肯定不会永远那么刚好了,所以当byte[]长度大于一个完整消息时,我们就把多余的byte放入⑤当中,和下次新接收的byte[]依次拼合在一起,再次进行【拆包】的循环,保证数据的完整性和独立性。
8,好了,以上过程就是利用封包、拆包原理解决Socket粘包、半包问题,接下来你可以在发送方以非常频繁的发送频率来发送信息,接收方依然会规规矩矩完完整整的以正确的姿势来接收消息了。最下面是要点代码,相信聪明的你一定学会了,如果还没学会,可以加我QQ:119945778,包教包会,不然我还得送路费不是...
下面是源码时间:
/// <summary>
/// 【消息协议】=【协议一级标志】+【协议二级标志】+【实际消息长度】+【实际消息内容】+【多余的消息内容】
/// </summary>
public class MessageXieYi
{
#region 自定义
#region 协议一级标志,值 = (0 至 254 )
private byte xieYiFirstFlag;
/// <summary>
/// 协议类别,值 = ( 0 直 254 )
/// </summary>
public byte XieYiFirstFlag
{
get { return xieYiFirstFlag; }
set { xieYiFirstFlag = value; }
}
#endregion #region 协议二级标志,值 = (0 至 254 )
private byte xieYiSecondFlag;
/// <summary>
/// 协议二级标志,值 = (0 至 254 )
/// </summary>
public byte XieYiSecondFlag
{
get { return xieYiSecondFlag; }
set { xieYiSecondFlag = value; }
}
#endregion #region 实际消息长度
private int messageContentLength;
/// <summary>
/// 实际消息长度
/// </summary>
public int MessageContentLength
{
get { return messageContentLength; }
set { messageContentLength = value; }
}
#endregion #region 实际消息内容
private byte[] messageContent = new byte[] { };
/// <summary>
/// 实际消息内容
/// </summary>
public byte[] MessageContent
{
get { return messageContent; }
set { messageContent = value; }
}
#endregion #region 多余的Bytes
private byte[] duoYvBytes;
/// <summary>
/// 多余的Bytes
/// </summary>
public byte[] DuoYvBytes
{
get { return duoYvBytes; }
set { duoYvBytes = value; }
} #endregion
#endregion #region 构造函数两个
public MessageXieYi()
{
//
} public MessageXieYi(byte _xieYiFirstFlage, byte _xieYiSecondFlage, byte[] _messageContent)
{
xieYiFirstFlag = _xieYiFirstFlage;
xieYiFirstFlag = _xieYiSecondFlage;
messageContentLength = _messageContent.Length;
messageContent = _messageContent;
}
#endregion #region MessageXieYi 转换为 byte[]
/// <summary>
/// MessageXieYi 转换为 byte[]
/// </summary>
/// <returns></returns>
public byte[] ToBytes()
{
byte[] _bytes; //自定义字节数组,用以装载消息协议 using (MemoryStream memoryStream = new MemoryStream()) //创建内存流
{
BinaryWriter binaryWriter = new BinaryWriter(memoryStream); //以二进制写入器往这个流里写内容 binaryWriter.Write(xieYiFirstFlag); //写入协议一级标志,占1个字节
binaryWriter.Write(xieYiSecondFlag); //写入协议二级标志,占1个字节
binaryWriter.Write(messageContentLength); //写入实际消息长度,占4个字节 if (messageContentLength > )
{
binaryWriter.Write(messageContent); //写入实际消息内容
} _bytes = memoryStream.ToArray(); //将流内容写入自定义字节数组 binaryWriter.Close(); //关闭写入器释放资源
} return _bytes; //返回填充好消息协议对象的自定义字节数组
}
#endregion #region byte[] 转换为 MessageXieYi
/// <summary>
/// byte[] 转换为 MessageXieYi
/// </summary>
/// <param name="buffer">字节数组缓冲器。</param>
/// <returns></returns>
public static MessageXieYi FromBytes(byte[] buffer)
{
int bufferLength = buffer.Length; MessageXieYi messageXieYi = new MessageXieYi(); using (MemoryStream memoryStream = new MemoryStream(buffer)) //将字节数组填充至内存流
{
BinaryReader binaryReader = new BinaryReader(memoryStream); //以二进制读取器读取该流内容 messageXieYi.xieYiFirstFlag = binaryReader.ReadByte(); //读取协议一级标志,读1个字节
messageXieYi.xieYiSecondFlag = binaryReader.ReadByte(); //读取协议二级标志,读1个字节
messageXieYi.messageContentLength = binaryReader.ReadInt32(); //读取实际消息长度,读4个字节 //如果【进来的Bytes长度】大于【一个完整的MessageXieYi长度】
if ((bufferLength - 6) > messageXieYi.messageContentLength)
{
messageXieYi.messageContent = binaryReader.ReadBytes(messageXieYi.messageContentLength); //读取实际消息内容,从第7个字节开始读
messageXieYi.duoYvBytes = binaryReader.ReadBytes(bufferLength - - messageXieYi.messageContentLength);
} //如果【进来的Bytes长度】等于【一个完整的MessageXieYi长度】
if ((bufferLength - 6) == messageXieYi.messageContentLength)
{
messageXieYi.messageContent = binaryReader.ReadBytes(messageXieYi.messageContentLength); //读取实际消息内容,从第7个字节开始读
} binaryReader.Close(); //关闭二进制读取器,是否资源
} return messageXieYi; //返回消息协议对象
}
#endregion
}
/// <summary>
/// 按照先后顺序合并字节数组类
/// </summary>
public class CombineBytes
{
/// <summary>
/// 按照先后顺序合并字节数组,并返回合并后的字节数组。
/// </summary>
/// <param name="firstBytes">第一个字节数组</param>
/// <param name="firstIndex">第一个字节数组的开始截取索引</param>
/// <param name="firstLength">第一个字节数组的截取长度</param>
/// <param name="secondBytes">第二个字节数组</param>
/// <param name="secondIndex">第二个字节数组的开始截取索引</param>
/// <param name="secondLength">第二个字节数组的截取长度</param>
/// <returns></returns>
public static byte[] ToArray(byte[] firstBytes, int firstIndex, int firstLength, byte[] secondBytes, int secondIndex, int secondLength)
{
using (MemoryStream ms = new MemoryStream())
{
BinaryWriter bw = new BinaryWriter(ms);
bw.Write(firstBytes, firstIndex, firstLength);
bw.Write(secondBytes, secondIndex, secondLength); bw.Close();
bw.Dispose(); return ms.ToArray();
}
}
}
byte[] msgBytes = Encoding.Unicode.GetBytes("要发送的消息");
MessageXieYi msgXY = new MessageXieYi(, , msgBytes);
networkStream.Write(msgXY.ToBytes(), , msgXY.ToBytes().Length);
#region 线程执行体,接收消息
/// <summary>
/// 线程执行体,接收消息
/// </summary>
/// <param name="obj">传递给线程执行体的用户名,用以与用户通信</param>
private void ThreadReceive(object obj)
{
//通过用户名找出已经保存在哈希表里的Socket
Socket savedSocket = hashtable_UserNameToSocket[obj] as Socket; MessageXieYi msgXY = new MessageXieYi(); byte[] buffer = new byte[];//定义一个大小为64的缓冲区
//byte[] receivedBytes = new byte[] { };
byte[] newBuffer = new byte[] { };//大小可变的缓存器 int receivedLength;
int availableLength;//没什么实际意义,就是为了方便理解Socket传输机制 while (true)
{
try
{
buffer = new byte[]; for (int i = ; i < ; i++)
{
availableLength = savedSocket.Available; Console.WriteLine("【循环判断有多少可读Bytes】savedSocket.Available[" + i + "]=" + availableLength);//没实际意义,就是来个直观感受Socket的原理
} Console.WriteLine("【可变缓存器大小】newBuffer.Length=" + newBuffer.Length); receivedLength = savedSocket.Receive(buffer); Console.WriteLine("【接收到数据】buffer.Length=" + receivedLength); newBuffer = CombineBytes.ToArray(newBuffer, , newBuffer.Length, buffer, , receivedLength); Console.WriteLine("【将接收到的数据追加在newBuffer后】newBuffer.Length=" + newBuffer.Length); if (newBuffer.Length < )
{
Console.WriteLine("newBuffer.Length=" + newBuffer.Length + "< 6 \t -> \t continue");
continue;
}
else //newBuffer.Length >= 6
{
//取msgXY包头部分
msgXY = MessageXieYi.FromBytes(newBuffer);
int firstFlag = msgXY.XieYiFirstFlag;
int secondFlag = msgXY.XieYiSecondFlag;
int msgContentLength = msgXY.MessageContentLength; //判断去掉msgXY包头剩下的长度是否达到可以取包实质内容
while ((newBuffer.Length - ) >= msgContentLength)
{
Console.WriteLine("【newBuffer去掉包头的长度=" + (newBuffer.Length - ) + "】>=【" + "包实质内容长度=" + msgContentLength + "】");
msgXY = null;
msgXY = MessageXieYi.FromBytes(newBuffer);
Console.WriteLine("\n【拆包】=" + Encoding.Unicode.GetString(msgXY.MessageContent) + "\n"); newBuffer = msgXY.DuoYvBytes;
Console.WriteLine("【剩余的newBuffer】newBuffer.Length=" + newBuffer.Length); if (newBuffer.Length >= )
{
msgXY = MessageXieYi.FromBytes(newBuffer);
firstFlag = msgXY.XieYiFirstFlag;
secondFlag = msgXY.XieYiSecondFlag;
msgContentLength = msgXY.MessageContentLength;
continue;
}
else
{
break;
}
}
} availableLength = savedSocket.Available;
Console.WriteLine("savedSocket.Available=" + availableLength + "\n\n\n\n"); continue;
}
catch
{
//异常处理
}
}
}
#endregion
C#下利用封包、拆包原理解决Socket粘包、半包问题(新手篇)的更多相关文章
- 解决Socket粘包问题——C#代码
解决Socket粘包问题——C#代码 前天晚上,曾经的一个同事问我socket发送消息如果太频繁接收方就会有消息重叠,因为当时在外面,没有多加思考 第一反应还以为是多线程导致的数据不同步导致的,让他加 ...
- Netty 粘包/半包原理与拆包实战
Java NIO 粘包 拆包 (实战) - 史上最全解读 - 疯狂创客圈 - 博客园 https://www.cnblogs.com/crazymakercircle/p/9941658.html 本 ...
- Http 调用netty 服务,服务调用客户端,伪同步响应.ProtoBuf 解决粘包,半包问题.
实际情况是: 公司需要开发一个接口给新产品使用,需求如下 1.有一款硬件设备,客户用usb接上电脑就可以,但是此设备功能比较单一,所以开发一个服务器程序,辅助此设备业务功能 2.解决方案,使用Sock ...
- netty解决粘包半包问题
前言:开发者用到TCP/IP交互时,偶尔会遇到粘包或者半包的数据,这种情况有时会对我们的程序造成严重的影响,netty框架为解决这种问题提供了若干框架 1. LineBasedFrameDecoder ...
- Unity C# 自定义TCP传输协议以及封包拆包、解决粘包问题
本文只是初步实现了一个简单的TCP自定协议,更为复杂的协议可以根据这种方式去扩展. TCP协议,通俗一点的讲,它是一种基于socket传输的由发送方和接收方事先协商好的一种消息包组成结构,主要由消息头 ...
- 解决socket粘包的两种low版模式 os.popen()和struct模块
os.popen()模式 server端 import socket import os phone = socket.socket() # 实例化一个socket对象 phone.bind((&qu ...
- 网络编程基础【day09】:解决socket粘包之大数据(七)
本节内容 概述 linux下运行效果 sleep解决粘包 服务端插入交互解决粘包问题 一.概述 刚刚我们在window的操作系统上,很完美的解决了,大数据量的数据传输出现的问题,但是在Linux环境下 ...
- Linux下利用phpize安装memcashe的php源码扩展包
phpize是php的一种构建工具,为PHP扩展准备构建环境,通过phpize可以编译php的扩展源码文件为php扩展模块. 一.安装 phpize工具可以通过安装php-dev包自动集成安装.安装完 ...
- socket编程 TCP 粘包和半包 的问题及解决办法
一般在socket处理大数据量传输的时候会产生粘包和半包问题,有的时候tcp为了提高效率会缓冲N个包后再一起发出去,这个与缓存和网络有关系. 粘包 为x.5个包 半包 为0.5个包 由于网络原因 一次 ...
随机推荐
- PetShop学习第四天
ASP.NET缓存 1.页输出缓存分为整页缓存和部分页缓存.我们可以通过@OutputCache指令来完成对Web页面的输出缓存.
- EasyBCD安装CentOS双系统
之前使用CentOS安装过ubuntu,今天安装一次CentOS6.6,要复杂一些,列文备忘. 1.安装EasyBCD,下载CentOS-6.6-x86_64-bin-DVD1.iso.CentOS- ...
- python 使用__future__
Python的每个新版本都会增加一些新的功能,或者对原来的功能作一些改动.有些改动是不兼容旧版本的,也就是在当前版本运行正常的代码,到下一个版本运行就可能不正常了. 从Python 2.7到Pytho ...
- zzuoj 10409 10409: D.引水工程
10409: D.引水工程 Time Limit: 2 Sec Memory Limit: 128 MBSubmit: 96 Solved: 34[Submit][Status][Web Boar ...
- [置顶] Flex中Tree组件无刷新删除节点
在Tree组件中经常要删除某个节点,而删除之后重新刷新加载该Tree组件会影响整个操作效果和效率,因此,无刷新删除就比较好,既删除了节点也没有刷新tree,而使Tree的状态处于删除之前的状态. 无刷 ...
- jboss7的服务器开启和关闭命令
国内私募机构九鼎控股打造APP,来就送 20元现金领取地址:http://jdb.jiudingcapital.com/phone.html内部邀请码:C8E245J (不写邀请码,没有现金送)国内私 ...
- Oracle用户及角色的权限管理[Oracle基础]
1.查看全部用户: select * from dba_users; select * from all_users; select * from user_users; 2.查看用户或角 ...
- 【07】为多态基类声明virtual析构方法
1.考虑下面的需要,需要一个工厂方法.工厂方法的规则是:在堆上分配一个子类对象,并返回父类指针.使用完毕,delete父类指针.如果父类的析构方法不是virtual,将直接调用父类的析构方法,导致局部 ...
- php join函数使用,很是方便
以前数组转换成用逗号隔开的字符串都是自己写一个数组,最后还要去除多余的一个逗号,好麻烦. 无意中发现join函数,原来一句话就可以了. $_array = array('a','b','c','d', ...
- 数据库中DDL、DML、DCL和TCP概念
1.DDL(Data Definition Language)数据库定义语言statements are used to define the database structure or schema ...