是否可以有多个具有相同 localEndPoint 的 UDP c# 套接字？

Question

I wrote a TCP client/server code that works fine. a TCP socket listener accept connections and create many sockets with same localEndPoint and various RemoteEndPoint. now I like to expand to UDP but I have a problem in seerver code. i must bind UDP socket to a localEndPoint for each client object. but I encounter an error: I can't bind multiple UDP sockets with same localEndPoint. I found that is nature of UDP sockets according to Wiki :

A UDP server does not create new child processes for every concurrently served client, but the same process handles incoming data packets from all remote clients sequentially through the same socket. It implies that UDP sockets are not identified by the remote address, but only by the local address, although each message has an associated remote address.

so can I create a distinct UDP socket for each Client like I do for TCP sockets?
note: please explain with socket class if possible not UDPClient class.

    private void SocketAsyncEventArgs_Completed(object sender, SocketAsyncEventArgs e)
    {
        if (e.SocketError == SocketError.Success)
        {
            switch (e.LastOperation)
            {
                case SocketAsyncOperation.Accept:
                case SocketAsyncOperation.Connect:
                    UDP.Bind(TCP.LocalEndPoint);

code explanation: I thought I can bind a UDP socket in both sides (client/server) after establishing TCP connection (connect/accept). it is fine for only one client on server. for new clients server throws an Exception because it can't bind multiple sockets with one localEndPoint . and clients can be more than all available ports. so i can't bind a UDP socket to a distinct localEndPoint for each client.
I knew that i can create a unique UDP socket and pass receiving messages to respective client object on server but its a bit nasty. thanks!

Answer 1

You could run a Task per unique source IP:Port combination. This would allow you to easily maintain a state machine for each unique incoming source IP:PORT combination. System.IO.Pipelines makes it really easy to tie this together.

First set up a UDPListener Task that kind of mimics a TCPListener , for each new IP:PORT spin up a Task to process that port, create a Pipe and eveytime data comes from that IPEndpoint, put the data into the PipeWriter

    static async Task StartUdpListener()
    {
        // Use a Dictionary to match packets from given connections to give Pipes
        ConcurrentDictionary<string, Pipe> connections = new ConcurrentDictionary<string, Pipe>();

        var udpServer = new UdpClient(new IPEndPoint(IPAddress.Any, 33000));
        while (true)
        {
            // Wait for some data to arrive
            var result = await udpServer.ReceiveAsync();

            if(connections.ContainsKey(result.RemoteEndPoint.ToString()))
            {
                // If we have seen this IPEndpoint before send the traffic to the pipe
                // the task associated with that Pipe willpick the traffic up
                connections.TryGetValue(result.RemoteEndPoint.ToString(), out var p);
                await p.Writer.WriteAsync(result.Buffer);
            }
            else
            {
                // If we have not seen it, make the pipe, stick the data in the pipe
                // and spin up a task to Read/Process the data
                var p = new Pipe();
                connections.TryAdd(result.RemoteEndPoint.ToString(), p);
                await p.Writer.WriteAsync(result.Buffer);
                _ = Task.Run(() => UdpServerClient(result.RemoteEndPoint.ToString(), p));
            }
        }
    }

That's a simplistic view of what the kernel does when it receives a TCPPacket, it sticks it in a socket buffer for you to read via a stream.

A UDP Server Client task would look something like this:

    static async Task UdpServerClient(string serverName,Pipe p)
    {
        while (true)
        {
            var readResult = await p.Reader.ReadAsync();
            var message = Encoding.ASCII.GetString(readResult.Buffer.FirstSpan.ToArray());
            Console.WriteLine($"Server: {serverName} Received: {message}");
            p.Reader.AdvanceTo(readResult.Buffer.End);
        }
    }

And for completeness, a few clients, these would normally be on different machines, but for the sake of simplicity we'll run them as Tasks.

    static async Task UdpClientClient(string messageToSend)
    {
        var client = new UdpClient();
        client.Connect("127.0.0.1", 33000);
        for(var i=0;i<5;i++)
        {
            var message = ASCIIEncoding.ASCII.GetBytes(messageToSend + " #"+ i.ToString());
            await client.SendAsync(message, message.Length);
            await Task.Delay(1000);
        }
    }
}

Link them all together:

    static async Task Main(string[] args)
    {
        _ = Task.Run(() => StartUdpListener());

        _ = UdpClientClient("hi Server!");
        _ = UdpClientClient("I am here server...");
        await UdpClientClient("Me too server!");
    }

And you get this:

Server: 127.0.0.1:53183 Received: Me too server! #0
Server: 127.0.0.1:53182 Received: I am here server... #0
Server: 127.0.0.1:53181 Received: hi Server! #0
Server: 127.0.0.1:53182 Received: I am here server... #1
Server: 127.0.0.1:53183 Received: Me too server! #1
Server: 127.0.0.1:53181 Received: hi Server! #1
Server: 127.0.0.1:53182 Received: I am here server... #2
Server: 127.0.0.1:53183 Received: Me too server! #2
Server: 127.0.0.1:53181 Received: hi Server! #2
Server: 127.0.0.1:53182 Received: I am here server... #3
Server: 127.0.0.1:53181 Received: hi Server! #3
Server: 127.0.0.1:53183 Received: Me too server! #3
Server: 127.0.0.1:53183 Received: Me too server! #4
Server: 127.0.0.1:53181 Received: hi Server! #4
Server: 127.0.0.1:53182 Received: I am here server... #4

Of course you need error checking, seeing if the client is still there etc.