C#使用Protocol Buffer(ProtoBuf)进行Unity中的Socket通信

From: http://www.jb51.net/article/82795.htm


这篇文章主要介绍了C#使用Protocol Buffer(ProtoBuf)进行Unity的Socket通信的实例,Protocol Buffer是Google开发的数据格式,也是除了XML和JSON之外人气第三高的^^需要的朋友可以参考下

首先来说一下本文中例子所要实现的功能：

  • 基于ProtoBuf序列化对象
  • 使用Socket实现时时通信
  • 数据包的编码和解码

下面来看具体的步骤：

一、Unity中使用ProtoBuf

导入DLL到Unity中，
创建网络传输的模型类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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工具的使用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
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实现时时通信

通信应该实现的功能：

  • 服务器可以时时监听多个客户端
  • 服务器可以时时监听某一个客户端消息
  • 服务器可以时时给某一个客户端发消息
  • 首先我们需要定义一个客户端对象
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
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)
 { 
  
 }
}


然后实现我们的服务器代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
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中可以时时监听到消息。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
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接收到数据之后，先提取出长度来，然后根据长度判断内容是否发送完毕。

再次重申，用户在发送序列化好的消息的前，需要先编码后再发送消息；用户在接受消息后，需要解码之后再解析数据（反序列化）。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
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;
 }
}

用户接受数据代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
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网络传输到这里就全部完成了。

您可能感兴趣的文章:

  • python如何通过protobuf实现rpc
  • 基于Protobuf C++ serialize到char*的实现方法分析
  • 通过Java来测试JSON和Protocol Buffer的传输文件大小
  • 使用Protocol Buffers的C语言拓展提速Python程序的示例
  • Protocol Buffer技术深入理解(C++实例)
Tags：ProtoBuf ProtocolBuffer

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/402996.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

监听el-table滚动到底；vue自定义指令监听el-table的滚动事件

监听el-table滚动到底；vue自定义指令监听el-table的滚动事件

链接地址&#xff1a;监听el-table滚动到底&#xff1b;vue自定义指令监听el-table的滚动事件
阅读更多...
泛型通用函数的一些特殊问题的解决方法

泛型通用函数的一些特殊问题的解决方法

首先先感谢MSDN中的一些优秀的外国友人精彩的回答&#xff0c;我从那里也受益良多&#xff0c;写此博文。 自从2.0版本的net framework推出之后泛型&#xff08;Generic&#xff09;得到了广泛好评。它不必像object类型一样性能上因为“拆箱”或者“装箱”得到损失&#xff0c;…
阅读更多...
Go-json 实例

Go-json 实例

环境: Win7_x64 go1.6.2 package mainimport "encoding/json" import "fmt" import "os"// 我们使用两个结构体来演示自定义数据类型的JSON数据编码和解码。 type Response1 struct {Page intFruits []string } type Response2 struct {Pag…
阅读更多...
将文件流blob或文件file读取成url

将文件流blob或文件file读取成url

let url URL.createObjectURL(file.raw) //将文件转化成url//或者let url URL.createObjectURL(blob) //将文件流转化成url 注意这个blob一般是通过读取后端接口文件流 设置 responseType: blob 然后返回得到的blob
阅读更多...
20145228 《信息安全系统设计基础》第0周学习总结

20145228 《信息安全系统设计基础》第0周学习总结

阅读博客感想 •经过上学期几个月的JAVA学习&#xff0c;收获的不仅仅是JAVA知识&#xff0c;更多的是我们自学一门课程的方法和能力。学习知识也不是死学&#xff0c;勤动手&#xff0c;多练习才是至关重要的。 •当处于健身教练和健身员的师生关系时&#xff0c;才是学习效率…
阅读更多...
解决vue-pdf报错TypeError: Cannot read properties of undefined (reading ‘catch‘)

解决vue-pdf报错TypeError: Cannot read properties of undefined (reading ‘catch‘)

使用vue-pdf插件后&#xff0c;报错 解决方法&#xff1a;找到node_modules/vue-pdf/src/pdfjsWrapper.js文件&#xff0c;注释掉下面的代码
阅读更多...
go 线程同步

go 线程同步

代码来源于《Go语言开发教程》 // 线程同步: sync.Mutexpackage mainimport ("errors""fmt""sync" )type MyMap struct {mp map[string]intmutex *sync.Mutex }func (this *MyMap) Get(key string) (int, error) {this.mutex.Lock()i, ok : t…
阅读更多...
中小企业如何提高售前，售中，售后客服质量？

中小企业如何提高售前，售中，售后客服质量？

企业产品出现差评、售后、维权、退款等售后问题总是让客服人员头疼&#xff0c;而且这些差评对企业的影响却日益重要&#xff0c;但是任何事情都是把双刃剑&#xff0c;处理好这些售后问题&#xff0c;不但会提升客户满意度&#xff0c;还会在这些售后问题中&#xff0c;总结出…
阅读更多...
XMLHttpRequest 的 responseType 属性详解

XMLHttpRequest 的 responseType 属性详解

