C# TCP客户端重连后无法发消息，监听器收不到数据问题

Hey there! Let's break down the most likely issues causing your TCP listener to miss data after a client reconnects—this is super common when you're new to TCP/IP, so let's work through it step by step.

1. Your Server Isn't Accepting New Connections After the First One #

TCP listeners (TcpListener) only accept one connection per call to AcceptTcpClient() or BeginAcceptTcpClient(). If your server code only calls this method once at startup, it'll never pick up the reconnection request from your client. Instead, it's still holding onto the old (disconnected) client session.

Fix: Add a Loop to Continuously Listen for New Connections #

You need to wrap your connection acceptance logic in a loop, and spin up a separate thread/Task to handle each client's communication (so the listener doesn't get blocked):

// Server-side example
var listener = new TcpListener(IPAddress.Any, 1234);
listener.Start();
Console.WriteLine("Listening for connections...");

// Keep accepting new connections indefinitely
while (true)
{
    // Wait for a new client to connect
    var client = listener.AcceptTcpClient();
    Console.WriteLine("New client connected!");
    
    // Handle communication in a background task so the listener can keep accepting
    Task.Run(() => HandleClient(client));
}

// Helper method to handle client communication
private static void HandleClient(TcpClient client)
{
    using (client) // Auto-dispose when done
    using (var stream = client.GetStream())
    {
        var buffer = new byte[1024];
        int bytesRead;
        
        try
        {
            // Read data until the client disconnects (Read returns 0)
            while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
            {
                var receivedMessage = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                Console.WriteLine($"Received: {receivedMessage}");
            }
        }
        catch (IOException ex)
        {
            // Client disconnected abruptly—log this if needed
            Console.WriteLine($"Client disconnected unexpectedly: {ex.Message}");
        }
        
        Console.WriteLine("Client session closed.");
    }
}

2. Your Client Isn't Creating a New TcpClient Instance on Reconnection #

If your client tries to reuse the old TcpClient object after it's disconnected, that instance is already in a closed state and won't work for a new connection. You need to dispose of the old instance and create a fresh one each time you reconnect.

Fix: Reset Client Resources Before Reconnecting #

Update your TcpMessageSender class to properly clean up old connections and initialize new ones:

public class TcpMessageSender : MessageSender
{
    private TcpClient _tcpClient;
    private NetworkStream _stream;

    public async Task ConnectAsync(string serverIp, int port)
    {
        // First, clean up any existing disconnected resources
        Disconnect();
        
        // Create a fresh TcpClient for the new connection
        _tcpClient = new TcpClient();
        await _tcpClient.ConnectAsync(serverIp, port);
        _stream = _tcpClient.GetStream();
        Console.WriteLine("Connected to server!");
    }

    public void Disconnect()
    {
        // Safely close and dispose of old resources
        _stream?.Close();
        _tcpClient?.Close();
        _stream = null;
        _tcpClient = null;
    }

    public async Task SendMessageAsync(string message)
    {
        if (_tcpClient == null || !_tcpClient.Connected)
        {
            throw new InvalidOperationException("Not connected to the server—call ConnectAsync first.");
        }

        var data = Encoding.UTF8.GetBytes(message);
        await _stream.WriteAsync(data, 0, data.Length);
    }
}

3. Your Server Isn't Detecting the Old Client Disconnection #

TCP doesn't immediately notify the server when a client disconnects unless the server tries to read/write to the stream. If your server is stuck waiting on a read from the old disconnected client, it won't get around to handling new connections.

Fix: Properly Handle Disconnection in Server Logic #

As shown in the server example above, check the return value of stream.Read()—if it returns 0, that means the client closed the connection gracefully. Catch IOException for abrupt disconnections, and make sure to exit the client handling loop so the server can get back to listening for new connections.

Quick Checks to Rule Out Other Issues #

• Verify Client Connection Status: After reconnecting, check _tcpClient.Connected in your client code to ensure the connection actually succeeded.
• Check Firewall/Network: Ensure the server port is open and there's no firewall blocking the reconnection traffic (though this is less likely if you don't see connection errors).

Start with checking the server's connection acceptance loop first—this is the most common culprit for this exact issue.

内容的提问来源于stack exchange，提问作者Benjabee