简介：TCP作为传输层的可靠通信协议，在建立连接后提供顺序和准确的数据传输。本教程将展示如何使用C#在Unity环境中创建一个本地TCP服务器和客户端，演示数据的发送和接收过程。通过利用.NET Framework中的TcpListener和TcpClient类，服务端将在单独线程上运行以避免阻塞主游戏循环。本项目着重于代码的实现细节，包括服务端的监听、接受连接以及客户端的连接和数据传输等关键部分。此外，还注重于Unity环境下的异步操作处理，使用Coroutine协同程序处理网络响应。开发者将通过本实践学习在Unity中运用TCP协议进行网络通信，从而为开发多人在线游戏和其他实时网络应用打下基础。
1. TCP通信协议概述
1.1 TCP的起源与重要性
传输控制协议（TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议。它由互联网工程任务组（IETF）在RFC 793中定义，是互联网中最重要的协议之一。TCP确保数据包能够在复杂的网络环境中准确无误地到达目的地，它在数据发送前会建立一个连接，并在数据传输完成后断开连接。
1.2 TCP的工作机制
TCP通过三次握手过程建立连接，这个过程包括同步序列编号（SYN）、确认应答（ACK）和完成建立连接的最终确认。数据传输完成后，通过四次挥手来断开连接。TCP通过序列号和确认应答机制保证数据包的顺序和完整性，而流量控制和拥塞控制则确保网络资源的有效利用和数据的平稳传输。
1.3 TCP的应用场景
TCP广泛应用于需要可靠传输的场景，比如网页浏览（HTTP）、文件传输（FTP）、电子邮件（SMTP/POP3）等。它提供了高度可靠的数据传输服务，能够确保即使在丢包、乱序或重复的网络环境下，数据也能够被完整地送达。尽管TCP在延迟和带宽效率方面有时不如用户数据报协议（UDP），但其在保证数据传输稳定性方面的优势使其成为许多关键应用的首选。
2. C#语言在Unity中的应用
在当今游戏开发领域，Unity已经成为一个不可或缺的平台，为开发者提供了一个功能强大的游戏引擎和开发环境。C#（发音为 “C sharp”），作为一种现代、类型安全的面向对象语言，已经成为Unity游戏开发的默认编程语言。C#语言以其简洁的语法、强大的功能、丰富的库支持和跨平台能力而受到开发者的青睐。在本章节中，我们将深入探讨C#语言在Unity中的应用，包括其基本语法、数据类型、类和对象，以及如何在Unity中通过C#脚本进行事件处理和多线程处理。
2.1 C#语言基础
C#是一种优雅而功能强大的编程语言，它具备现代编程语言的所有特性，并且与Microsoft .NET框架紧密集成。C#的语言设计旨在使开发者能够快速开发各种应用程序，特别是在Unity游戏开发环境中。
2.1.1 C#的基本语法
C#的基本语法是学习这门语言的基础，它为编写结构化程序提供了一系列规则和约定。C#的语句可以被组织到代码块中，通常由花括号 {} 包围。在代码块中，语句可以是表达式语句、选择语句、迭代语句、跳转语句等。
例如，创建一个简单的C#程序，它输出”Hello, Unity!”到控制台：
using System;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, Unity!");
}
}
}
在上述代码中， using System; 指令引入了System命名空间，它包含了许多有用的类，比如Console类。 namespace HelloWorld 定义了一个命名空间，而 class Program 定义了一个类， Main 方法是程序的入口点，是每个C#程序必须包含的一个静态方法。
2.1.2 C#的数据类型和变量
C#是一种强类型语言，这意味着所有的变量都必须声明其类型。C#的基本数据类型包括整型、浮点型、字符型和布尔型等。例如， int 表示一个32位的整数， float 表示一个32位的单精度浮点数， char 表示单个Unicode字符，而 bool 表示布尔值。
变量的声明遵循以下模式：
TypeName variableName;
比如：
int number = 10;
float decimalNumber = 9.99f;
char letter = 'A';
bool isTrue = true;
2.1.3 C#的类和对象
类是面向对象编程的基础。在C#中，类是定义对象的蓝图或模板，它包含了数据成员（字段）和函数成员（方法）。
定义一个类的基本语法如下：
class ClassName
{
// 数据成员和方法
}
例如，创建一个表示游戏对象的简单类：
class GameObject
{
string name;
int health;
public GameObject(string name, int health)
{
this.name = name;
this.health = health;
}
public void TakeDamage(int damage)
{
health -= damage;
}
}
在此类中， name 和 health 是私有字段，而 TakeDamage 是一个公共方法。对象由类的实例化产生，如创建 GameObject 的实例：
GameObject myObject = new GameObject("Character", 100);
创建类的实例化对象是面向对象编程的核心概念，允许开发者以模块化和可重用的方式来组织代码。
通过本章节的介绍，您将深入了解C#语言的基础知识以及如何在Unity游戏开发环境中应用这些知识。在下一节中，我们将深入了解C#在Unity中的具体应用，包括如何在Unity编辑器中使用C#脚本以及如何在Unity中处理事件和进行多线程编程。
3. 本地TCP服务器和客户端实现
3.1 本地TCP服务器的实现
3.1.1 本地TCP服务器的设计
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。设计一个本地TCP服务器，我们需要遵循TCP的三次握手协议来建立连接，并且确保数据在两个点之间准确、可靠地传输。
本地TCP服务器的设计主要涉及以下几个方面：
- 监听端口 ：服务器需要在特定的端口上进行监听，以便客户端可以向该端口发起连接请求。
- 接受连接 ：服务器需要能够接受客户端的连接请求，并建立连接。
- 数据通信 ：服务器与客户端连接建立后，应该能够接收和发送数据。
- 并发处理 ：为了提高服务器的使用效率和性能，服务器通常需要支持多线程或异步IO，以同时处理多个客户端的连接和数据传输。
- 异常处理和资源管理 ：服务器需要具备异常处理能力，并在适当的时候释放资源，比如关闭不再需要的连接。
3.1.2 本地TCP服务器的代码实现
在C#中，可以使用 System.Net.Sockets 命名空间下的 TcpListener 类来创建本地TCP服务器。下面的代码展示了如何实现一个简单的TCP服务器。
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
public class TcpServer
{
private TcpListener _listener;
private int _port = 8080; // 服务器监听端口
public TcpServer()
{
_listener = new TcpListener(IPAddress.Any, _port);
}
public void Start()
{
_listener.Start();
Console.WriteLine("TCP服务器启动，等待客户端连接...");
while (true)
{
// 等待客户端连接
TcpClient client = _listener.AcceptTcpClient();
Console.WriteLine("客户端已连接：" + client.Client.RemoteEndPoint.ToString());
// 创建线程来处理客户端连接
Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClient));
clientThread.Start(client);
}
}
private void HandleClient(object obj)
{
TcpClient client = (TcpClient)obj;
NetworkStream stream = client.GetStream();
try
{
byte[] buffer = new byte[1024];
int bytesRead;
// 循环读取客户端数据
while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
{
string message = Encoding.ASCII.GetString(buffer, 0, bytesRead);
Console.WriteLine("收到客户端消息：" + message);
// 发送数据到客户端
string response = "服务器响应：" + message;
byte[] responseBytes = Encoding.ASCII.GetBytes(response);
stream.Write(responseBytes, 0, responseBytes.Length);
}
}
catch (Exception e)
{
Console.WriteLine("发生异常：" + e.Message);
}
finally
{
// 关闭流和客户端连接
stream.Close();
client.Close();
}
}
}
上述代码中创建了一个 TcpServer 类，它包含了 Start() 方法用于启动服务器监听，以及 HandleClient() 方法用于处理每个客户端的连接。服务器使用 AcceptTcpClient() 方法接受连接请求，并且为每个客户端创建一个新的线程以实现并发处理。
3.2 本地TCP客户端的实现
3.2.1 本地TCP客户端的设计
客户端是主动发起TCP连接请求的实体。在设计时需要考虑如何发起连接请求、如何发送数据请求、如何接收服务器的响应，以及如何正确处理网络异常和资源释放。
3.2.2 本地TCP客户端的代码实现
using System;
using System.Net.Sockets;
using System.Text;
using System.Threading;
public class TcpClientApp
{
private string _serverIp = "127.0.0.1"; // 服务器IP地址
private int _port = 8080; // 服务器端口
public void ConnectToServer()
{
try
{
TcpClient client = new TcpClient();
client.Connect(_serverIp, _port); // 连接到服务器
Console.WriteLine("已连接到服务器");
NetworkStream stream = client.GetStream();
// 发送数据到服务器
string message = "Hello Server!";
byte[] data = Encoding.ASCII.GetBytes(message);
stream.Write(data, 0, data.Length);
// 读取服务器响应
data = new byte[256];
int bytes = stream.Read(data, 0, data.Length);
string responseData = Encoding.ASCII.GetString(data, 0, bytes);
Console.WriteLine("来自服务器的响应：" + responseData);
// 关闭连接
stream.Close();
client.Close();
}
catch (SocketException e)
{
Console.WriteLine("SocketException: " + e.ToString());
}
}
}
上述客户端代码创建了一个 TcpClientApp 类，它包含 ConnectToServer() 方法用于连接服务器并发送接收数据。客户端使用 TcpClient 类发起连接请求，并通过 NetworkStream 来发送和接收数据。
以上代码展示了本地TCP服务器和客户端的基本实现方式。在实际的项目中，代码需要根据具体需求进行优化和扩展，例如增加异步操作处理、设置超时机制、添加加密通信等安全特性。此外，代码注释应详细说明每一步操作的逻辑和目的，以便于理解代码的执行流程和潜在的风险点。
4. .NET Framework的System.Net.Sockets类使用
4.1 System.Net.Sockets类的基本使用
4.1.1 System.Net.Sockets类的简介
在 .NET Framework 中， System.Net.Sockets 命名空间提供了许多用于网络通信的类。这些类允许开发者编写能够执行各种网络操作的程序，如发送和接收数据，建立连接，和在客户端与服务器之间进行通信。 System.Net.Sockets 类是基于 TCP/IP 协议族的，它为开发面向连接的网络应用程序提供了基础。
其中， Socket 类是 .NET 中进行网络通信的核心类。通过使用 Socket 类的实例，开发者可以创建 TCP 或 UDP 连接，并进行数据的发送和接收。
4.1.2 System.Net.Sockets类的主要方法
-
Socket 类构造函数 ：用于初始化新的
Socket实例，可以指定协议类型（如SocketType.Stream表示面向连接的协议）。 -
Bind ：将
Socket绑定到特定的 IP 地址和端口上，这是服务器端开始监听连接请求之前的必要步骤。 -
Listen ：让服务器
Socket开始监听端口上的连接请求。 -
Accept ：服务器端用于接受客户端的连接请求，返回一个新的
Socket实例用于与客户端通信。 -
Connect ：在客户端用于发起对服务器的连接请求。
-
Send 和 Receive ：用于在网络上发送和接收数据。
-
Close 和 Shutdown ：用于关闭
Socket连接。
这些方法是使用 System.Net.Sockets 类进行网络通信时最常用的一些。下面章节将会对一些高级用法进行详解。
4.2 System.Net.Sockets类的高级使用
4.2.1 异步网络操作处理
在进行网络编程时，为了不阻塞主线程，异步网络操作是一个非常重要的概念。使用 System.Net.Sockets 类库时，可以利用其提供的异步方法来实现这一点。
异步操作不会阻塞主线程，因此用户界面仍然可以响应用户操作，提高程序的响应性和性能。异步网络操作通常通过使用 BeginXXX 和 EndXXX 方法模式来实现。例如， BeginReceive 和 EndReceive 用于异步接收数据。
4.2.2 网络数据的接收和发送
网络数据的发送和接收是网络编程中最基本的操作， System.Net.Sockets 类库中的 Socket 类提供了简单易用的方法来实现数据的传输。
当使用 Send 方法时，需要提供一个包含数据的 byte[] 数组和数据的长度。 Receive 方法则是从网络中接收数据到 byte[] 数组中。值得注意的是，网络编程通常涉及到字节序和数据包分段问题，因此在接收数据时需要合理处理字节流，避免数据解析错误。
下面是一个简单的使用 System.Net.Sockets 类进行异步网络操作的 C# 代码示例：
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
public class AsyncSocketExample
{
private Socket socket;
public void StartListening()
{
// 创建 socket 实例并初始化
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// 绑定到 IP 地址和端口
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 11000);
socket.Bind(localEndPoint);
// 开始监听
socket.Listen(100);
// 接受客户端的连接请求
socket.BeginAccept(new AsyncCallback(AcceptCallback), socket);
}
private void AcceptCallback(IAsyncResult ar)
{
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
// 创建新线程来处理客户端请求
new Thread(new ThreadStart(HandleClient)).Start(handler);
// 继续监听
listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
}
private void HandleClient(object obj)
{
Socket clientSocket = (Socket)obj;
// 接收客户端发送的数据
byte[] buffer = new byte[1024];
int bytesRead = clientSocket.Receive(buffer);
// 处理接收到的数据
string receivedData = Encoding.ASCII.GetString(buffer, 0, bytesRead);
Console.WriteLine("Received: {0}", receivedData);
// 发送响应数据到客户端
string responseData = "Hello from server";
byte[] response = Encoding.ASCII.GetBytes(responseData);
clientSocket.Send(response);
// 关闭连接
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
}
}
在上述代码示例中，首先初始化并监听一个 TCP 服务器端口，然后使用 BeginAccept 方法接受客户端的连接请求，并在回调方法 AcceptCallback 中处理客户端的连接。使用新线程 HandleClient 来处理客户端请求，以避免阻塞主线程。
这个代码片段演示了如何使用 System.Net.Sockets 类进行基本的网络通信。在实际应用中，需要根据具体需求对异常进行处理，并实现更健壮的连接管理机制。
5. Unity中异步网络操作处理
5.1 异步网络操作的基本概念
5.1.1 异步网络操作的定义
异步网络操作是一种不阻塞主执行流程的网络通信方式，在执行网络请求或响应时，允许程序继续执行其他任务而不是等待。在Unity中，这通常是通过协程（Coroutines）实现的，这使得网络调用可以在后台进行，而不会导致UI冻结或其他性能问题。
5.1.2 异步网络操作的优势
使用异步网络操作的优势在于它提高了应用程序的响应性。用户界面保持流畅，用户体验更佳，同时还能执行其他任务，如数据处理和渲染。对于移动游戏开发，这尤为重要，因为网络延迟可能导致用户等待时间变长。
5.2 异步网络操作的具体实现
5.2.1 Unity中异步网络操作的API
Unity提供了一些API来处理异步网络操作，例如 www 类（现在推荐使用 UnityWebRequest ）。 UnityWebRequest 类能够发送GET和POST请求，并处理常见的网络响应格式，如JSON和XML。
5.2.2 异步网络操作的代码实现
下面是一个使用 UnityWebRequest 来发送异步HTTP GET请求的例子：
using System.Collections;
using UnityEngine;
using UnityEngine.Networking;
public class AsyncWebRequests : MonoBehaviour
{
IEnumerator SendGetRequest()
{
UnityWebRequest www = UnityWebRequest.Get("http://example.com/api/data");
yield return www.SendWebRequest();
if (www.isNetworkError || www.isHttpError)
{
Debug.LogError(www.error);
}
else
{
Debug.Log("Received: " + www.downloadHandler.text);
}
}
}
在这个代码块中，我们首先创建了一个 UnityWebRequest 对象来获取指定的URL。通过使用 yield return www.SendWebRequest(); ，我们暂停了协程的执行，直到请求完成。如果请求成功，我们打印出接收到的数据；如果请求失败，则打印出错误信息。注意，为了处理异步逻辑，我们使用了协程，这是一种在Unity中处理异步任务的流行方式。
6. Coroutine协同程序在Unity网络操作中的应用
在Unity开发中，网络操作往往是复杂且耗时的任务，尤其是在多线程和异步操作方面。Coroutine协同程序提供了一种灵活的方式来处理这些操作，尤其是在需要维护游戏的实时性和流畅性的场景中。本章节将深入探讨Coroutine协同程序的基本概念、工作原理，以及它在网络操作中的应用。
6.1 Coroutine协同程序的基本概念
6.1.1 Coroutine协同程序的定义
Coroutine协同程序是Unity提供的一种特殊的函数，它允许执行一些操作，然后在某个时刻被挂起，稍后再从上次挂起的位置继续执行。这种控制流程的能力使得协同程序非常适合用来处理需要等待一段时间才能继续的操作，比如网络请求。
6.1.2 Coroutine协同程序的工作原理
协同程序的执行依赖于 yield 语句。当 yield 语句被执行时，它会返回一个迭代器对象，该对象告诉Unity在何时何地恢复协同程序的执行。最常用的 yield 语句是 yield return null ，它允许程序等待下一个Update调用。
6.2 Coroutine协同程序在Unity网络操作中的应用
6.2.1 Coroutine协同程序在网络操作中的优势
使用Coroutine协同程序进行网络操作，可以使得网络请求在后台异步执行，而不会阻塞主线程。这意味着，即便是在网络请求进行时，游戏仍可以继续响应玩家的输入并进行必要的更新。此外，协同程序的暂停和恢复机制让代码更加清晰，易于管理。
6.2.2 Coroutine协同程序的具体实现
为了更好地理解Coroutine协同程序在网络操作中的应用，我们将通过一个实际的代码示例来进行说明。
假设我们要实现一个简单的网络请求功能，其中需要异步地从服务器获取数据。以下是一个使用 UnityWebRequest 进行网络请求并使用Coroutine处理异步操作的示例代码：
using UnityEngine;
using System.Collections;
using UnityEngine.Networking;
public class NetworkRequestExample : MonoBehaviour
{
IEnumerator MakeWebCall(string url)
{
UnityWebRequest www = UnityWebRequest.Get(url);
yield return www.SendWebRequest();
if (www.result != UnityWebRequest.Result.Success)
{
Debug.Log(www.error);
}
else
{
Debug.Log(www.downloadHandler.text);
}
}
void Start()
{
StartCoroutine(MakeWebCall("http://example.com/api/data"));
}
}
在上述代码中：
-
UnityWebRequest.Get(url)创建了一个网络请求实例，用于向指定的URL发送请求。 -
yield return www.SendWebRequest();是关键所在，它告诉Unity要暂停协同程序的执行，直到网络请求完成。 - 一旦请求完成，
www.result会被用来检查请求是否成功。 - 如果请求成功，我们就可以通过
www.downloadHandler.text获取服务器返回的数据。
这个简单的例子演示了如何在Unity中使用Coroutine协同程序来处理异步网络请求。在网络请求结束后，协同程序自动恢复并执行后续代码，而无需阻塞主线程。
通过上面的实现，我们可以看到Coroutine在处理网络请求时的强大能力。它不仅可以将网络操作的复杂性封装在易于理解的控制流中，还能保持游戏界面的响应性和性能。在现代游戏开发中，将网络请求与游戏逻辑分离，使用Coroutine进行处理是一种常见且推荐的做法。
7. Unity中服务端监听和客户端连接的具体代码实现
在游戏或实时应用程序中，实现服务器监听和客户端连接是网络通信的基础。本章节将详细介绍如何在Unity中使用C#语言和System.Net.Sockets类实现服务端监听和客户端连接的具体代码。
7.1 服务端监听的具体实现
7.1.1 服务端监听的设计
为了实现一个服务端监听，我们首先需要设计一个能够监听网络请求的服务器。服务端监听的主要任务是等待客户端的连接请求，一旦接收到请求，就建立连接并处理客户端发送的数据。
7.1.2 服务端监听的代码实现
以下是使用C#在Unity中创建一个简单的TCP服务端监听器的代码示例。
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
public class TcpServer
{
private TcpListener tcpListener;
private Thread listenThread;
public TcpServer(int port)
{
tcpListener = new TcpListener(IPAddress.Any, port);
}
public void Start()
{
listenThread = new Thread(new ThreadStart(ListenForClients));
listenThread.Start();
}
private void ListenForClients()
{
tcpListener.Start();
Console.WriteLine("Server started. Waiting for a connection...");
while (true)
{
// Blocks until a client has connected to the server
TcpClient client = tcpListener.AcceptTcpClient();
Console.WriteLine("Connected!");
// Create a thread to handle communication with connected client
Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClientComm));
clientThread.Start(client);
}
}
private void HandleClientComm(object obj)
{
TcpClient client = (TcpClient)obj;
NetworkStream stream = client.GetStream();
byte[] buffer = new byte[1024];
int bytesRead;
try
{
while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
{
// There might be more data in the stream so
// store it until an empty line is read
string received = Encoding.ASCII.GetString(buffer, 0, bytesRead);
Console.WriteLine("Received: " + received);
//Echo back to the client
byte[] msg = Encoding.ASCII.GetBytes(received);
stream.Write(msg, 0, msg.Length);
Console.WriteLine("Sent: " + received);
}
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
}
finally
{
// Shutdown and end connection
client.Close();
}
}
}
此代码段展示了如何创建一个 TcpServer 类，它包含用于启动监听和处理客户端连接的逻辑。服务端监听在指定端口上启动，当接收到连接请求时，它会为每个客户端连接创建一个新的线程来处理通信。
7.2 客户端连接的具体实现
7.2.1 客户端连接的设计
客户端连接设计的核心是建立与服务端的连接，并发送/接收数据。客户端需要处理连接失败的情况，并能够从服务端接收响应。
7.2.2 客户端连接的代码实现
下面是一个简单的TCP客户端类，用于连接到服务器，并发送和接收数据。
using System;
using System.Net.Sockets;
using System.Text;
public class TcpClientExample
{
private TcpClient client;
public void Connect(string ip, int port)
{
try
{
// Create a TCP/IP client.
client = new TcpClient();
// Connect to a remote device.
client.Connect(ip, port);
// Create a network stream.
NetworkStream stream = client.GetStream();
// Send a message.
string message = "Hello from client!";
byte[] data = Encoding.ASCII.GetBytes(message);
stream.Write(data, 0, data.Length);
Console.WriteLine("Sent: {0}", message);
// Receive the server response.
data = new byte[256];
int bytes = stream.Read(data, 0, data.Length);
string responseData = Encoding.ASCII.GetString(data, 0, bytes);
Console.WriteLine("Received: {0}", responseData);
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
}
}
在上述代码中，客户端尝试连接到服务器，并发送一个简单的消息。随后，客户端等待服务器的响应并输出。如果连接过程中发生任何问题，会捕获 SocketException 异常。
请注意，以上代码均需在Unity环境下进行调试和执行，确保所有异步调用和线程处理均符合Unity的执行框架要求。
简介：TCP作为传输层的可靠通信协议，在建立连接后提供顺序和准确的数据传输。本教程将展示如何使用C#在Unity环境中创建一个本地TCP服务器和客户端，演示数据的发送和接收过程。通过利用.NET Framework中的TcpListener和TcpClient类，服务端将在单独线程上运行以避免阻塞主游戏循环。本项目着重于代码的实现细节，包括服务端的监听、接受连接以及客户端的连接和数据传输等关键部分。此外，还注重于Unity环境下的异步操作处理，使用Coroutine协同程序处理网络响应。开发者将通过本实践学习在Unity中运用TCP协议进行网络通信，从而为开发多人在线游戏和其他实时网络应用打下基础。
转载自CSDN-专业IT技术社区
原文链接：https://blog.csdn.net/weixin_32747681/article/details/149805110
