C#TCP/IP简单聊天多个客户端

Question

我正在学习c#socket编程.所以,我决定进行TCP聊天,基本的想法是A客户端将数据发送到服务器,然后服务器在线为所有客户端广播它(在这种情况下,所有客户端都在字典中).

当有1个客户端连接时,它按预期工作,当连接的客户端超过1时发生问题.

服务器:

class Program
{
    static void Main(string[] args)
    {
        Dictionary<int,TcpClient> list_clients = new Dictionary<int,TcpClient> ();

        int count = 1;


        TcpListener ServerSocket = new TcpListener(IPAddress.Any, 5000);
        ServerSocket.Start();

        while (true)
        {
            TcpClient client = ServerSocket.AcceptTcpClient();
            list_clients.Add(count, client);
            Console.WriteLine("Someone connected!!");
            count++;
            Box box = new Box(client, list_clients);

            Thread t = new Thread(handle_clients);
            t.Start(box);
        }

    }

    public static void handle_clients(object o)
    {
        Box box = (Box)o;
        Dictionary<int, TcpClient> list_connections = box.list;

        while (true)
        {
            NetworkStream stream = box.c.GetStream();
            byte[] buffer = new byte[1024];
            int byte_count = stream.Read(buffer, 0, buffer.Length);
            byte[] formated = new Byte[byte_count];
            //handle  the null characteres in the byte array
            Array.Copy(buffer, formated, byte_count);
            string data = Encoding.ASCII.GetString(formated);
            broadcast(list_connections, data);
            Console.WriteLine(data);

        } 
    }

    public static void broadcast(Dictionary<int,TcpClient> conexoes, string data)
    {
        foreach(TcpClient c in conexoes.Values)
        {
            NetworkStream stream = c.GetStream();

            byte[] buffer = Encoding.ASCII.GetBytes(data);
            stream.Write(buffer,0, buffer.Length);
        }
    }

}
class Box
{
    public TcpClient c;
     public Dictionary<int, TcpClient> list;

    public Box(TcpClient c, Dictionary<int, TcpClient> list)
    {
        this.c = c;
        this.list = list;
    }

}

我创建了这个盒子,所以我可以通过2个args Thread.start().

客户:

class Program
{
    static void Main(string[] args)
    {
        IPAddress ip = IPAddress.Parse("127.0.0.1");
        int port = 5000;
        TcpClient client = new TcpClient();
        client.Connect(ip, port);
        Console.WriteLine("client connected!!");
        NetworkStream ns = client.GetStream();

        string s;
        while (true)
        {
             s = Console.ReadLine();
            byte[] buffer = Encoding.ASCII.GetBytes(s);
            ns.Write(buffer, 0, buffer.Length);
            byte[] receivedBytes = new byte[1024];
            int byte_count = ns.Read(receivedBytes, 0, receivedBytes.Length);
            byte[] formated = new byte[byte_count];
            //handle  the null characteres in the byte array
            Array.Copy(receivedBytes, formated, byte_count); 
            string data = Encoding.ASCII.GetString(formated);
            Console.WriteLine(data);
        }
        ns.Close();
        client.Close();
        Console.WriteLine("disconnect from server!!");
        Console.ReadKey();        
    }
}

Answer 1

从你的问题不清楚你有什么具体的问题.但是,检查代码会发现两个重要问题:

1. 您不以线程安全的方式访问您的字典,这意味着可以向字典添加项的侦听线程可以在客户端服务线程尝试检查字典的同时对该对象进行操作.但是,添加操作不是原子的.这意味着在添加项目的过程中,字典可能暂时处于无效状态.这会导致尝试同时读取它的任何客户端服务线程出现问题.
2. 您的客户端代码尝试处理用户输入并在处理从服务器接收数据的同一线程中写入服务器.这可能导致至少一些问题:
   • 在下次用户提供某些输入之前,无法从其他客户端接收数据.
   • 因为在单个读取操作中您可能只收到一个字节,即使在用户提供输入后,您仍可能仍然无法收到先前发送的完整消息.

以下是解决这两个问题的代码版本:

服务器代码:

class Program
{
    static readonly object _lock = new object();
    static readonly Dictionary<int, TcpClient> list_clients = new Dictionary<int, TcpClient>();

    static void Main(string[] args)
    {
        int count = 1;

        TcpListener ServerSocket = new TcpListener(IPAddress.Any, 5000);
        ServerSocket.Start();

        while (true)
        {
            TcpClient client = ServerSocket.AcceptTcpClient();
            lock (_lock) list_clients.Add(count, client);
            Console.WriteLine("Someone connected!!");

            Thread t = new Thread(handle_clients);
            t.Start(count);
            count++;
        }
    }

