這篇文章主要介紹了 C#使用Protocol Buffer(ProtoBuf)進行Unity的Socket通信的執行個體,Protocol Buffer是Google開發的資料格式,也是除了XML和JSON之外人氣第三高的^^需要的朋友可以參考下
首先來說一下本文中例子所要實作的功能:
- 基于ProtoBuf序列化對象
- 使用Socket實作時時通信
- 資料包的編碼和解碼
下面來看具體的步驟:
一、Unity中使用ProtoBuf
導入DLL到Unity中,
建立網絡傳輸的模型類:
using System;
using ProtoBuf;
//添加特性,表示可以被ProtoBuf工具序列化
[ProtoContract]
public class NetModel {
//添加特性,表示該字段可以被序列化,1可以了解為下标
[ProtoMember(1)]
public int ID;
[ProtoMember(2)]
public string Commit;
[ProtoMember(3)]
public string Message;
}
using System;
using ProtoBuf;
//添加特性,表示可以被ProtoBuf工具序列化
[ProtoContract]
public class NetModel {
//添加特性,表示該字段可以被序列化,1可以了解為下标
[ProtoMember(1)]
public int ID;
[ProtoMember(2)]
public string Commit;
[ProtoMember(3)]
public string Message;
}
在Unity中添加測試腳本,介紹ProtoBuf工具的使用。
using System;
using System.IO;
public class Test : MonoBehaviour {
void Start () {
//建立對象
NetModel item = new NetModel(){ID = 1, Commit = "LanOu", Message = "Unity"};
//序列化對象
byte[] temp = Serialize(item);
//ProtoBuf的優勢一:小
Debug.Log(temp.Length);
//反序列化為對象
NetModel result = DeSerialize(temp);
Debug.Log(result.Message);
}
// 将消息序列化為二進制的方法
// < param name="model">要序列化的對象< /param>
private byte[] Serialize(NetModel model)
{
try {
//涉及格式轉換,需要用到流,将二進制序列化到流中
using (MemoryStream ms = new MemoryStream()) {
//使用ProtoBuf工具的序列化方法
ProtoBuf.Serializer.Serialize<NetModel> (ms, model);
//定義二級制數組,儲存序列化後的結果
byte[] result = new byte[ms.Length];
//将流的位置設為0,起始點
ms.Position = 0;
//将流中的内容讀取到二進制數組中
ms.Read (result, 0, result.Length);
return result;
}
} catch (Exception ex) {
Debug.Log ("序列化失敗: " + ex.ToString());
return null;
}
}
// 将收到的消息反序列化成對象
// < returns>The serialize.< /returns>
// < param name="msg">收到的消息.</param>
private NetModel DeSerialize(byte[] msg)
{
try {
using (MemoryStream ms = new MemoryStream()) {
//将消息寫入流中
ms.Write (msg, 0, msg.Length);
//将流的位置歸0
ms.Position = 0;
//使用工具反序列化對象
NetModel result = ProtoBuf.Serializer.Deserialize<NetModel> (ms);
return result;
}
} catch (Exception ex) {
Debug.Log("反序列化失敗: " + ex.ToString());
return null;
}
}
}
using System;
using System.IO;
public class Test : MonoBehaviour {
void Start () {
//建立對象
NetModel item = new NetModel(){ID = 1, Commit = "LanOu", Message = "Unity"};
//序列化對象
byte[] temp = Serialize(item);
//ProtoBuf的優勢一:小
Debug.Log(temp.Length);
//反序列化為對象
NetModel result = DeSerialize(temp);
Debug.Log(result.Message);
}
// 将消息序列化為二進制的方法
// < param name="model">要序列化的對象< /param>
private byte[] Serialize(NetModel model)
{
try {
//涉及格式轉換,需要用到流,将二進制序列化到流中
using (MemoryStream ms = new MemoryStream()) {
//使用ProtoBuf工具的序列化方法
ProtoBuf.Serializer.Serialize<NetModel> (ms, model);
//定義二級制數組,儲存序列化後的結果
byte[] result = new byte[ms.Length];
//将流的位置設為0,起始點
ms.Position = 0;
//将流中的内容讀取到二進制數組中
ms.Read (result, 0, result.Length);
return result;
}
} catch (Exception ex) {
Debug.Log ("序列化失敗: " + ex.ToString());
return null;
}
}
// 将收到的消息反序列化成對象
// < returns>The serialize.< /returns>
// < param name="msg">收到的消息.</param>
private NetModel DeSerialize(byte[] msg)
{
try {
using (MemoryStream ms = new MemoryStream()) {
//将消息寫入流中
ms.Write (msg, 0, msg.Length);
//将流的位置歸0
ms.Position = 0;
//使用工具反序列化對象
NetModel result = ProtoBuf.Serializer.Deserialize<NetModel> (ms);
return result;
}
} catch (Exception ex) {
Debug.Log("反序列化失敗: " + ex.ToString());
return null;
}
}
}
二、Unity中使用Socket實作時時通信
通信應該實作的功能:
- 伺服器可以時時監聽多個用戶端
- 伺服器可以時時監聽某一個用戶端消息
- 伺服器可以時時給某一個用戶端發消息
- 首先我們需要定義一個用戶端對象
using System;
using System.Net.Sockets;
// 表示一個用戶端
public class NetUserToken {
//連接配接用戶端的Socket
public Socket socket;
//用于存放接收資料
public byte[] buffer;
public NetUserToken()
{
buffer = new byte[1024];
}
// 接受消息
// < param name="data">Data.< /param>
public void Receive(byte[] data)
{
UnityEngine.Debug.Log("接收到消息!");
}
// 發送消息
//< param name="data">Data.< /param>
public void Send(byte[] data)
{
}
}
using System;
using System.Net.Sockets;
// 表示一個用戶端
public class NetUserToken {
//連接配接用戶端的Socket
public Socket socket;
//用于存放接收資料
public byte[] buffer;
public NetUserToken()
{
buffer = new byte[1024];
}
// 接受消息
// < param name="data">Data.< /param>
public void Receive(byte[] data)
{
UnityEngine.Debug.Log("接收到消息!");
}
// 發送消息
//< param name="data">Data.< /param>
public void Send(byte[] data)
{
}
}
然後實作我們的伺服器代碼
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System;
using System.Net.Sockets;
public class NetServer{
//單例腳本
public static readonly NetServer Instance = new NetServer();
//定義tcp伺服器
private Socket server;
private int maxClient = 10;
//定義端口
private int port = 35353;
//使用者池
private Stack<NetUserToken> pools;
private NetServer()
{
//初始化socket
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.Bind(new IPEndPoint(IPAddress.Any, port));
}
//開啟伺服器
public void Start()
{
server.Listen(maxClient);
UnityEngine.Debug.Log("Server OK!");
//執行個體化用戶端的使用者池
pools = new Stack<NetUserToken>(maxClient);
for(int i = 0; i < maxClient; i++)
{
NetUserToken usertoken = new NetUserToken();
pools.Push(usertoken);
}
//可以異步接受用戶端, BeginAccept函數的第一個參數是回調函數,當有用戶端連接配接的時候自動調用
server.BeginAccept (AsyncAccept, null);
}
//回調函數, 有用戶端連接配接的時候會自動調用此方法
private void AsyncAccept(IAsyncResult result)
{
try {
//結束監聽,同時擷取到用戶端
Socket client = server.EndAccept(result);
UnityEngine.Debug.Log("有用戶端連接配接");
//來了一個用戶端
NetUserToken userToken = pools.Pop();
userToken.socket = client;
//用戶端連接配接之後,可以接受用戶端消息
BeginReceive(userToken);
//尾遞歸,再次監聽是否還有其他用戶端連入
server.BeginAccept(AsyncAccept, null);
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
//異步監聽消息
private void BeginReceive(NetUserToken userToken)
{
try {
//異步方法
userToken.socket.BeginReceive(userToken.buffer, 0, userToken.buffer.Length, SocketFlags.None,
EndReceive, userToken);
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
//監聽到消息之後調用的函數
private void EndReceive(IAsyncResult result)
{
try {
//取出用戶端
NetUserToken userToken = result.AsyncState as NetUserToken;
//擷取消息的長度
int len = userToken.socket.EndReceive(result);
if(len > 0)
{
byte[] data = new byte[len];
Buffer.BlockCopy(userToken.buffer, 0, data, 0, len);
//使用者接受消息
userToken.Receive(data);
//尾遞歸,再次監聽用戶端消息
BeginReceive(userToken);
}
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
}
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System;
using System.Net.Sockets;
public class NetServer{
//單例腳本
public static readonly NetServer Instance = new NetServer();
//定義tcp伺服器
private Socket server;
private int maxClient = 10;
//定義端口
private int port = 35353;
//使用者池
private Stack<NetUserToken> pools;
private NetServer()
{
//初始化socket
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.Bind(new IPEndPoint(IPAddress.Any, port));
}
//開啟伺服器
public void Start()
{
server.Listen(maxClient);
UnityEngine.Debug.Log("Server OK!");
//執行個體化用戶端的使用者池
pools = new Stack<NetUserToken>(maxClient);
for(int i = 0; i < maxClient; i++)
{
NetUserToken usertoken = new NetUserToken();
pools.Push(usertoken);
}
//可以異步接受用戶端, BeginAccept函數的第一個參數是回調函數,當有用戶端連接配接的時候自動調用
server.BeginAccept (AsyncAccept, null);
}
//回調函數, 有用戶端連接配接的時候會自動調用此方法
private void AsyncAccept(IAsyncResult result)
{
try {
//結束監聽,同時擷取到用戶端
Socket client = server.EndAccept(result);
UnityEngine.Debug.Log("有用戶端連接配接");
//來了一個用戶端
NetUserToken userToken = pools.Pop();
userToken.socket = client;
//用戶端連接配接之後,可以接受用戶端消息
BeginReceive(userToken);
//尾遞歸,再次監聽是否還有其他用戶端連入
server.BeginAccept(AsyncAccept, null);
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
//異步監聽消息
private void BeginReceive(NetUserToken userToken)
{
try {
//異步方法
userToken.socket.BeginReceive(userToken.buffer, 0, userToken.buffer.Length, SocketFlags.None,
EndReceive, userToken);
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
//監聽到消息之後調用的函數
private void EndReceive(IAsyncResult result)
{
try {
//取出用戶端
NetUserToken userToken = result.AsyncState as NetUserToken;
//擷取消息的長度
int len = userToken.socket.EndReceive(result);
if(len > 0)
{
byte[] data = new byte[len];
Buffer.BlockCopy(userToken.buffer, 0, data, 0, len);
//使用者接受消息
userToken.Receive(data);
//尾遞歸,再次監聽用戶端消息
BeginReceive(userToken);
}
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
}
在Unity中開啟伺服器,并使用C#控制台模拟用戶端連接配接、發送消息操作。測試OK了,Unity中可以時時監聽到消息。
using UnityEngine;
using System.Collections;
public class CreateServer : MonoBehaviour {
void StartServer () {
NetServer.Instance.Start();
}
}
//C#控制台工程
using System;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Text;
namespace Temp
{
class MainClass
{
public static void Main (string[] args)
{
TcpClient tc = new TcpClient();
IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 35353);
tc.Connect(ip);
if(tc.Connected)
{
while(true)
{
string msg = Console.ReadLine();
byte[] result = Encoding.UTF8.GetBytes(msg);
tc.GetStream().Write(result, 0, result.Length);
}
}
Console.ReadLine();
}
}
}
using UnityEngine;
using System.Collections;
public class CreateServer : MonoBehaviour {
void StartServer () {
NetServer.Instance.Start();
}
}
//C#控制台工程
using System;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Text;
namespace Temp
{
class MainClass
{
public static void Main (string[] args)
{
TcpClient tc = new TcpClient();
IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 35353);
tc.Connect(ip);
if(tc.Connected)
{
while(true)
{
string msg = Console.ReadLine();
byte[] result = Encoding.UTF8.GetBytes(msg);
tc.GetStream().Write(result, 0, result.Length);
}
}
Console.ReadLine();
}
}
}
三、資料包的編碼和解碼
首先,舉個例子,這個月信用卡被媳婦刷爆了,面對房貸車貸的壓力,我隻能選擇分期付款。。。
那麼OK了,現在我想問一下,當伺服器向用戶端發送的資料過大時怎麼辦呢?
當伺服器需要向用戶端發送一條很長的資料,也會“分期付款!”,伺服器會把一條很長的資料分成若幹條小資料,多次發送給用戶端。
可是,這樣就又有另外一個問題,用戶端接受到多條資料之後如何解析?
這裡其實就是用戶端的解碼。server發資料一般采用“長度+内容”的格式,Client接收到資料之後,先提取出長度來,然後根據長度判斷内容是否發送完畢。
再次重申,使用者在發送序列化好的消息的前,需要先編碼後再發送消息;使用者在接受消息後,需要解碼之後再解析資料(反序列化)。
using UnityEngine;
using System.Collections.Generic;
using System.IO;
// 編碼和解碼
public class NetEncode {
// 将資料編碼 長度+内容
/// < param name="data">内容< /param>
public static byte[] Encode(byte[] data)
{
//整形占四個位元組,是以聲明一個+4的數組
byte[] result = new byte[data.Length + 4];
//使用流将編碼寫二進制
MemoryStream ms = new MemoryStream();
BinaryWriter br = new BinaryWriter(ms);
br.Write(data.Length);
br.Write(data);
//将流中的内容複制到數組中
System.Buffer.BlockCopy(ms.ToArray(), 0, result, 0, (int)ms.Length);
br.Close();
ms.Close();
return result;
}
// 将資料解碼
// < param name="cache">消息隊列< /param>
public static byte[] Decode(ref List<byte> cache)
{
//首先要擷取長度,整形4個位元組,如果位元組數不足4個位元組
if(cache.Count < 4)
{
return null;
}
//讀取資料
MemoryStream ms = new MemoryStream(cache.ToArray());
BinaryReader br = new BinaryReader(ms);
int len = br.ReadInt32();
//根據長度,判斷内容是否傳遞完畢
if(len > ms.Length - ms.Position)
{
return null;
}
//擷取資料
byte[] result = br.ReadBytes(len);
//清空消息池
cache.Clear();
//講剩餘沒處理的消息存入消息池
cache.AddRange(br.ReadBytes((int)ms.Length - (int)ms.Position));
return result;
}
}
using UnityEngine;
using System.Collections.Generic;
using System.IO;
// 編碼和解碼
public class NetEncode {
// 将資料編碼 長度+内容
/// < param name="data">内容< /param>
public static byte[] Encode(byte[] data)
{
//整形占四個位元組,是以聲明一個+4的數組
byte[] result = new byte[data.Length + 4];
//使用流将編碼寫二進制
MemoryStream ms = new MemoryStream();
BinaryWriter br = new BinaryWriter(ms);
br.Write(data.Length);
br.Write(data);
//将流中的内容複制到數組中
System.Buffer.BlockCopy(ms.ToArray(), 0, result, 0, (int)ms.Length);
br.Close();
ms.Close();
return result;
}
// 将資料解碼
// < param name="cache">消息隊列< /param>
public static byte[] Decode(ref List<byte> cache)
{
//首先要擷取長度,整形4個位元組,如果位元組數不足4個位元組
if(cache.Count < 4)
{
return null;
}
//讀取資料
MemoryStream ms = new MemoryStream(cache.ToArray());
BinaryReader br = new BinaryReader(ms);
int len = br.ReadInt32();
//根據長度,判斷内容是否傳遞完畢
if(len > ms.Length - ms.Position)
{
return null;
}
//擷取資料
byte[] result = br.ReadBytes(len);
//清空消息池
cache.Clear();
//講剩餘沒處理的消息存入消息池
cache.AddRange(br.ReadBytes((int)ms.Length - (int)ms.Position));
return result;
}
}
使用者接受資料代碼如下:
using System;
using System.Collections.Generic;
using System.Net.Sockets;
// 表示一個用戶端
public class NetUserToken {
//連接配接用戶端的Socket
public Socket socket;
//用于存放接收資料
public byte[] buffer;
//每次接受和發送資料的大小
private const int size = 1024;
//接收資料池
private List<byte> receiveCache;
private bool isReceiving;
//發送資料池
private Queue<byte[]> sendCache;
private bool isSending;
//接收到消息之後的回調
public Action<NetModel> receiveCallBack;
public NetUserToken()
{
buffer = new byte[size];
receiveCache = new List<byte>();
sendCache = new Queue<byte[]>();
}
// 伺服器接受用戶端發送的消息
// < param name="data">Data.< /param>
public void Receive(byte[] data)
{
UnityEngine.Debug.Log("接收到資料");
//将接收到的資料放入資料池中
receiveCache.AddRange(data);
//如果沒在讀資料
if(!isReceiving)
{
isReceiving = true;
ReadData();
}
}
// 讀取資料
private void ReadData()
{
byte[] data = NetEncode.Decode(ref receiveCache);
//說明資料儲存成功
if(data != null)
{
NetModel item = NetSerilizer.DeSerialize(data);
UnityEngine.Debug.Log(item.Message);
if(receiveCallBack != null)
{
receiveCallBack(item);
}
//尾遞歸,繼續讀取資料
ReadData();
}
else
{
isReceiving = false;
}
}
// 伺服器發送消息給用戶端
public void Send()
{
try {
if (sendCache.Count == 0) {
isSending = false;
return;
}
byte[] data = sendCache.Dequeue ();
int count = data.Length / size;
int len = size;
for (int i = 0; i < count + 1; i++) {
if (i == count) {
len = data.Length - i * size;
}
socket.Send (data, i * size, len, SocketFlags.None);
}
UnityEngine.Debug.Log("發送成功!");
Send ();
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
public void WriteSendDate(byte[] data){
sendCache.Enqueue(data);
if(!isSending)
{
isSending = true;
Send();
}
}
}
using System;
using System.Collections.Generic;
using System.Net.Sockets;
// 表示一個用戶端
public class NetUserToken {
//連接配接用戶端的Socket
public Socket socket;
//用于存放接收資料
public byte[] buffer;
//每次接受和發送資料的大小
private const int size = 1024;
//接收資料池
private List<byte> receiveCache;
private bool isReceiving;
//發送資料池
private Queue<byte[]> sendCache;
private bool isSending;
//接收到消息之後的回調
public Action<NetModel> receiveCallBack;
public NetUserToken()
{
buffer = new byte[size];
receiveCache = new List<byte>();
sendCache = new Queue<byte[]>();
}
// 伺服器接受用戶端發送的消息
// < param name="data">Data.< /param>
public void Receive(byte[] data)
{
UnityEngine.Debug.Log("接收到資料");
//将接收到的資料放入資料池中
receiveCache.AddRange(data);
//如果沒在讀資料
if(!isReceiving)
{
isReceiving = true;
ReadData();
}
}
// 讀取資料
private void ReadData()
{
byte[] data = NetEncode.Decode(ref receiveCache);
//說明資料儲存成功
if(data != null)
{
NetModel item = NetSerilizer.DeSerialize(data);
UnityEngine.Debug.Log(item.Message);
if(receiveCallBack != null)
{
receiveCallBack(item);
}
//尾遞歸,繼續讀取資料
ReadData();
}
else
{
isReceiving = false;
}
}
// 伺服器發送消息給用戶端
public void Send()
{
try {
if (sendCache.Count == 0) {
isSending = false;
return;
}
byte[] data = sendCache.Dequeue ();
int count = data.Length / size;
int len = size;
for (int i = 0; i < count + 1; i++) {
if (i == count) {
len = data.Length - i * size;
}
socket.Send (data, i * size, len, SocketFlags.None);
}
UnityEngine.Debug.Log("發送成功!");
Send ();
} catch (Exception ex) {
UnityEngine.Debug.Log(ex.ToString());
}
}
public void WriteSendDate(byte[] data){
sendCache.Enqueue(data);
if(!isSending)
{
isSending = true;
Send();
}
}
}
ProtoBuf網絡傳輸到這裡就全部完成了。