本文使用udpclient和tcpclient，而非使用socket实例
命名空间
using System.Net;
using System.Net.Sockets;
TCP
TCP的核心对象为 TcpListener和TcpClient,前者用于服务器监听连接请求，并创建TcpClient对象，当需要通信时，直接使用创建的TcpClient调用Send,Receive方法即可
监听连接： TCP需要进行连接，因此需要一个连接监听器，服务器监听客户端连接如下
/// <summary>
/// TCP连接请求监听者
/// </summary>
private TcpListener tcpListener;
private void Awake()
{
//开启连接监听的线程，必须另开一个线程启动监听，如果在主线程里直接调用，主线程会阻塞
tcpListenerT = new Thread(ListenConnect);
tcpListenerT.IsBackground = true;
tcpListenerT.Start();
}
//监听连接请求的方法
private void ListenConnect()
{
//声明监听者的IP为任意可用`在这里插入代码片`
tcpListener = new TcpListener(new IPEndPoint(IPAddress.Any, 10086));
tcpListener.Start(100);//监听请求 最多连接100个
while (true)
{
//这一步会阻塞线程，不能在主线程中调用
TcpClient client = tcpListener.AcceptTcpClient();
//获取客户端的IP
string ip = (client.Client.RemoteEndPoint as IPEndPoint).Address.ToString();
}
}
客户端连接服务器:
private TcpClient tcpClient = new TcpClient();
private void Start()
{
//参数为服务器的地址，和服务器的TcpListener绑定的端口
tcpClient.Connect("192.168.1.36", 10086);
}
发送消息:
public void SendMsg(TcpClient client,string msg)
{
byte[] buff = Encoding.UTF8.GetBytes(msg);
client.Send(buff);
}
接收消息:
private TcpClient tcpClient = new TcpClient();
private void Start()
{
//连接到服务器
tcpClient.Connect("192.168.1.36", 10086);
//接收消息的方法必须在子线程中执行
tcpReciveT = new Thread(Recciveimage);
tcpReciveT.IsBackground = true;
tcpReciveT.Start();
}
/// <summary>
/// 接收字节数组
/// </summary>
private void Recciveimage()
{
//声明接收缓冲区的长度
byte[] receiveBuff = new byte[1024];
int reviceLength = 0;
while (true)
{
try
{
//返回值为接收到的字节的数量 这一步会阻塞线程，决不能在主线程中执行
reviceLength = tcpClient.Client.Receive(receiveBuff);
//必须指定转换的字节数组的长度，因为缓冲区剩余的空位会用0填充，这些0我们并不需要
msg = Encoding.UTF8.GetString(receiveBuff,0,reviceLength);
isReveive = true;
print("收到的消息 "+msg);
}
}
}
UDP
UDP相对简单，UDP并不需要连接，核心对象为UdpClinent和IPEndPoint
UdpClient即UDP的对象，用于收发消息
IPEndPoint可以理解为Udp通信的端点，解决三个问题 我是谁？我要发到哪里去？我从哪里接收？
声明UdpClient时，需要指定UdpClient的IPEndPoint，即，我是谁
通过UdpClient发送消息时，需要指定目的地的IPEndPoint，即，我要发到哪里去
通过UdpClient接收消息时，需要指定监听的IPEndPoint，即，我从哪里收
IPEndPoint常用的构造有以下两种,都需要我们指定IP和端口，在构造函数中使用IPAddress类指定IP
//IP为当前可用IP，或任意IP 端口为0表示任何端口， 这种声明通常在接收消息中使用
new IPEndPoint(IPAddress.Any, 0)
//指定一个IP，255.255.255.255为群发 端口为40000 指定确定的IP端口通常用于声明UdpClient和发送消息
new IPEndPoint(IPAddress.Parse("192.168.1.36"), 40000)
发送
//公共的消息发送中心
private UdpClient udpClient;
private void Awake()
{
//为UdpClient绑定本机的IP和端口 我是谁
udpClient = new UdpClient(new IPEndPoint(IPAddress.Any, 40000));
}
/// <summary>
/// 消息发送 IPEndPoint声明 IPEndPoint = new IPEndPoint(IPAddress.Parse("192.168.1.36"),10000)
/// </summary>
public void CommonendMsgSender(string msg, IPEndPoint commonIPEndPoint)
{
byte[] commonBuff = Encoding.UTF8.GetBytes(msg);
udpClient.Send(commonBuff, commonBuff.Length, commonIPEndPoint);
}
监听
private UdpClient CommonUdpClient;
// 公共的消息接收端口
private IPEndPoint commonReceiveIPEndPoint;
// 公共的消息线程
Thread commonReceiveThread;
// 公共消息的缓存
private byte[] commonMsgBuff;
private void Start()
{
//公共消息接收端口
commonReceiveIPEndPoint = new IPEndPoint(IPAddress.Any, 0);
//启动监听线程，和TCP一样，监听会阻塞线程，不能在主线程中监听消息
commonReceiveThread = new Thread(ListenCommonMsg);
commonReceiveThread.IsBackground = true;
commonReceiveThread.Start();
}
// 监听公共消息
private void ListenCommonMsg()
{
while (true)
{
//这里会阻塞线程
commonMsgBuff = CommonUdpClient.Receive(ref commonReceiveIPEndPoint);
string temp = Encoding.UTF8.GetString(commonMsgBuff);
print("公共消息为" + temp);
}
}
注意事项
1 监听操作必须在子线程中执行，不要在主线程中执行，否则主线程会被阻塞
2 重复监听消息应该使用死循环
3 子线程可以操作主线程的简单属性，如果 int bool str，但不能直接操作Uinty对象如Text等，如果需要在接收消息后改变场景内容 ，在一个主线程的脚本中的Update里，使用一个bool制作一把锁，将子线程收到的消息，赋值给主线程脚本的string变量，并将锁置为true，使用这个脚本来控制Uinty对象
例
//子线程接到消息后，置为true
public bool isReceive = false;
/// <summary>
/// 子线程接到消息后，将消息赋值到这个变量
/// </summary>
public string msg;
void Update()
{
if (isReceive)
{
//处理msg
if(msg == "1")
{
//逻辑
}
}
}