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

            服务器

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

    （五）测试

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

    本地服务器客户端单独通信

    （六）总结

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

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

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

  • 相关阅读:
    红黑树的由来及其底层原理
    Spark的部署与使用
    NuGet私有服务器ProGet Docker搭建和公司中实战用法
    算法9-动态规划
    P5194 [USACO05DEC]Scales S
    操作系统 day11（进程调度时机、切换、调度方式）
    赛力斯上半年营收124亿亏17亿：与华为深度捆绑 已推两款车型
    wordpress建网站主题案例推荐
    奇异矩阵、非奇异矩阵
    springboot毕设项目4S店车辆管理系统4n9r4（java+VUE+Mybatis+Maven+Mysql）
  • 原文地址：https://blog.csdn.net/hgf1037882434/article/details/134540785