网游是怎么进行通信的?本文教你用最简单的 TCP/IP Socket 实现最简单的网络通信。
初学者可能接触了 Unity 游戏引擎以后,会萌生做联机游戏的想法,我一开始也一样。我尝试过一些联机服务框架,比如 PUN2,最终游戏的确能玩,但这无法满足我的求知欲,我还是想自己实现服务器和客户端通信。相信读者也不希望只会用框架而不知道原理。
本系列博文参考自《Unity3D 网络游戏实战》一书。如有错误,欢迎评论区指正。
客户端、服务端、TCP#
你手机运行的 App,电脑上玩的游戏,都算客户端程序。运行在运营商服务器上的程序,是服务端程序。
游戏中,客户端与服务端一般使用 TCP(Transfer Control Protocol,传输控制协议) 进行通信。TCP 是面向连接的、可靠的、基于字节流的传输层通信协议。简单理解为:需要建立连接,传输丢包率低,传输的数据是字节流。
客户端之间的消息通信利用服务端的消息转发来实现。
假设 Client A 和 Client B 都与 Server A 进行了 TCP 连接。
如果 Client A 位置变更,那么 Client B 怎么知道呢?由于 Client A 和 Client B 都与 Server A 进行了连接,Server A 可以把 Client A 位置变更的消息发送给 Client B,这样就完成了位置信息同步。
如果数以万计的客户端同时连接同一个服务端,不难想象,这个服务端可能会崩溃。所以,现在的网游多数都进行分区处理。分区实际上就是服务端采取分布式架构。这样,原本一个服务端要处理十万个客户端,现在 N 个服务端处理十万个客户端,崩溃的可能性小多了。
心细的读者会考虑到,那如果十万个客户端都选同一个区呢?哈哈哈,玩过 LOL 的朋友就最清楚了,以前每次有活动,艾欧尼亚都会“排队”!蜂拥而至的情况,服务端会处理的,排队就是处理方式之一。
Socket#
Socket,套接字,是网络连接的端点。网络上的两个程序进行双向通信时,通信的一端是 Socket。对于 Client A 和 Server A 而言,Client A 包含一个 Socket 实例,Server A 包含一个 Socket 实例。Socket 包含了网络通信的五种信息:
Socket 包含的五种信息:
- 协议:TCP
- 本地 IP: 192.168.1.103
- 本地端口: 65308
- 远程 IP:192.168.1.105
- 远程端口:8888
Socket 通信流程为:
Socket 通信流程:
- 服务端建立 Socket 对象,Bind(绑定)一个 IPEndPoint(就是 IP 和端口号所生成的对象)
- 服务端开启 Listen(监听)
- 客户端 Connect(连接)到服务端(三次握手)
- 服务端 Accept(接受)连接
- 客户端和服务端通过 Send(发送)和 Receive(接收)进行数据通信
- 某一方 Close(关闭)连接(四次挥手)
开始网络编程:Echo#
我会分为同步篇和异步篇来说明。
客户端采用 Unity3D 制作,服务端采用 C#.NET 制作控制台应用程序。
Echo 的效果就是,客户端给服务端发送 InputField 输入框内的文本消息,服务端控制台打印日志,把接收到的消息发送回客户端,客户端的 Text 控件显示从服务端接收到的消息文本。
同步和异步的概念#
同步是指:发送方发出数据后,等接收方发回响应以后才发下一个数据包的通讯方式。
异步是指:发送方发出数据后,不等接收方发回响应,接着发送下个数据包的通讯方式。
同步往往不被采纳,因为会造成线程阻塞,影响程序性能。但是同步程序要好写很多,所以我先从最简单的同步程序讲起。
同步篇#
场景搭建:

