What is the difference between TCP and UDP? When would you choose each, and why does HTTP/3 run over UDP?

1. TCP connection lifecycle

Client                         Server
  │── SYN seq=x ───────────────────► │  LISTEN
  │◄── SYN-ACK seq=y ack=x+1 ────────│
  │── ACK ack=y+1 ──────────────────► │  ESTABLISHED
  │── data ─────────────────────────► │
  │◄── ACK ───────────────────────── │
  │── FIN ─────────────────────────► │  (graceful close, TIME_WAIT on the closer)

2. How TCP stays reliable and fair

• Sequence numbers + ACKs: the sender retransmits unacknowledged data after a timeout or duplicate ACKs.
• Flow control: the receiver advertises a window (how much it can buffer), so a fast sender cannot overwhelm a slow reader.
• Congestion control (CUBIC, BBR): the sender starts slowly and backs off on loss, sharing the network fairly.
• Nagle's algorithm combines small writes; it adds latency for chatty protocols. Socket.NoDelay = true disables it (Kestrel and HttpClient already do this).

3. TCP is a stream, not messages

sender: Send("HELLO") Send("WORLD")
receiver may get: "HELLOWOR" then "LD"   or   "HELLOWORLD"   or  "HEL" "LOWORLD"

Your protocol must frame messages (length prefix or delimiter). HTTP, gRPC and WebSockets do this for you.

4. UDP realities

• Max datagram is 65,507 bytes, but anything over the path MTU (~1,472 bytes of payload on Ethernet) is fragmented, and losing one fragment loses the datagram. Keep datagrams small.
• No congestion control: blasting UDP can hurt other traffic and get rate-limited.
• Firewalls often block or time out UDP flows faster than TCP.
• DNS uses UDP for small queries and falls back to TCP for large answers.

5. HTTP/3 in .NET

• Kestrel and HttpClient support HTTP/3 via System.Net.Quic, which uses msquic (built into Windows 11 / Server 2022; on Linux install the libmsquic package).
• Clients discover HTTP/3 through the Alt-Svc header, then try QUIC on UDP 443, falling back to HTTP/2 if UDP is blocked.
• HttpClient needs request.Version = HttpVersion.Version30 and a version policy to try it.

6. Try it yourself

1. Start a UdpClient listener and send 1,000 numbered datagrams from another app over Wi-Fi; count how many arrive and whether order changes.
2. Do the same over TCP and note it always arrives complete and ordered.
3. Capture both in Wireshark and compare handshakes and headers.
4. curl --http3 -I https://cloudflare.com (curl built with HTTP/3) and inspect the alt-svc header with curl -I.

// UDP: fire-and-forget metric (StatsD-style). No connection, no delivery guarantee.
using var udp = new UdpClient();
udp.Connect("metrics.internal", 8125);          // sets default remote; no handshake
byte[] payload = Encoding.ASCII.GetBytes("orders.created:1|c");
await udp.SendAsync(payload);                   // returns immediately even if nobody is listening

// TCP: framed messages over a stream (length prefix), because TCP has no message boundaries
using var client = new TcpClient { NoDelay = true };
await client.ConnectAsync("ledger.internal", 9000, ct);
await using var stream = client.GetStream();

static async Task SendMessageAsync(Stream s, ReadOnlyMemory<byte> body, CancellationToken ct)
{
    var header = new byte[4];
    BinaryPrimitives.WriteInt32BigEndian(header, body.Length);
    await s.WriteAsync(header, ct);
    await s.WriteAsync(body, ct);
}

static async Task<byte[]> ReadMessageAsync(Stream s, CancellationToken ct)
{
    var header = new byte[4];
    await s.ReadExactlyAsync(header, ct);
    var body = new byte[BinaryPrimitives.ReadInt32BigEndian(header)];
    await s.ReadExactlyAsync(body, ct);
    return body;
}

// HttpClient trying HTTP/3 with fallback
using var http = new HttpClient
{
    DefaultRequestVersion = HttpVersion.Version30,
    DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrLower
};
using var response = await http.GetAsync("https://example.com/", ct);
Console.WriteLine(response.Version); // 3.0 if QUIC worked, else 2.0 or 1.1