receiver

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

class Program
{
    static async Task Main(string[] args)
    {
        // Initialize UDP client
        using var udpClient = new UdpClient(11000); // Listening on port 11000
        Console.WriteLine("UDP server started on port 11000. Waiting for messages...");

        try
        {
            while (true)
            {
                // Receive message
                var result = await udpClient.ReceiveAsync();
                
                // Process each request in parallel without awaiting
                _ = ProcessMessageAsync(udpClient, result)
                    .ContinueWith(t => 
                    {
                        if (t.IsFaulted)
                            Console.WriteLine($"Error processing message: {t.Exception}");
                    });
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"An error occurred: {e.Message}");
        }
        finally
        {
            udpClient.Close();
        }
    }

    private static async Task ProcessMessageAsync(UdpClient udpClient, UdpReceiveResult result)
    {
        var message = Encoding.UTF8.GetString(result.Buffer);
        Console.WriteLine($"Received message from {result.RemoteEndPoint}: {message}");

        // Create random delay
        var random = new Random();
        int delayMs = random.Next(0, 3000);
        Console.WriteLine($"Waiting for {delayMs}ms before responding...");
        
        // Wait for random delay
        await Task.Delay(delayMs);

        // Prepare and send response
        string response = $"Received '{message}' - Responded after {delayMs}ms delay";
        byte[] responseData = Encoding.UTF8.GetBytes(response);
        await udpClient.SendAsync(responseData, responseData.Length, result.RemoteEndPoint);
        
        Console.WriteLine($"Sent response to {result.RemoteEndPoint}");
    }
}

sender

using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Text;

public class Counter {
    public int Value = 0;
}

class Program
{
    static async Task Main(string[] args)
    {
        var tasks = new List<Task>();
        var counter = new Counter();
        var maxConcurrentTasks = 10000; // Adjust this number based on your system's capabilities
        var semaphore = new SemaphoreSlim(maxConcurrentTasks);

        _ = Task.Run(async () =>
        {
            while (true)
            {
                await Task.Delay(1000);
                var current = Interlocked.Exchange(ref counter.Value, 0);
                Console.WriteLine($"[{DateTime.Now:HH:mm:ss:ffff}] Requests per second: {current}");
            }
        });

        for(var i = 0; i < 100000; i++)
        {
            tasks.Add(ProcessMessage());
        }

        async Task ProcessMessage()
        {
            await semaphore.WaitAsync();
            try
            {
                await SendUdpMessage(1000, counter);
            }
            finally
            {
                semaphore.Release();
            }
        }

        await Task.WhenAll(tasks);
    }

    static async Task SendUdpMessage(int timeout, Counter counter) {
        var udpClient = new UdpClient();
        var serverEndpoint = new IPEndPoint(IPAddress.Loopback, 11000);

        while(true) {
            byte[] messageData = Encoding.UTF8.GetBytes("qwe");
            await udpClient.SendAsync(messageData, messageData.Length, serverEndpoint);
            var stopwatch = new Stopwatch();

            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2)); // 6 seconds timeout

            stopwatch.Start();
            var receiveTask = Task.Run(async () =>
            {
                var result = await udpClient.ReceiveAsync(cts.Token);
                return result;
            });

            try
            {
                var result = await receiveTask;
                string response = Encoding.UTF8.GetString(result.Buffer);
                // Console.WriteLine($"[{DateTime.Now:HH:mm:ss:ffff}] Received response: {response}");
                Interlocked.Increment(ref counter.Value);
            }
            catch (OperationCanceledException)
            {
                // Console.WriteLine($"[{DateTime.Now:HH:mm:ss:ffff}] No response received within timeout period.");
                udpClient.Close();
                udpClient = new UdpClient();
            }
            var elapsed = stopwatch.ElapsedMilliseconds;

            if (elapsed < timeout)
                await Task.Delay(timeout - (int)elapsed);
        }
    }
}