c#多线程网络聊天程序代码分享(服务器端和客户端)

C#多线程网络聊天程序代码分享(服务器端和客户端)

介绍

本文所分享的是使用C#编写的多线程网络聊天程序的源代码，包括服务器端和客户端代码。网络聊天程序可以实现在不同计算机之间进行即时聊天的功能，多线程可以提升程序的并发性和性能，同时使用C#编写可以大大简化代码编写过程。

实现流程

服务器端程序编写

服务器端程序的主要作用是接受用户请求，并与客户端进行通讯。以下是服务器端代码的主要实现过程：

创建Socket对象，并指定所使用的协议和通信类型。

Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

绑定IP地址和端口号，即指定服务器端进行监听的网络地址。

IPEndPoint serverIpEndPoint = new IPEndPoint(IPAddress.Parse("服务器IP地址"), 8888);
serverSocket.Bind(serverIpEndPoint);

开始监听客户端连接请求。

serverSocket.Listen(5);

使用无限循环进行接收客户端请求，并在有客户端接入时创建一个新的线程进行处理。

while (true)
{
    Socket clientSocket = serverSocket.Accept();
    //使用新线程处理客户端请求
    Thread thread = new Thread(ClientThreadProc);
    thread.Start(clientSocket);
}

在新线程中处理客户端的请求，包括接收客户端的消息和向客户端发送消息。

private void ClientThreadProc(object param)
{
    Socket clientSocket = (Socket)param;
    //接收来自客户端的消息
    byte[] buffer = new byte[1024 * 1024];
    int count = clientSocket.Receive(buffer);
    string msg = Encoding.UTF8.GetString(buffer, 0, count);
    //向客户端发送消息
    clientSocket.Send(Encoding.UTF8.GetBytes("收到了你的消息：" + msg));
    clientSocket.Close();
}

客户端程序编写

客户端程序的主要作用是与服务器端进行通讯，并向服务器端发送消息。以下是客户端代码的主要实现过程：

创建Socket对象，并连接到服务器端。

Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint serverIpEndPoint = new IPEndPoint(IPAddress.Parse("服务器IP地址"), 8888);
clientSocket.Connect(serverIpEndPoint);

向服务器端发送消息。

string msg = "你好，服务器！";
clientSocket.Send(Encoding.UTF8.GetBytes(msg));

接收来自服务器端的消息。

byte[] buffer = new byte[1024 * 1024];
int count = clientSocket.Receive(buffer);
string msg = Encoding.UTF8.GetString(buffer, 0, count);

关闭Socket对象。

clientSocket.Close();

示例说明

以下是基于上述代码实现的多线程网络聊天程序的两个示例说明。

示例1：单一服务器

假设有1台服务器和2个客户端，可以使用以下代码实现多线程网络聊天：

服务器端代码：

public class Server
{
    private Socket serverSocket;

    public void Start()
    {
        serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IPEndPoint serverIpEndPoint = new IPEndPoint(IPAddress.Parse("服务器IP地址"), 8888);
        serverSocket.Bind(serverIpEndPoint);
        serverSocket.Listen(5);

        while (true)
        {
            Socket clientSocket = serverSocket.Accept();
            Thread thread = new Thread(ClientThreadProc);
            thread.Start(clientSocket);
        }
    }

    private void ClientThreadProc(object param)
    {
        Socket clientSocket = (Socket)param;
        byte[] buffer = new byte[1024 * 1024];
        int count = clientSocket.Receive(buffer);
        string msg = Encoding.UTF8.GetString(buffer, 0, count);
        Console.WriteLine("服务器接收到来自客户端的消息：" + msg);
        clientSocket.Send(Encoding.UTF8.GetBytes("服务器已收到你的消息：" + msg));
        clientSocket.Close();
    }
}

客户端代码：

public class Client
{
    private Socket clientSocket;

    public void SendMessage(string msg)
    {
        clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IPEndPoint serverIpEndPoint = new IPEndPoint(IPAddress.Parse("服务器IP地址"), 8888);
        clientSocket.Connect(serverIpEndPoint);
        clientSocket.Send(Encoding.UTF8.GetBytes(msg));

        byte[] buffer = new byte[1024 * 1024];
        int count = clientSocket.Receive(buffer);
        string responseMsg = Encoding.UTF8.GetString(buffer, 0, count);
        Console.WriteLine("客户端接收到来自服务器的消息：" + responseMsg);

        clientSocket.Close();
    }
}

测试代码：

static void Main(string[] args)
{
    Server server = new Server();
    new Thread(server.Start).Start();

    Client client1 = new Client();
    new Thread(() => client1.SendMessage("你好，服务器！")).Start();

    Client client2 = new Client();
    new Thread(() => client2.SendMessage("来自客户端2的消息！")).Start();

    Console.ReadLine();
}

