socket收发数据的处理

1. TCP 协议是一种基于数据流的协议

Socket的Receive方法只是把接收缓冲区的数据提取出来,当系统的接收缓冲区为空,Receive方法会被阻塞,直到里面有数据。
Socket的Send方法只是把数据写入到发送缓冲区里,具体的发送过程由操作系统负责。当操作系统的发送缓冲区满了,Send方法会阻塞

2.解决粘包问题的方法

一般有三种方法可以解决粘包和半包问题，分别是

长度信息法: 指在每个数据包前面加上长度信
固定长度法: 每次都以相同的长度发送数据
结束符号法

一般的游戏开发会在每个数据包前面加上长度字节，以方便解析

2.1 发送数据代码

//点击发送按钮
public void Send(string sendStr)
{
    //组装协议
    byte [] bodyBytes = System.Text.Encoding.Default.GetBytes(sendStr);
    Int16 len = (Int16)bodyBytes.Length;
    byte[] lenBytes = BitConverter.GetBytes (len);
    byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray( ); 
    // 为了精简代码:使用同步Send
    // 不考虑抛出异常
    socket.Send(sendBytes);
}

2.2 定义一个缓冲区(readBuff)和一个指示缓冲区有效数据长度变量(buffCount)。

// 接收缓冲区
byte[] readBuff= new byte[1024];
// 接收缓 冲区的数据 长度
int buffcount = 0;

public void ReceiveCallback (IAsyncResult ar) { 
       Socket socket = (Socket) ar.AsyncState;
       // 获取接收数据长度
       int count = socket.EndReceive(ar);
       buffCount += count;
       .....
}

3. 大小端

3.1 使用Reverse()兼容大小端编码
如果使用BitConverter.GetBytes将数字转换成二进制数据，转换出来的数据有可能基于大端模式，也有可能基于小端模式。

因为我们规定必须使用小端编码，一个简单的办法是，判断系统是否是小端编码的系统，如果不是，就使用Reverse() 方法将大端编码转换为小端编码。以Send 为例，代码如下:

