重用UdpClient还是丢弃它

Question

我正在创建一个聊天应用程序，其中用户在路由器（NAT）后面。所以主要问题是向这些客户端发送消息。服务器接收消息没有问题。

>

UdpServer侦听来自客户端A

的udp数据包

服务器从客户端A接收数据包并回复数据包以打开NAT

服务器现在变成了客户端（服务器不断向客户端A发送数据包，客户端回复服务器，通知它收到了他的消息）现在NAT打开了，我将客户端和服务器反转。这是因为客户端A总是可以通过tcp向服务器发送消息。

如果Server看到客户端A没有回复其不断发送的数据包，则将客户端A标记为已断开连接并停止发送数据包。

// class that holds infor about client
class ClientBehindNat
{
     public IPEndPoint EndpointListening;
     public string Id;
}

侦听新客户端（连接）的线程：

while(true)
{
    IPEndPoint ep = new IPEndPoint(IPAddress.Any, 1234);
    // create a new udpServer
    using(var udpServer = new UdpClient())
    {
        // allow reusing port 1234
        udpServer.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        // wait to receive data
        var data = udpServer.Receive(ref ep);

        // analyze data make sure it is reliable....

        // maybe data is a reply from a client 
        if(data.IsReply())
        {
             // mark that client replied
             // ....
             continue;
        }
        else
        {
            // save new client
            ConnectedClients.Add(new ClientBehindNat(){EndpointListening=ep});
        }

        udpServer.Connect(ep);
        udpServer.Send( // data notifying client that we got his message)

    }
}

不断向客户端发送udp数据包以保持nat打开的线程

// send packets every 15 seconds in order to leave nat open
timer.elapsed += (a,b)=> {

    foreach (var c in connectedClients)
    {
        // create a copy of udp server so that client can get our response
        using (var copySocket = new UdpClient())
        {
            // allow reusing port 1234
            copySocket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            copySocket.Client.Bind(new IPEndPoint(IPAddress.Any, 1234));
            // log that we will send this request
            // Requests[someId] = ....

            // send it
            copySocket.Send(someData, someData.Length, c.EndpointListening);

            // first thread should be responsible for receiving this response

            // dispose this client                            
        }          
    }
}

一切都很好，但为每个请求创建一个新的Socket（UdpClient）是不是很糟糕？如果我收到100个请求，我会创建100个新套接字并处理所有这些请求。当我尝试重用udp客户端更新其endpoint时，我遇到了一个异常。我经常需要向Client a或Client Z发送消息，这就是我存储其endpoint以了解如何访问它的原因。如何重用udpClient更新其endpoint，以便能够访问我感兴趣的客户端？

Answer 1

发现问题了。当我回复客户时，我得到的回复是这样的:

udpServer.Connect(ep); // <---------------- this was the problem
udpServer.Send(someData);

如果我从不连接并使用@Sourush声明的 SneTo 方法，它使我能够继续侦听数据包。因此，现在我有：

udpServer.Client.SentTo(data, ep)

Answer 2

我应该再次推荐直接使用< code>Socket,它给了你很大的灵活性。看看下面的例子，它使用一个套接字进行发送和接收UDP连接:

    private static readonly List<EndPoint> clients = new List<EndPoint>();
    private static readonly SocketAsyncEventArgs receiveEventArgs = new SocketAsyncEventArgs();
    private static Socket socket;

    private static void Main(string[] args)
    {
        receiveEventArgs.Completed += OnReceive;
        socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        socket.Bind(new IPEndPoint(IPAddress.Any, 6000));
        Receive();

        while (true)
        {
            Thread.Sleep(3000);
            lock (clients)
            {
                foreach (var endPoint in clients)
                    socket.SendTo(Encoding.ASCII.GetBytes("PING"), endPoint);
            }
        }
    }

    private static void Receive()
    {
        receiveEventArgs.SetBuffer(new byte[256], 0, 256);
        receiveEventArgs.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 6000);
        socket.ReceiveFromAsync(receiveEventArgs);
    }

    private static void OnReceive(object sender, SocketAsyncEventArgs e)
    {
        if (e.BytesTransferred > 0)
        {
            // Is reply?
            var isReply = true/false;
            if (isReply)
            {
                // Do domething
            }
            else
                lock (clients)
                {
                    clients.Add(e.RemoteEndPoint);
                }
        }
        else
        {
            lock (clients)
            {
                clients.Remove(e.RemoteEndPoint);
            }
        }
        Receive();
    }