执行以上代码后，在服务器端的控制台输出如下：

服务器接收到来自客户端的消息：你好，服务器！
服务器接收到来自客户端的消息：来自客户端2的消息！

客户端1的控制台输出如下：

客户端接收到来自服务器的消息：服务器已收到你的消息：你好，服务器！

客户端2的控制台输出如下：

客户端接收到来自服务器的消息：服务器已收到你的消息：来自客户端2的消息！

可以看出，客户端发送的消息已经被服务器端接收，并向每个客户端发送响应消息。

示例2：多服务器

假设有2台服务器和2个客户端，可以使用以下代码实现多线程网络聊天：

服务器1代码：

public class Server1
{
    private Socket serverSocket;

    public void Start()
    {            
        serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IPEndPoint serverIpEndPoint = new IPEndPoint(IPAddress.Parse("服务器1IP地址"), 8888);
        serverSocket.Bind(serverIpEndPoint);
        serverSocket.Listen(5);

        while (true)
        {
            Socket clientSocket = serverSocket.Accept();
            Thread thread = new Thread(() => ClientThreadProc1(clientSocket));
            thread.Start();
        }
    }

    private void ClientThreadProc1(Socket clientSocket)
    {
        byte[] buffer = new byte[1024 * 1024];
        int count = clientSocket.Receive(buffer);
        string msg = Encoding.UTF8.GetString(buffer, 0, count);
        Console.WriteLine("服务器1接收到来自客户端的消息：" + msg);

        Socket server2Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IPEndPoint server2IpEndPoint = new IPEndPoint(IPAddress.Parse("服务器2IP地址"), 8889);
        server2Socket.Connect(server2IpEndPoint);

        server2Socket.Send(Encoding.UTF8.GetBytes(msg));
        buffer = new byte[1024 * 1024];
        count = server2Socket.Receive(buffer);
        string responseMsg = Encoding.UTF8.GetString(buffer, 0, count);
        Console.WriteLine("服务器1接收到来自服务器2的响应消息：" + responseMsg);

        server2Socket.Close();
        clientSocket.Send(Encoding.UTF8.GetBytes(responseMsg));
        clientSocket.Close();
    }
}

服务器2代码：

public class Server2
{
    private Socket serverSocket;

    public void Start()
    {
        serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IPEndPoint serverIpEndPoint = new IPEndPoint(IPAddress.Parse("服务器2IP地址"), 8889);
        serverSocket.Bind(serverIpEndPoint);
        serverSocket.Listen(5);

        while (true)
        {
            Socket clientSocket = serverSocket.Accept();
            Thread thread = new Thread(() => ClientThreadProc2(clientSocket));
            thread.Start();
        }
    }

    private void ClientThreadProc2(Socket clientSocket)
    {
        byte[] buffer = new byte[1024 * 1024];
        int count = clientSocket.Receive(buffer);
        string msg = Encoding.UTF8.GetString(buffer, 0, count);
        Console.WriteLine("服务器2接收到来自服务器1的消息：" + msg);
        clientSocket.Send(Encoding.UTF8.GetBytes("服务器2已收到你的消息：" + msg));
        clientSocket.Close();
    }
}

客户端代码：

public class Client
{
    private Socket clientSocket;

    public void SendMessage(string msg)
    {
        clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        IPEndPoint server1IpEndPoint = new IPEndPoint(IPAddress.Parse("服务器1IP地址"), 8888);
        clientSocket.Connect(server1IpEndPoint);
        clientSocket.Send(Encoding.UTF8.GetBytes(msg));

        byte[] buffer = new byte[1024 * 1024];
        int count = clientSocket.Receive(buffer);
        string responseMsg = Encoding.UTF8.GetString(buffer, 0, count);
        Console.WriteLine("客户端接收到来自服务器的消息：" + responseMsg);

        clientSocket.Close();
    }
}

测试代码：

static void Main(string[] args)
{
    Server1 server1 = new Server1();
    new Thread(server1.Start).Start();

    Server2 server2 = new Server2();
    new Thread(server2.Start).Start();

    Client client1 = new Client();
    new Thread(() => client1.SendMessage("来自客户端1的消息！")).Start();

    Client client2 = new Client();
    new Thread(() => client2.SendMessage("来自客户端2的消息！")).Start();

    Console.ReadLine();
}

执行以上代码后，在服务器1的控制台输出如下：

服务器1接收到来自客户端的消息：来自客户端1的消息！
服务器1接收到来自服务器2的响应消息：服务器2已收到你的消息：来自客户端1的消息！

在服务器2的控制台输出如下：

服务器2接收到来自服务器1的消息：来自客户端1的消息！