1open System
2open System.Net
3open System.Net.Sockets
4open System.Text
5open System.Threading
6
7let startReceiver (port: int) (token: CancellationToken) =
8    async {
9        use udp = new UdpClient(port)
10        while not token.IsCancellationRequested do
11            let! result = udp.ReceiveAsync() |> Async.AwaitTask
12            let text = Encoding.UTF8.GetString(result.Buffer)
13            printfn "Received from %A: %s" result.RemoteEndPoint text
14    }
15
16let sendMessage (host: string) (port: int) (message: string) =
17    async {
18        use udp = new UdpClient()
19        let bytes = Encoding.UTF8.GetBytes(message)
20        let endpoint = IPEndPoint(IPAddress.Parse(host), port)
21        let! _ = udp.SendAsync(bytes, bytes.Length, endpoint) |> Async.AwaitTask
22        return ()
23    }
24
25[<EntryPoint>]
26let main _ =
27    use cts = new CancellationTokenSource()
28    let receiver = startReceiver 9000 cts.Token |> Async.StartAsTask
29
30    sendMessage "127.0.0.1" 9000 "ping from sender"
31|> Async.RunSynchronously Thread.Sleep(500) cts.Cancel() receiver.Wait() 0 ``` This design keeps each operation focused. `startReceiver` does not care where packets come from, and `sendMessage` does not know who receives them. That separation makes testing and reuse easier. ## Coordinating Lifetime and Throughput In production, you often run multiple senders and one receiver per service instance. Add a simple message envelope with timestamp and message type so you can debug packet flow. For higher throughput, decode quickly in the receive loop and push heavy processing to another queue. Also consider socket options and buffer sizes when traffic spikes. Defaults may be too small for bursty workloads. Measure packet loss under realistic load, then tune receive buffer size and application level retry rules. ```fsharp // Example envelope structure represented as plain text let formatEnvelope msgType payload = let ts = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() sprintf "%d|%s|%s" ts msgType payload let parseEnvelope (line: string) = let parts = line.Split('|') if parts.Length <> 3 then None else Some(parts.[0], parts.[1], parts.[2]) ``` A small envelope like this can save hours when diagnosing duplicate packets, late packets, or malformed payloads. ## Testing UDP Flows Locally You can validate most UDP behavior on a local machine before deploying to shared environments. Start two processes, one receiver and one sender, then script bursts of messages with sequence numbers. This gives quick feedback on parsing errors, dropped packets, and ordering assumptions. Even though localhost is more stable than real networks, it is still useful for proving that your async loops, cancellation, and message format work as expected. A simple reliability test is to send one hundred numbered datagrams and count what arrives. If counts diverge, add logging for receive timestamp and sequence number so you can isolate where data disappears. ```fsharp let sendBurst host port count = async { for i in 1 .. count do do! sendMessage host port (sprintf "seq=%d" i) } sendBurst "127.0.0.1" 9000 100 |> Async.RunSynchronously ``` Once this baseline is stable, move the same test into CI by asserting that your parser accepts valid packets and rejects malformed ones without throwing unhandled exceptions. ## Common Pitfalls * Assuming UDP guarantees delivery or ordering, then building logic that fails under packet loss. * Forgetting cancellation wiring, which leaves orphaned receive tasks during shutdown. * Doing expensive parsing directly in the receive loop and falling behind under load. * Recreating sockets per packet in hot paths, which adds avoidable overhead. * Ignoring malformed payload handling, causing crashes on unexpected input. ## Summary * Use `UdpClient` with F sharp async workflows for clear non blocking code. * Keep receive, send, and shutdown logic separate. * Add cancellation so services stop cleanly. * Use lightweight envelopes for observability. * Treat reliability as an application concern when using UDP.