• C#实现本地服务器多客户端同频道通信

    （一）需求

         在游戏中我们经常能够看到玩家在世界频道聊天，在QQ或微信中也有群聊功能。抽象成计算机网络，就是多个客户端通过服务器进行同频道通信，所有连接的客户端都可以看到其他客户端发送的消息。这种多客户端同频道通信是如何实现的呢？在本篇文章我们就来探讨一下。

    （二）解决思路

           这个需求的重点部分在于网络通信，需要我们掌握基本的计算机网络通信知识，具体到每种编程语言又有对应的API。如果把这个需求抽象到计算机网络中，我们就可以理解成多个客户端向服务器发送信息，服务器接收信息后又把信息发送给所有连接的客户端。这样，在各个客户端就可以接收到其他客户端发送的信息了。

    （三）设计思路

           服务器基于本地服务器开发，通过一个单独的C#控制台项目模拟，编程语言使用C#，客户端通过Unity3D构建GUI并编写客户端脚本。多客户端则通过打开多个Unity3D项目的可执行文件进行模拟，客户端的GUI需要有调试面板、客户端名称下拉菜单、连接和断开连接按钮、消息显示面板、消息输入框和消息发送按钮等。

    （四）代码实现

            由于代码中引用了自定义的网络通信共享库NetShare，关于NetShare请阅读这篇文章。

           客户端

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Net;
    4. using System.Net.Sockets;
    5. using System.Text;
    6. using UnityEngine;
    7. using UnityEngine.UI;
    8. using NetShare;//自定义网络通信共享库，包括通用数据包DataPacket等
    9. using System.Threading;
    10.  
    11. //世界频道客户端
    12. public class WorldChannelClient : MonoBehaviour
    13. {
    14.     public Text BaseInfo;//显示Socket连接基本信息的文本
    15.     public Text EchoContents;//Socket回显信息的文本
    16.     public Text ChatContents;//聊天信息的文本
    17.     public Dropdown ClientMenu;//客户端名称下拉菜单
    18.     public Button Connect;//连接按钮
    19.     public Button DisConnect;//断开连接按钮
    20.     public InputField SendInput;//聊天消息输入框
    21.     public Button Send;//聊天信息发送按钮
    22.  
    23.     static string ipAddressStr;//IP地址字符串
    24.     static int port;//端口
    25.     static IPAddress iPAddress;//IP地址对象
    26.     static IPEndPoint iPEndPoint;//IP端点对象
    27.     string clientName;//客户端名称
    28.     Socket currentClientSocket;//当前客户端Socket
    29.     bool isLockSend;//是否锁定聊天信息发送按钮
    30.     byte[] buffer;//消息接收缓冲区
    31.     Queue<string> echoContentQueue, chatContentQueue;//回显信息队列和聊天信息队列
    32.     DataPacket dataPacket;//通用数据包
    33.  
    34.     //反映Socket是否与服务器有效连接的属性
    35.     bool isConnected
    36.     {
    37.         get
    38.         {
    39.             if (currentClientSocket == null) return false;
    40.             return !currentClientSocket.Poll(10, SelectMode.SelectRead) && currentClientSocket.Connected;
    41.         }
    42.     }
    43.  
    44.     void Start()
    45.     {
    46.         //初始化
    47.         ipAddressStr = "8.137.8.206";
    48.         clientName = ClientMenu.options.Count > 0 ? ClientMenu.options[0].text : "";
    49.         port = 5500;
    50.         iPAddress = IPAddress.Parse(ipAddressStr);
    51.         iPEndPoint = new IPEndPoint(iPAddress, port);
    52.         buffer = new byte[1024];
    53.         echoContentQueue = new Queue<string>();
    54.         chatContentQueue = new Queue<string>();
    55.  
    56.         //为UI控件添加监听事件
    57.         ClientMenu.onValueChanged.AddListener((index) =>
    58.         {
    59.             clientName = ClientMenu.options[index].text;
    60.         });
    61.         Connect.onClick.AddListener(() =>
    62.         {
    63.             Thread thread = new Thread(new ThreadStart(ConnectDeal));
    64.             thread.Start();
    65.         });
    66.         DisConnect.onClick.AddListener(() =>
    67.         {
    68.             Thread thread = new Thread(new ThreadStart(DisConnectDeal));
    69.             thread.Start();
    70.         });
    71.         Send.onClick.AddListener(() =>
    72.         {
    73.             Thread thread = new Thread(new ThreadStart(SendDeal));
    74.             thread.Start();
    75.         });
    76.     }
    77.  
    78.     void Update()
    79.     {
    80.         //不断更新Socket基本信息
    81.         BaseInfo.text = $"ClientName:{clientName}" +
    82.                         string.Format("\nSocketHashCode:{0}", currentClientSocket == null ? "None" : currentClientSocket.GetHashCode().ToString()) +
    83.                         $"\nisLock:{isLockSend}" +
    84.                         string.Format("\nPoll:{0}", currentClientSocket == null ? "None" : (!currentClientSocket.Poll(10, SelectMode.SelectRead)).ToString()) +
    85.                         string.Format("\nIsConnected:{0}", currentClientSocket == null ? "False" : currentClientSocket.Connected.ToString());
    86.         //更新回显信息
    87.         if (echoContentQueue.Count > 0)
    88.         {
    89.             while (echoContentQueue.Count > 0)
    90.             {
    91.                 SetEchoContents(echoContentQueue.Dequeue());
    92.             }
    93.         }
    94.         //更新聊天信息
    95.         if (chatContentQueue.Count > 0)
    96.         {
    97.             while (chatContentQueue.Count > 0)
    98.             {
    99.                 SetChatContents(chatContentQueue.Dequeue());
    100.             }
    101.         }
    102.     }
    103.  
    104.     //设置回显信息相关UI的内容
    105.     void SetEchoContents(string text)
    106.     {
    107.         EchoContents.text += text;
    108.     }
    109.  
    110.     //设置聊天信息相关UI的内容
    111.     void SetChatContents(string text)
    112.     {
    113.         ChatContents.text += text;
    114.     }
    115.  
    116.     //执行逻辑：Socket异步连接处理
    117.     void ConnectDeal()
    118.     {
    119.         echoContentQueue.Enqueue($"\n客户端{clientName}正在请求服务器连接...");
    120.         Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    121.         clientSocket.BeginConnect(iPEndPoint, ConnectCallback, clientSocket);
    122.     }
    123.  
    124.     //执行逻辑：Socket异步断开连接处理
    125.     void DisConnectDeal()
    126.     {
    127.         echoContentQueue.Enqueue($"\n客户端{clientName}正在断开与服务器的连接...");
    128.         if (isConnected)
    129.         {
    130.             currentClientSocket.Shutdown(SocketShutdown.Both);//关闭Socket的发送和接收消息功能
    131.             currentClientSocket.BeginDisconnect(false, DisConnectCallback, currentClientSocket);
    132.         }
    133.         else echoContentQueue.Enqueue($"\n客户端{clientName}未与服务器建立连接,无法进行断开连接的操作...");
    134.     }
    135.  
    136.     //执行逻辑：Socket异步接收信息处理
    137.     void ReceiveDeal()
    138.     {
    139.         echoContentQueue.Enqueue($"\n客户端{clientName}开始监听服务器响应...");
    140.         currentClientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, currentClientSocket);
    141.     }
    142.  
    143.     //执行逻辑：Socket异步发送信息处理
    144.     void SendDeal()
    145.     {
    146.         if (!isLockSend && !string.IsNullOrEmpty(SendInput.text))
    147.         {
    148.             dataPacket.mContent = SendInput.text;
    149.             SendInput.text = string.Empty;
    150.             byte[] bytes = dataPacket.ToBytes();
    151.             currentClientSocket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, SendCallback, currentClientSocket);
    152.         }
    153.     }
    154.  
    155.     //执行逻辑：Socket异步连接处理回调
    156.     void ConnectCallback(IAsyncResult ar)
    157.     {
    158.         try
    159.         {
    160.             Socket socket = ar.AsyncState as Socket;
    161.             socket.EndConnect(ar);
    162.             currentClientSocket = socket;
    163.             if (isConnected)
    164.             {
    165.                 dataPacket = new ClientDataPacket()
    166.                 {
    167.                     mLocalEndPointStr = socket.LocalEndPoint.ToString(),
    168.                     mClientName = clientName
    169.                 };
    170.                 isLockSend = false;
    171.                 echoContentQueue.Enqueue($"\n客户端{clientName}与服务器连接成功!");
    172.                 ReceiveDeal();
    173.             }
    174.             else echoContentQueue.Enqueue($"\n客户端{clientName}与服务器连接失败!");
    175.         }
    176.         catch (SocketException se)
    177.         {
    178.             echoContentQueue.Enqueue($"\n客户端{clientName}与服务器连接失败!\n错误信息:{se.Message}");
    179.         }
    180.     }
    181.  
    182.     //执行逻辑：Socket异步断开连接处理回调
    183.     void DisConnectCallback(IAsyncResult ar)
    184.     {
    185.         try
    186.         {
    187.             isLockSend = true;
    188.             Socket socket = ar.AsyncState as Socket;
    189.             socket.EndDisconnect(ar);
    190.             dataPacket = null;
    191.             echoContentQueue.Enqueue($"\n客户端{clientName}与服务器断开连接操作成功!");
    192.         }
    193.         catch (SocketException se)
    194.         {
    195.             echoContentQueue.Enqueue($"\n客户端{clientName}与服务器断开连接操作失败！\n错误信息:{se.Message}");
    196.         }
    197.     }
    198.  
    199.     //执行逻辑：Socket异步发送信息处理回调
    200.     void SendCallback(IAsyncResult ar)
    201.     {
    202.         try
    203.         {
    204.             Socket socket = ar.AsyncState as Socket;
    205.             socket.EndSend(ar);
    206.             echoContentQueue.Enqueue($"\n客户端{clientName}向服务器发送了一条消息！");
    207.         }
    208.         catch (SocketException se)
    209.         {
    210.             echoContentQueue.Enqueue($"\n客户端{clientName}向服务器发送信息操作失败！\n错误信息:{se.Message}");
    211.         }
    212.     }
    213.  
    214.     //执行逻辑：Socket异步接收信息处理回调
    215.     void ReceiveCallback(IAsyncResult ar)
    216.     {
    217.         try
    218.         {
    219.             Socket socket = ar.AsyncState as Socket;
    220.             int count = socket.EndReceive(ar);
    221.             string res = Encoding.UTF8.GetString(buffer, 0, count);
    222.             if (!string.IsNullOrEmpty(res)) chatContentQueue.Enqueue("\n" + res);
    223.             //若Socket连接有效则继续接收消息
    224.             if (isConnected)
    225.                 socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, socket);
    226.         }
    227.         catch (SocketException se)
    228.         {
    229.             echoContentQueue.Enqueue($"\n客户端{clientName}接收服务器消息失败！\n错误信息:{se.Message}");
    230.         }
    231.     }
    232. }

            服务器

    1. using System.Net.Sockets;
    2. using System.Net;
    3. using System.Text;
    4. using NetShare;//自定义网络通信共享库，其中包括了通用数据包DataPacket、客户端数据包ClientDataPacket等
    5.  
    6. namespace UnityServer
    7. {
    8.     //世界频道服务器
    9.     internal class WorldChannelServer
    10.     {
    11.         private static string ipAddressStr = "127.0.0.1";//IP地址字符串
    12.         private static int port = 5500;//端口
    13.         private static int maxConnectCount = 20;//最大连接数
    14.         private static byte[] buffer = new byte[1024];//消息缓冲区
    15.  
    16.         //客户端Socket合集，key为IPEndPoint字符串，value为服务器为客户端分配的Socket
    17.         private static Dictionary<string, Socket> clients = new Dictionary<string, Socket>();
    18.  
    19.         private static Socket? serverSocket;//服务器Socket
    20.  
    21.         private static void Main(string[] args)
    22.         {
    23.             Thread thread = new Thread(new ThreadStart(ServerDeal));
    24.             thread.Start();
    25.             Console.ReadLine();
    26.         }
    27.  
    28.         //判断Socket是否进行有效连接
    29.         private static bool IsConnected(Socket socket)
    30.         {
    31.             if (socket == null) return false;
    32.             return !socket.Poll(10, SelectMode.SelectRead) && socket.Connected;
    33.         }
    34.  
    35.         //执行逻辑：服务器处理
    36.         private static void ServerDeal()
    37.         {
    38.             serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    39.             IPAddress v_ipAddress = IPAddress.Parse(ipAddressStr);
    40.             serverSocket.Bind(new IPEndPoint(v_ipAddress, port));
    41.             serverSocket.Listen(maxConnectCount);
    42.             Console.WriteLine($"开启服务器[{serverSocket.LocalEndPoint}]...");
    43.  
    44.             serverSocket.BeginAccept(AcceptCallback, null);
    45.         }
    46.  
    47.         //执行逻辑：Socket异步接收消息
    48.         private static void ReceiveDeal(object? clientSocket)
    49.         {
    50.             Console.WriteLine("********************");
    51.             if (clientSocket == null) return;
    52.             Socket? v_clientSocket = clientSocket as Socket;
    53.             if (v_clientSocket == null) return;
    54.             Console.WriteLine("接收到客户端的连接请求！");
    55.  
    56.             if (IsConnected(v_clientSocket))
    57.                 v_clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, v_clientSocket);
    58.         }
    59.  
    60.         //添加客户端Socket到客户端Socket合集
    61.         private static void AddClient(Socket clientSocket)
    62.         {
    63.             if (clientSocket == null) return;
    64.             EndPoint? endPoint = clientSocket.RemoteEndPoint;
    65.             if (endPoint != null)
    66.             {
    67.                 string? v_endPointStr = endPoint.ToString();
    68.                 if (v_endPointStr != null) clients[v_endPointStr] = clientSocket;
    69.             }
    70.         }
    71.  
    72.         //向所有客户端发送指定信息
    73.         private static void SendToAll(string? content)
    74.         {
    75.             if (string.IsNullOrEmpty(content)) return;
    76.             byte[] bytes = Encoding.UTF8.GetBytes(content);
    77.             foreach (Socket clientSocket in clients.Values)
    78.             {
    79.                 if (IsConnected(clientSocket))
    80.                 {
    81.                     Thread thread = new Thread(() =>
    82.                     {
    83.                         clientSocket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, SendCallback, clientSocket);
    84.                     });
    85.                     thread.Start();
    86.                 }
    87.             }
    88.         }
    89.  
    90.         //Socket监听请求回调
    91.         private static void AcceptCallback(IAsyncResult ar)
    92.         {
    93.             try
    94.             {
    95.                 if (serverSocket != null)
    96.                 {
    97.                     Socket clientSocket = serverSocket.EndAccept(ar);
    98.                     AddClient(clientSocket);
    99.                     Thread thread = new Thread(new ParameterizedThreadStart(ReceiveDeal));
    100.                     thread.Start(clientSocket);
    101.                     serverSocket.BeginAccept(AcceptCallback, null);
    102.                 }
    103.             }
    104.             catch (SocketException se)
    105.             {
    106.                 Console.WriteLine("AcceptException:" + se.Message);
    107.             }
    108.         }
    109.  
    110.         //Socket发送信息回调
    111.         private static void SendCallback(IAsyncResult ar)
    112.         {
    113.             try
    114.             {
    115.                 Socket? clientSocket = ar.AsyncState as Socket;
    116.                 if (clientSocket != null) clientSocket.EndSend(ar);
    117.             }
    118.             catch (SocketException se)
    119.             {
    120.                 Console.WriteLine("SendException:" + se.Message);
    121.             }
    122.         }
    123.  
    124.         //Socket接收信息回调
    125.         private static void ReceiveCallback(IAsyncResult ar)
    126.         {
    127.             try
    128.             {
    129.                 Socket? clientSocket = ar.AsyncState as Socket;
    130.                 if (clientSocket != null)
    131.                 {
    132.                     int bytesCount = clientSocket.EndReceive(ar);
    133.                     ClientDataPacket? dataPacket = DataPacket.ToObject(buffer.Take(bytesCount).ToArray());
    134.                     if (dataPacket != null)
    135.                     {
    136.                         string v_content = $"客户端{dataPacket.mClientName}：{dataPacket.mContent}";
    137.                         SendToAll(v_content);
    138.                     }
    139.                     if (IsConnected(clientSocket))
    140.                         clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, clientSocket);
    141.                 }
    142.             }
    143.             catch (SocketException se)
    144.             {
    145.                 Console.WriteLine("ReceiveException:" + se.Message);
    146.             }
    147.         }
    148.     }
    149. }

    （五）测试

           测试流程大概是先启动服务器，然后启动三个客户端，三个客户端分别以A、B、C的名称作为客户端名称与服务器建立连接，连接后再由客户端A、B、C分别向服务器发送信息，通过观察三个客户端的消息面板来确定测试结果，具体测试流程请观看下列视频：

    本地服务器多客户端通信

    （六）总结

           在服务器端，我们通过一个C#控制台项目来模拟服务器后台，服务器与客户端具有类似的功能，同样具有发送、接收消息的功能，不同的是服务器具有监听客户端连接的功能，而客户端具有向服务器发送连接请求的功能，本质上这些都是通过Socket实现的功能，人为划分成服务器端和客户端。在客户端我们通过GUI将用户的操作进行可视化构建，实现了回显、客户端名称选择、连接、断开连接、发送和显示消息等基本交互。

           为了模拟多客户端并发操作，所有功能我们都采用了异步的方式启动，对于真正的网络通信而言，这对我们来说才刚刚开始，不过通过这个案例也让我们了解了基本的网络通信流程。

    如果这篇文章对你有帮助，请给作者点个赞吧！

  • 相关阅读:
    【C++类型转换】4种类型转换：static_cast、reinterpret_cast、const_cast、dynamic_cast
    LeetCode刷题笔记【35】：动态规划专题-7（爬楼梯、零钱兑换、完全平方数）
    C语言典范编程
    HK32_UID中获取芯片唯一ID相同的问题
    使用任务定时执行软件的定时关机功能，控制电脑可用时间段
    06-集合
    今年跳槽成功测试工程师原来是掌握了这3个“潜规则”
    OpenCV(四十):图像分割—漫水填充
    Window10 安装 Lua
    Spring实战之Bean的主要装配机制之一-组件扫描、自动装配bean
  • 原文地址：https://blog.csdn.net/hgf1037882434/article/details/134539702