XMLHttpRequest.responseType 属性是一个枚举类型的属性&#xff0c;返回响应数据的类型。它允许我们手动的设置返回数据的类型。如果我们将它设置为一个空字符串&#xff0c;它将使用默认的"text"类型。 当将responseType设置为一个特定的类型时&#xff0c;你需要确…
阅读更多...
go 打印当前时间

go 打印当前时间

go打印当前时间&#xff0c;Format好奇葩&#xff01; // 打印当前时间package mainimport ("fmt""time" )func main() {fmt.Println(time.Now().Format("2006-01-02 15:04:05")) }运行结果&#xff1a; E:\program\go\src\hw>go run h1.go 2…
阅读更多...
electron打包

electron打包

1、全局安装electron-packager npm install -g electron-packager 2、在项目目录下执行命令 electron-packager ./ --platformwin32 --archia32--platform 是发布平台win32指windows平台 linux darwin--archia32 指32位windows 64位的则为x64 3 notice package.json里面的name字…
阅读更多...
WPR-007：WPF中窗体的透明设置

WPR-007：WPF中窗体的透明设置

一般使用WindowStyle&#xff0c;Background&#xff0c;AllowsTransparency&#xff0c;Opacity来进行设置。 1、设置Opacity控制整个窗口的透明&#xff0c;包括上面的控件 Window x:Class"TestTransparentWindow.MainWindow" xmlns"http://schemas.m…
阅读更多...
element中el-input无法输入

element中el-input无法输入

element 的 el-input 组件&#xff0c;由于组件嵌套了层次&#xff0c;导致组件无法及时刷新 解决办法&#xff1a; 使用 input &#xff0c;在输入时进行强制刷新 <el-input input"forceUpdate" v-model"status" placeholder"请输入状态">…
阅读更多...
浅谈项目管理中的四要素

浅谈项目管理中的四要素

项目管理一直是一个老生常谈的问题&#xff0c;我们身边项目时时刻刻发生&#xff0c;大到火箭上天&#xff0c;小到家庭装修。老K作为技术出身&#xff0c;大大小小也做了不下50个项目&#xff0c;这里老K从IT的角度&#xff0c;带领大家用理论的知识分享如何做好一个项目。　…
阅读更多...
万立快速开发平台——软件制作大师

万立快速开发平台——软件制作大师

万立快速开发平台&#xff0c;是一款国内最好用的快速开发平台&#xff0c;使用者不需要懂技术&#xff0c;不用写代码&#xff0c;可以快速地开发出强大的管理软件&#xff0c;例如ERP&#xff0c;OA&#xff0c;CRM&#xff0c;HRM等等软件。 万立快速开发平台&#xff0c;能…
阅读更多...
Memcached缓存在.Net 中的使用(memcacheddotnet)

Memcached缓存在.Net 中的使用(memcacheddotnet)

From: http://www.cnblogs.com/xibei666/p/4863604.html 缓存对于提高大数据量的网站性能无疑不是一个很好的解决方案&#xff0c;针对缓存的使用网上同仁介绍很多&#xff0c;再次我仅仅分享一下自己对Memcached使用的简单介绍。Memchached的使用通过第三方DLL来完成&#xff…
阅读更多...
js获取节点的DOM操作

js获取节点的DOM操作

一直感觉DOM节点什么的乱七八糟的不能理解&#xff0c;可能博客也没办法写清楚&#xff0c;只能把知道的一些信息大致写下来慢慢再补充了。 HTML DOM类型 Node类型 Javascript中的所有节点类型都继承自Node类型&#xff0c;因此所有节点类型都共享着相同的基本属性和方法。 除I…
阅读更多...
git合并代码冲突

git合并代码冲突

场景&#xff1a;多人共同更改同一文件代码时候&#xff0c;可能回引发代码冲突。此时需要选择某一方或者双方代码进行合并。 采用当前更改&#xff1a;就是保留本地修改。 采用传入的更改&#xff1a;就是选择线上已有的覆盖更改。 保留双方更改&#xff1a;就是两份都保存。
阅读更多...
[转]T4模版引擎之基础入门

[转]T4模版引擎之基础入门

本文转自&#xff1a;http://www.cnblogs.com/lzrabbit/archive/2012/07/15/2591085.html 额&#xff0c;T4好陌生的名字&#xff0c;和NuGet一样很悲催&#xff0c;不为世人所熟知&#xff0c;却又在背后默默无闻的奉献着&#xff0c;直到现在我们项目组的人除了我之外&#x…
阅读更多...
请问WCF 跟 WebService之间异同

请问WCF 跟 WebService之间异同

From: http://tommyhu.cn/wcf-WebService-qu-bie/ 问题&#xff1a; WCF与 Web Service的区别是什么&#xff1f; 和ASP.NET Web Service有什么关系&#xff1f; WCF与ASP.NET Web Service的区别是什么&#xff1f; 这是很多.NET开发人员容易搞错的问题。面试的时候也经常遇到…
阅读更多...
最新文章

Copyright @ 2022~2023