    public static void handle_clients(object o)
    {
        int id = (int)o;
        TcpClient client;

        lock (_lock) client = list_clients[id];

        while (true)
        {
            NetworkStream stream = client.GetStream();
            byte[] buffer = new byte[1024];
            int byte_count = stream.Read(buffer, 0, buffer.Length);

            if (byte_count == 0)
            {
                break;
            }

            string data = Encoding.ASCII.GetString(buffer, 0, byte_count);
            broadcast(data);
            Console.WriteLine(data);
        }

        lock (_lock) list_clients.Remove(id);
        client.Client.Shutdown(SocketShutdown.Both);
        client.Close();
    }

    public static void broadcast(string data)
    {
        byte[] buffer = Encoding.ASCII.GetBytes(data + Environment.NewLine);

        lock (_lock)
        {
            foreach (TcpClient c in list_clients.Values)
            {
                NetworkStream stream = c.GetStream();

                stream.Write(buffer, 0, buffer.Length);
            }
        }
    }
}

客户代码:

class Program
{
    static void Main(string[] args)
    {
        IPAddress ip = IPAddress.Parse("127.0.0.1");
        int port = 5000;
        TcpClient client = new TcpClient();
        client.Connect(ip, port);
        Console.WriteLine("client connected!!");
        NetworkStream ns = client.GetStream();
        Thread thread = new Thread(o => ReceiveData((TcpClient)o));

        thread.Start(client);

        string s;
        while (!string.IsNullOrEmpty((s = Console.ReadLine())))
        {
            byte[] buffer = Encoding.ASCII.GetBytes(s);
            ns.Write(buffer, 0, buffer.Length);
        }

        client.Client.Shutdown(SocketShutdown.Send);
        thread.Join();
        ns.Close();
        client.Close();
        Console.WriteLine("disconnect from server!!");
        Console.ReadKey();
    }

    static void ReceiveData(TcpClient client)
    {
        NetworkStream ns = client.GetStream();
        byte[] receivedBytes = new byte[1024];
        int byte_count;

        while ((byte_count = ns.Read(receivedBytes, 0, receivedBytes.Length)) > 0)
        {
            Console.Write(Encoding.ASCII.GetString(receivedBytes, 0, byte_count));
        }
    }
}

笔记:

• 此版本使用该lock语句确保list_clients对象的线程的独占访问.
• 必须在整个消息广播期间保持锁定,以确保在枚举集合时不删除任​​何客户端,并且当另一个线程尝试在套接字上发送时,没有客户端被一个线程关闭.
• 在此版本中,不需要该Box对象.集合本身由所有执行的方法可访问的静态字段引用,并且int分配给每个客户端的值作为线程参数传递,因此线程可以查找相应的客户端对象.
• 服务器和客户端都会监视并处理以字节数为完成的读取操作0.这是用于指示远程端点已完成发送的标准套接字信号.端点表示已使用该Shutdown()方法完成发送.要启动正常关闭,Shutdown()将使用"发送"原因调用,指示端点已停止发送,但仍将接收.另一个端点,一旦完成发送到第一个端点,然后可以Shutdown()使用"both"的原因进行呼叫,以指示它已完成发送和接收.

代码中仍存在各种问题.以上仅解决了最明显的问题,并将代码带入了一个非常基本的服务器/客户端架构的工作演示的合理传真.

附录:

一些补充说明,以解决评论中的后续问题:

• 客户端调用Thread.Join()接收线程(即等待该线程退出),以确保在启动正常关闭进程后,它实际上不会关闭套接字,直到远程端点通过关闭其结束来响应.
• 使用o => ReceiveData((TcpClient)o)作为ParameterizedThreadStart委托是一个习惯,我更喜欢铸造线程参数.它允许线程入口点保持强类型.虽然,那段代码并不完全是我通常会写的; 我紧紧抓住你的原始代码,同时仍然利用这个机会来说明这个成语.但实际上,我会使用无参数ThreadStart委托使用构造函数重载,只需让lambda表达式捕获必要的方法参数:Thread thread = new Thread(() => ReceiveData(client)); thread.Start();然后,根本不需要进行任何转换(如果任何参数是值类型,则无需任何装箱处理它们/拆箱开销......在这种情况下通常不是关键问题,但仍然让我感觉更好:)).
• 将这些技术应用于Windows窗体项目会增加一些复杂性,这并不奇怪.在非UI线程(无论是专用的每个连接线程,还是使用多个异步API中的一个用于网络I/O)中接收时,您需要在与UI对象交互时返回UI线程.这里的解决方案与往常一样:最基本的方法是使用Control.Invoke()(或者Dispatcher.Invoke(),在WPF程序中); 更复杂(和恕我直言,更优秀)的方法是使用async/ await用于I/O. 如果您使用StreamReader接收数据,该对象已经有一个等待ReadLineAsync()和类似的方法.如果Socket直接使用,您可以使用该Task.FromAsync()方法将BeginReceive()和EndReceive()方法包装在一个等待中.无论哪种方式,结果是当I/O异步发生时,仍然可以在UI线程中处理完成,您可以在其中直接访问UI对象.(在这种方法中,您将等待代表接收代码的任务,而不是使用Thread.Join(),以确保您不会过早关闭套接字.)