C# List使用Stream同时删除多个元素

在 C# 中，你可以使用 `Stream` 流来同时删除多个元素。以下是一个例子，演示如何使用 `Stream` 流来同时删除多个元素：

List<int> numbers = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> numbersToRemove = new List<int>() { 2, 4, 6, 8, 10 };

// 创建一个新的 List，其中包含所有要保留的元素
List<int> numbersToKeep = numbers.Where(x => !numbersToRemove.Contains(x)).ToList();

// 输出剩余元素
foreach (int number in numbersToKeep)
{
    Console.WriteLine(number);
}

在这个例子中，我们使用 `Stream` 流来删除多个元素。我们创建了一个名为 `numbersToRemove` 的 `List` 对象，它包含要删除的元素。然后，我们使用 `Where` 方法创建一个新的 `List` 对象，其中包含所有不包含在 `numbersToRemove` 中的元素。最后，我们输出剩余的元素。

需要注意的是，这种方式并没有直接修改原始 `List` 对象，而是创建了一个新的 `List` 对象。如果你需要直接修改原始 `List` 对象，则可以使用 `RemoveAll` 方法，或者使用 `List` 类型的延迟删除。

相关问题

C#中 用socket实现多个个客户端的相互聊天功能

好的，下面是一个简单的 C# socket 多客户端聊天示例代码，其中使用了 TCP 协议。

服务端代码：

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace SocketServer
{
    class Program
    {
        static List<TcpClient> clientsList = new List<TcpClient>();
        static void Main(string[] args)
        {
            IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 1234);
            TcpListener listener = new TcpListener(localEndPoint);
            listener.Start();
            Console.WriteLine("Server started, waiting for client to connect...");

            while (true)
            {
                TcpClient client = listener.AcceptTcpClient();
                Console.WriteLine("Client connected: " + client.Client.RemoteEndPoint.ToString());
                clientsList.Add(client);
                BroadcastMessage(client.Client.RemoteEndPoint.ToString() + " joined the chat");

                NetworkStream stream = client.GetStream();
                byte[] buffer = new byte[1024];

                while (true)
                {
                    int bytesRead = stream.Read(buffer, 0, buffer.Length);
                    string message = Encoding.ASCII.GetString(buffer, 0, bytesRead);
                    Console.WriteLine("Received message: " + message);

                    if (message == "quit")
                    {
                        clientsList.Remove(client);
                        BroadcastMessage(client.Client.RemoteEndPoint.ToString() + " left the chat");
                        break;
                    }

                    BroadcastMessage(client.Client.RemoteEndPoint.ToString() + ": " + message);
                }

                stream.Close();
                client.Close();
            }

            listener.Stop();
        }

        static void BroadcastMessage(string message)
        {
            byte[] buffer = Encoding.ASCII.GetBytes(message);
            foreach (TcpClient client in clientsList)
            {
                NetworkStream stream = client.GetStream();
                stream.Write(buffer, 0, buffer.Length);
            }
        }
    }
}

客户端代码：

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace SocketClient
{
    class Program
    {
        static void Main(string[] args)
        {
            IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1234);
            TcpClient client = new TcpClient();
            client.Connect(remoteEndPoint);
            Console.WriteLine("Connected to server: " + client.Client.RemoteEndPoint.ToString());

            NetworkStream stream = client.GetStream();
            byte[] buffer = new byte[1024];

            Thread receiveThread = new Thread(new ThreadStart(() =>
            {
                while (true)
                {
                    int bytesRead = stream.Read(buffer, 0, buffer.Length);
                    string message = Encoding.ASCII.GetString(buffer, 0, bytesRead);
                    Console.WriteLine("Received message: " + message);
                }
            }));
            receiveThread.Start();

            while (true)
            {
                Console.Write("Enter your message: ");
                string message = Console.ReadLine();
                byte[] messageBuffer = Encoding.ASCII.GetBytes(message);
                stream.Write(messageBuffer, 0, messageBuffer.Length);

                if (message == "quit")
                    break;
            }

            stream.Close();
            client.Close();
        }
    }
}

以上代码演示了一个简单的 TCP socket 多客户端聊天程序，服务端可以接受多个客户端连接，每个客户端之间可以相互发送消息，客户端程序可以通过控制台进行输入和输出。

c# socket服务器 封装类 多线程

以下是一个支持多线程的C# Socket服务器封装类的示例：

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

public class SocketServer
{
    private readonly List<Socket> _clients = new List<Socket>();
    private readonly Socket _listener;
    private readonly Thread _listenerThread;

    public SocketServer(int port)
    {
        _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        _listener.Bind(new IPEndPoint(IPAddress.Any, port));
        _listener.Listen(10);

        _listenerThread = new Thread(ListenForClients);
        _listenerThread.Start();

        Console.WriteLine($"Server started on port {port}");
    }

    private void ListenForClients()
    {
        while (true)
        {
            var client = _listener.Accept();
            _clients.Add(client);
            Console.WriteLine($"Client connected: {client.RemoteEndPoint}");

            var thread = new Thread(HandleClient);
            thread.Start(client);
        }
    }

    private void HandleClient(object clientObj)
    {
        var client = (Socket)clientObj;
        var buffer = new byte[1024];

        while (true)
        {
            try
            {
                var bytesRead = client.Receive(buffer);

                if (bytesRead > 0)
                {
                    var message = Encoding.ASCII.GetString(buffer, 0, bytesRead);
                    Console.WriteLine($"Received message from {client.RemoteEndPoint}: {message}");

                    // Echo the message back to the client
                    var responseBuffer = Encoding.ASCII.GetBytes(message);
                    client.Send(responseBuffer);
                }
                else
                {
                    Console.WriteLine($"Client disconnected: {client.RemoteEndPoint}");
                    _clients.Remove(client);
                    client.Close();
                    return;
                }
            }
            catch (SocketException)
            {
                Console.WriteLine($"Client disconnected: {client.RemoteEndPoint}");
                _clients.Remove(client);
                client.Close();
                return;
            }
        }
    }

    public void Close()
    {
        _listener.Close();
        foreach (var client in _clients)
        {
            client.Shutdown(SocketShutdown.Both);
            client.Close();
        }
    }
}

使用示例：

var server = new SocketServer(1234);
Console.ReadLine();
server.Close();

这个封装类与之前的封装类非常相似，但它在接受客户端连接时创建了一个新的线程来处理每个客户端。这允许服务器同时处理多个客户端，而不必等待一个客户端的操作完成后才能处理另一个客户端。当客户端断开连接时，对应的线程也会退出。可以通过调用Close()方法来关闭服务器。