说明:Unity 场景中空物体 EchoSync 绑定客户端脚本 EchoSync.cs,有一个 ConnectButton 按钮,绑定客户端脚本的 Connection 方法,有一个 Send 按钮,绑定客户端脚本的 Send 方法,有一个 InputField 对应输入框,有一个 Text 对应服务端发回来的信息显示,InputField 和 Text 通过 public 绑定。这里设计好服务端 IP 为 localhost(127.0.0.1),端口号 8888。
客户端代码:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Net.Sockets;
using UnityEngine.UI;
/// <summary>
/// 同步,客户端
/// </summary>
public class EchoSync : MonoBehaviour
{
/// <summary>
/// 套接字
/// </summary>
private Socket socket;
/// <summary>
/// 发送信息的输入框
/// </summary>
public InputField input;
/// <summary>
/// 显示服务端发送内容的文本框
/// </summary>
public Text text;
/// <summary>
/// 连接服务器
/// </summary>
public void Connection()
{
//定义使用IPv4,流式传输,TCP协议的一个Socket
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//连接服务器,服务器ip为本机ip,端口号8888
socket.Connect("127.0.0.1", 8888);
}
/// <summary>
/// 发送消息
/// </summary>
public void Send()
{
//----------------------
//发送
//获取输入框文本字符串
string sendStr = input.text;
//转换为字节数组
byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(sendStr);
//发送
socket.Send(sendBytes);
//----------------------
//接收
//接收缓冲
byte[] readBuffer = new byte[1024];
//接收并获得字节大小
int count = socket.Receive(readBuffer);
//生成字符串
string receiveStr = System.Text.Encoding.UTF8.GetString(readBuffer, 0, count);
//显示字符串到UGUI
text.text = receiveStr;
//----------------------
//关闭
//关闭socket
socket.Close();
}
}服务端代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
/// <summary>
/// 同步,服务器,缺点:阻塞,CPU占用高。
/// </summary>
namespace Echo_Server_Sync
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
//Console.ReadKey();
//创建Socket
Socket listenfd = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//创建IPAddress
IPAddress ipAddr = IPAddress.Parse("127.0.0.1");
//创建IPEndPoint
IPEndPoint ipEp = new IPEndPoint(ipAddr, 8888);
//绑定(Bind)
listenfd.Bind(ipEp);
//监听,0代表等待连接数不受限制
listenfd.Listen(0);
Console.WriteLine("[服务器]启动成功");
while (true)
{
//Accept
Socket connfd = listenfd.Accept();
Console.WriteLine("[服务器]Accept");
//Receive
byte[] readBuffer = new byte[1024];
int count = connfd.Receive(readBuffer);
string receiveStr = System.Text.Encoding.UTF8.GetString(readBuffer, 0, count);
Console.WriteLine("[服务器接收]" + receiveStr);
//Send
byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(receiveStr);
connfd.Send(sendBytes);
}
}
}
}这样的客户端和服务器程序,写起来简单,用起来可能会造成卡顿,因为 Connect、Accept、Receive、Send 都是阻塞方法。不仅如此,目前的同步程序,只能是 1 对 1 的关系,服务端不能处理多个客户端的连接。
异步篇#
异步程序中,对应的 API 发生了变换。Connect 变为 BeginConnect,Accept 变为 BeginAccept,Receive 变为 BeginReceive,Send 变为 BeginSend。改变后的方法均需要传入 void Callback(IAsyncResult ar) 类型的委托作为回调,均返回一个 IAsyncResult 接口类型的对象。相应需要结束,就有 EndConnect、EndAccept、EndReceive、EndSend 等方法,需要传入一个 IAsyncResult 类型的对象作为参数。
客户端代码:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Net.Sockets;
using UnityEngine.UI;
using System;
/// <summary>
/// 异步,客户端
/// </summary>
public class EchoAsync : MonoBehaviour
{
/// <summary>
/// 套接字
/// </summary>
private Socket socket;
/// <summary>
/// 发送信息的输入框
/// </summary>
public InputField input;
/// <summary>
/// 显示服务端发送内容的文本框
/// </summary>
public Text text;
/// <summary>
/// 接收缓冲区
/// </summary>
private byte[] readBuffer = new byte[1024];
/// <summary>
/// 接收文本
/// </summary>
private string recvStr = "";
/// <summary>
/// 连接服务器
/// </summary>
public void Connection()
{
//定义使用IPv4,流式传输,TCP协议的一个Socket
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//开始异步连接服务器,服务器ip为本机ip,端口号8888,回调函数为ConnectCallback,回调参数socket
socket.BeginConnect("127.0.0.1", 8888, ConnectCallback, socket);
}
/// <summary>
/// 异步连接的回调
/// </summary>
/// <param name="ar"></param>
public void ConnectCallback(IAsyncResult ar)
{
try
{
//通过ar的异步状态获取到socket对象
Socket socket = (Socket)ar.AsyncState;
//结束异步连接
socket.EndConnect(ar);
Debug.Log("Socket连接成功");
//开始异步接收
socket.BeginReceive(readBuffer, 0, 1024, 0, ReceiveCallback, socket);
}
catch(SocketException ex)
{
Debug.LogError("Socket连接失败: " + ex.ToString());
}
}
/// <summary>
/// 异步接收的回调
/// </summary>
/// <param name="ar"></param>
public void ReceiveCallback(IAsyncResult ar)
{
try
{
Socket socket = (Socket)ar.AsyncState;
//结束异步接收,返回接收信息的字节个数
int count = socket.EndReceive(ar);
recvStr = System.Text.Encoding.UTF8.GetString(readBuffer, 0, count);
//继续开始异步接收,形成循环
socket.BeginReceive(readBuffer, 0, 1024, 0, ReceiveCallback, socket);
}
catch(SocketException ex)
{
Debug.LogError("Socket接收失败: " + ex.ToString());
}
}
/// <summary>
/// 异步发送消息
/// </summary>
public void Send()
{
//----------------------
//发送
//获取输入框文本字符串
string sendStr = input.text;
//转换为字节数组
byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(sendStr);
//发送
socket.BeginSend(sendBytes, 0, sendBytes.Length, 0, SendCallback, socket);
}
/// <summary>
/// 异步发送消息的回调
/// </summary>
/// <param name="ar"></param>
public void SendCallback(IAsyncResult ar)
{
try
{
Socket socket = (Socket)ar.AsyncState;
int count = socket.EndSend(ar);
Debug.Log("Socket发送成功,发送字节数:" + count);
}
catch(SocketException ex)
{
Debug.LogError("Socket发送失败" + ex.ToString());
}
}
private void Update()
{
text.text = recvStr;
}
}需要注意的是:
- 采用异步以后,不能在回调里直接对 Unity 的控件(例如 Text)进行更新,因为异步程序新开了线程,非主线程无法对 Unity 控件进行任何操作,所以只能改变一个字符串的值,在 Update 方法中循环赋值为那个字符串。
- 回调里继续调用 BeginXXX 方法,BeginXXX 方法里再传入这个回调,可以形成一个循环。
- 异步程序可能会抛出 SocketException 异常,所以需要使用 try/catch 结构进行异常捕获。
服务端代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
/// <summary>
/// 异步,服务器
/// </summary>
namespace Echo_Server_Async
{
/// <summary>
/// 客户端状态
/// </summary>
class ClientState
{
//套接字
public Socket socket;
//接收缓冲区
public byte[] readBuffer = new byte[1024];
}
class Program
{
//监听Socket
static Socket listenfd;
//客户端Socket及状态
static Dictionary<Socket, ClientState> clients = new Dictionary<Socket, ClientState>();
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
//Console.ReadKey();
//创建Socket
listenfd = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//创建IPAddress
IPAddress ipAddr = IPAddress.Parse("127.0.0.1");
//创建IPEndPoint
IPEndPoint ipEp = new IPEndPoint(ipAddr, 8888);
//绑定(Bind)
listenfd.Bind(ipEp);
//监听,0代表等待连接数不受限制
listenfd.Listen(0);
Console.WriteLine("[服务器]启动成功");
//开始异步Accept
listenfd.BeginAccept(AcceptCallback, listenfd);
Console.ReadLine();
}
/// <summary>
/// 异步Accept的回调
/// </summary>
/// <param name="ar"></param>
public static void AcceptCallback(IAsyncResult ar)
{
try
{
Console.WriteLine("[服务器]Accept");
Socket listenfd = (Socket)ar.AsyncState;
Socket clientfd = listenfd.EndAccept(ar);
//clients列表
ClientState state = new ClientState();
state.socket = clientfd;
clients.Add(clientfd, state);
//开始异步接收数据
clientfd.BeginReceive(state.readBuffer, 0, 1024, 0, ReceiveCallback, state);
//继续异步Accept
listenfd.BeginAccept(AcceptCallback, listenfd);
}
catch(SocketException ex)
{
Console.WriteLine("Socket Accept失败" + ex.ToString());
}
}
/// <summary>
/// 异步接收的回调
/// </summary>
/// <param name="ar"></param>
public static void ReceiveCallback(IAsyncResult ar)
{
try
{
ClientState state = (ClientState)ar.AsyncState;
Socket clientfd = state.socket;
int count = clientfd.EndReceive(ar);
//客户端关闭
if(count == 0)
{
clientfd.Close();
clients.Remove(clientfd);
Console.WriteLine("Socket关闭");
return;
}
string recvStr = System.Text.Encoding.UTF8.GetString(state.readBuffer, 0, count);
Console.WriteLine("[服务器接收]" + recvStr);
byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes("Echo " + recvStr);
clientfd.Send(sendBytes);
Console.WriteLine("[服务器发送]" + "Echo " + recvStr);
//继续开始异步接收
clientfd.BeginReceive(state.readBuffer, 0, 1024, 0, ReceiveCallback, state);
}
catch(SocketException ex)
{
Console.WriteLine("Socket接收失败" + ex.ToString());
}
}
}
}需要注意的是:
- 服务端使用了 Dictionary<Socket, ClientState>存储了客户端字典集合。
- ClientState 存储了 Socket 对应连接的 Socket 对象和缓冲区。
- EndReceive 返回客户端传送的字节数,字节数为 0 代表该客户端断开了连接。
- 为了减少代码量,服务端的 Send 没有采用异步,但读者可以用异步实现,效果会更好。
这样的程序,效率高,CPU 占用相对较低,不会阻塞,一个服务端可以处理多个客户端的连接。
关于程序中的 API,详见 微软官方 C# API 文档。
运行效果#
以异步为例:

总结#
同步方法好写但阻塞,可能影响程序的效率。
异步方法效率高性能好,但是写起来相对复杂。
对于游戏而言,性能很关键,所以我们一般不会使用同步方法。
留言