Wie kann ich sicherstellen, dass der Rückruf von UDPClient Receive die Nachricht in einem separaten Thread verarbeitet?

Question

Ich versuche herauszufinden, wie der UDPClient empfangen Rückruf von der Verarbeitung der empfangenen Nachricht zu trennen. Aufgrund der hohen Anzahl von eingehenden UDP-Nachrichten möchten wir die eigentliche Verarbeitung der Nachricht in einen anderen Thread verlagern, in der Hoffnung, dem UDP-Client Gewicht zu geben und keine der eingehenden Nachrichten zu verpassen. (200 Nachrichten/Sekunde)

Tritt der AsyncCallBack in demselben Thread auf, in dem sich der UDPClient befindet, oder in einem neuen Thread? Wenn es im selben Thread ist, würde ich, wenn ich einen neuen Thread innerhalb des Callbacks erstelle, einen separaten Thread pro Nachricht erstellen, der nicht funktionieren würde. Wenn der AsyncCallback im selben Thread wie die Verbindung ist, dann denke ich, müsste ich irgendwie einen Thread erstellen, bevor ich die Verbindung herstelle, und dann für jede empfangene Nachricht etwas in diesem Thread aufrufen?

Private Sub OpenConnection() 
    _ipendpoint = New IPEndPoint(IPAddress.Any, _configobj.port) 
    _udpclient = New UdpClient(_ipendpoint) 
    _udpclient.BeginReceive(New AsyncCallback(AddressOf ReceiveCallback), Nothing) 
End Sub 

Private Sub ReceiveCallback(ar As IAsyncResult) 
    Dim bytes As Byte() = _udpclient.EndReceive(ar, _ipendpoint) 
    _udpclient.BeginReceive(New AsyncCallback(AddressOf ReceiveCallback), Nothing) 
    ProcessReceived(bytes) 
End Sub 

Private Sub ProcessReceived(bytes() As Byte) 
    Dim rcv As String = Encoding.ASCII.GetString(bytes).Trim() 
    'PROCESS MESSAGE ON DIFFERENT THREAD 
End Sub 

Answer 1

Sie verkomplizieren die Dinge ein wenig. 200 Nachrichten pro Sekunde sind nichts.

Zunächst müssen Sie eine Leseschleife:

while (true) { 
var result = udpClient.Receive(...); 
Task.Run(() => ProcessPacketAsync(result)); 
} 

Das ist alles was man braucht. Sie müssen ProcessPacketAsync implementieren. Abhängig von dieser Funktion müssen Sie Async-IO verwenden. Oft reicht eine synchrone IO aus. Der Hauptgrund für die Verwendung von asynchronem IO ist das Speichern von Threads, wenn eine große Anzahl gleichzeitiger Operationen ausgeführt wird.

Sie haben gefragt, auf welchen Threads diese Dinge laufen. Das ist egal, aber die Antwort ist: Auf einigen Thread-Pool-Thread.