//点击发送按钮 
public void Send () 
{
      string sendStr = InputFeld.text; 
      // 组装协议
      byte[| bodyBytes = System.Text.Encoding.Default.GetBytes (sendStr); 
      Int16 len = (Int16)bodyBytes.Length;
      byte[] lenBytes = BitConverter.GetBytes (len); 
      //大 小 端编 码
      if(!BitConverter.IsLittleEndian) {
          Debug. Log (" [Send] Reverse lenBytes");
          lenBytes.Reverse();
      }    
      // 拼接字节
      byte[] sendBytes = lenBytes.Concat(bodyBytes) .ToArray ( );
      socket.Send(sendBytes);
}

3.2 手动还原数值
BitConverter. Toint16中根据系统大小端采用不同的编码方式，如果是小端编码，返回的是(pbyte) | ((pbyte+1)<< 8)，如果是大端编码，返回的是(pbyte<< 8) | ((pbyte+1)。以小端为例，由于采用指针，(pbyte)指向缓冲区中指定位置的第1 个字节，(pbyte + 1)指向缓冲区中指定位置的第2个字节，((pbyte+1)<<8)表示左移8位，相当于乘以 256，返回的数字便是“第1个字节+第2字节256”，与4. 4.1节中介绍的步骤相同。

public void OnReceiveData ( ) { 
	// 消息长 度
	if (buffCount <= 2)
	return;
	// 消息长度
	Int16 bodyLength = (short) ((readBuff[1] << 8) | readBuff[0]);
	Debug.Log ( "[Recv] bodyLength=" + bodyLength); 
	// 消息体、更新 缓冲区
	// 消 息 处 理 、 继 续读 取 消 息
	.....
}

readBuff[0] 代表缓冲区的第1 个字节，readBuff[1] 代表缓冲区的第 2 个字节， ( readBuff[1] < < 8 ) 代表将缓冲区第 2 个字节的数据乘以 2 5 6 ，中间的“|” 代表逻辑与，在这里等同于相加。

完整的ByteArray
ByteArray作为一种通用的byte型缓冲区结构，它应该支持自动扩展，支持常用的读写操作。同时，为了做到极致的效率， ByteArray 的大部分成员变量都设为
public ，以提供灵活性

readldx 代表可读位置，即缓冲区有效数据的起始位置，writeldx 代表可写位置，即缓冲区有效数据的末尾。成员两数remain 代表缓冲区还可以容纳的字节数

using System;

public class ByteArray  {
	//默认大小
	const int DEFAULT_SIZE = 1024;
	//初始大小
	int initSize = 0;
	//缓冲区
	public byte[] bytes;
	//读写位置
	public int readIdx = 0;
	public int writeIdx = 0;
	//容量
	private int capacity = 0;
	//剩余空间
	public int remain { get { return capacity-writeIdx; }}
	//数据长度
	public int length { get { return writeIdx-readIdx; }}

	//构造函数
	public ByteArray(int size = DEFAULT_SIZE){
		bytes = new byte[size];
		capacity = size;
		initSize = size;
		readIdx = 0;
		writeIdx = 0;
	}

	//构造函数
	public ByteArray(byte[] defaultBytes){
		bytes = defaultBytes;
		capacity = defaultBytes.Length;
		initSize = defaultBytes.Length;
		readIdx = 0;
		writeIdx = defaultBytes.Length;
	}

	//重设尺寸
	public void ReSize(int size){
		if(size < length) return;
		if(size < initSize) return;
		int n = 1;
		while(n<size) n*=2;
		capacity = n;
		byte[] newBytes = new byte[capacity];
		Array.Copy(bytes, readIdx, newBytes, 0, writeIdx-readIdx);
		bytes = newBytes;
		writeIdx = length;
		readIdx = 0;
	}

	//写入数据
	public int Write(byte[] bs, int offset, int count){
		if(remain < count){
			ReSize(length + count);
		}
		Array.Copy(bs, offset, bytes, writeIdx, count);
		writeIdx+=count;
		return count;
	}

	//读取数据
	public int Read(byte[] bs, int offset, int count){
		count = Math.Min(count, length);
		Array.Copy(bytes, 0, bs, offset, count);
		readIdx+=count;
		CheckAndMoveBytes();
		return count;
	}

	//检查并移动数据
	public void CheckAndMoveBytes(){
		if(length < 8){
			MoveBytes();
		}
	}

	//移动数据
	public void MoveBytes(){
		Array.Copy(bytes, readIdx, bytes, 0, length);
		writeIdx = length;
		readIdx = 0;
	} 

	//读取Int16
	public Int16 ReadInt16(){
		if(length < 2) return 0;
		Int16 ret = BitConverter.ToInt16(bytes, readIdx);
		readIdx += 2;
		CheckAndMoveBytes();
		return ret;
	}

	//读取Int32
	public Int32 ReadInt32(){
		if(length < 4) return 0;
		Int32 ret = BitConverter.ToInt32(bytes, readIdx);
		readIdx += 4;
		CheckAndMoveBytes();
		return ret;
	}
	//打印缓冲区
	public override string ToString(){
		return BitConverter.ToString(bytes, readIdx, length);
	}

	//打印调试信息
	public string Debug(){
		return string.Format("readIdx({0}) writeIdx({1}) bytes({2})",
			readIdx,
			writeIdx,
			BitConverter.ToString(bytes, 0, capacity)
		);
	}
}

4.2. 重设尺寸
在某此情况下，比如需要写人的数据量大于缓冲区剩余长度 (r e m a i n ) 时，就需要扩大缓冲区。例如要在图 4 - 4 2 所示缓冲区后面添加数据〝0 5 h e l l o ” ，使绥冲区数据变成〝02hioshello”。此时缓冲区只剩余6 个字节，但“0shello” 是7个字节，放不下。此时的做法是，重新申请一个长度合适的byte 数组，然后把原byte 数组的数据复制过去，再重新设置readldx、writeldx 等数值。
在这里插入图片描述
为了避免频繁重设尺寸，规定每次翻倍增加bytes数组长度，即长度是1、2、4、8、 1 6 、 32 、 64 、 128 、 256 、 512 、 1024 、 2048 等值。如果参数 size 是1500 ，缓冲区长度会被设置成 2048 ，如果参数 size 是130 (假设size值合理)，缓冲区长度会被设置成256。通过“ int n= 1; while(n<size) n*= 2〞这两行代码，即可得出长度值。在图4-42 所示的缓冲区上执行Resize(6)后，缓冲区将变成图 4- 43 所示的样式。
在这里插入图片描述
4.3 移动数据
在某些情形下，例如有效数据长度很小 ( 这里设置为 8 )，或者数据全部被读取时 ( readldx==writeldx)，可以将数据前移，增加remain，避免bytes数组过长。由于数据很少，程序执行的效率不会有影响。在图 4 - 4 0 所示的缓冲区上执行 CheckAndMoveBytes 后，缓冲区将变成图4- 44 所示的样式。
在这里插入图片描述

把上面的ByteArray 应用到异步

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Net.Sockets;
using UnityEngine.UI;
using System;
using System.Linq;

public class Echo : MonoBehaviour {

	//定义套接字
	Socket socket;
	//UGUI
	public InputField InputFeld;
	public Text text;
	//接收缓冲区
	ByteArray readBuff = new ByteArray();
	//发送缓冲区
	Queue<ByteArray> writeQueue = new Queue<ByteArray>();
	bool isSending = false;
	//显示文字
	string recvStr = "";


	//点击连接按钮
	public void Connection()
	{
		//Socket
		socket = new Socket(AddressFamily.InterNetwork,
			SocketType.Stream, ProtocolType.Tcp);
		//为了精简代码：使用同步Connect
		//             不考虑抛出异常
		socket.Connect("127.0.0.1", 8888);

		socket.BeginReceive( readBuff.bytes, readBuff.writeIdx, 
							readBuff.remain, 0, ReceiveCallback, socket);
	}

	//Receive回调
	public void ReceiveCallback(IAsyncResult ar){
		try {
			Socket socket = (Socket) ar.AsyncState;
			//获取接收数据长度
			int count = socket.EndReceive(ar);
			readBuff.writeIdx+=count;
			//处理二进制消息
			OnReceiveData();
			//继续接收数据
			if(readBuff.remain < 8){
				readBuff.MoveBytes();
				readBuff.ReSize(readBuff.length*2);
			}
			socket.BeginReceive( readBuff.bytes, readBuff.writeIdx, 
				readBuff.remain, 0, ReceiveCallback, socket);
		}
		catch (SocketException ex){
			Debug.Log("Socket Receive fail" + ex.ToString());
		}
	}

	//
	public void OnReceiveData(){
		Debug.Log("[Recv 1] length  =" + readBuff.length);
		Debug.Log("[Recv 2] readbuff=" + readBuff.ToString());
		if(readBuff.length <= 2) 
			return;
		//消息长度
		int readIdx = readBuff.readIdx;
		byte[] bytes =readBuff.bytes; 
		Int16 bodyLength = (Int16)((bytes[readIdx+1] << 8 )| bytes[readIdx]);
		if(readBuff.length < bodyLength)
			return;
		readBuff.readIdx+=2; 
		Debug.Log("[Recv 3] bodyLength=" +bodyLength);
		//消息体
		byte[] stringByte = new byte[bodyLength];
		readBuff.Read(stringByte, 0, bodyLength);
		string s = System.Text.Encoding.UTF8.GetString(stringByte);

		Debug.Log("[Recv 4] s=" +s);
;
		Debug.Log("[Recv 5] readbuff=" + readBuff.ToString());
		//消息处理
		recvStr = s + "\n" + recvStr;
		//继续读取消息
		if(readBuff.length > 2){
			OnReceiveData();
		}
	}


	//点击发送按钮
	public void Send()
	{
		string sendStr = InputFeld.text;
		//组装协议
		byte[] bodyBytes = System.Text.Encoding.Default.GetBytes(sendStr);
		Int16 len = (Int16)bodyBytes.Length;
		byte[] lenBytes = BitConverter.GetBytes(len);
		//大小端编码
		if(!BitConverter.IsLittleEndian){
			Debug.Log("[Send] Reverse lenBytes");
			lenBytes.Reverse();
		}
		//拼接字节
		byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray();
		ByteArray ba = new ByteArray(sendBytes);
		lock(writeQueue){
			writeQueue.Enqueue(ba);
		}
		//send
		socket = new Socket(AddressFamily.InterNetwork,
			SocketType.Stream, ProtocolType.Tcp);
		if(!isSending){
			socket.BeginSend(sendBytes, 0, sendBytes.Length, 0, SendCallback, socket);
			isSending = true;
		}
		Debug.Log("[Send] " + BitConverter.ToString(sendBytes));

	}

	//Send回调
	public void SendCallback(IAsyncResult ar){
		//获取state
		Socket socket = (Socket) ar.AsyncState;
		//EndSend的处理
		int count = 0;
		count = socket.EndSend(ar);
			
		Debug.Log("Socket Send succ " + count);

		ByteArray ba = writeQueue.First();
		ba.readIdx+=count;
		if(ba.length == 0){
			lock(writeQueue){
				writeQueue.Dequeue();
				ba = writeQueue.First();
			}
		}
		if(ba != null){
			socket.BeginSend(ba.bytes, ba.readIdx, ba.length, 0, SendCallback, socket);
		}
		else{
			isSending = false;
		}
	}

	public void Update(){
		text.text = recvStr;
	}
}