c# - TcpClient 仅在服务器在调用 ConnectAsync 之前开始监听时才连接

Question

我有一个基本的 TCP 客户端和服务器，它们都在我的机器上本地运行。

如果当我调用 ConnectAsync() 时服务器已经在监听，那么客户端连接到服务器，没问题。

如果我启动客户端并调用 ConnectAsync()，那么在监听客户端之后启动服务器，它不会建立连接。 ConnectAsync 挂起约 85 秒，然后出现以下错误:System.Net.Sockets.SocketException (0x80004005): Connection denied。尽管服务器已经开始监听这一事实。

不确定这是否会影响 TcpClient，但客户端正在 Xamarin 项目中运行。

这是我的代码:

客户:

public static class DataSource
{
    private static TcpClient client;
    private static NetworkStream networkStream;

    public static bool Connected => client is null ? false : client.Connected;

    public static async Task EstablishTcpConnection(string serverIP, int port)
    {
        CloseTcpConnection();

        try
        {
            client = new TcpClient();
            await client.ConnectAsync(IPAddress.Parse(serverIP), port);
            networkStream = client.GetStream();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{nameof(EstablishTcpConnection)} Error: {ex}");
        }
    }

    public static void CloseTcpConnection()
    {
        if (networkStream != null)
        {
            networkStream.Close();
            networkStream.Dispose();
            networkStream = null;
        }

        if (client != null)
        {
            client.Close();
            client.Dispose();
            client = null;
        }
    }

    public static async Task SendTcp(string toSend)
    {
        if (client is null) return;
        if (networkStream is null) return;
        if (!Connected) return;

        if (networkStream != null && networkStream.CanWrite)
        {
            byte[] bytesToSend = ASCIIEncoding.ASCII.GetBytes(toSend);
            await networkStream.WriteAsync(bytesToSend, 0, bytesToSend.Length);
        }
    }

    public static async Task TcpListener()
    {
        while (networkStream != null && networkStream.CanRead)
        {
            if (client is null) return;
            if (networkStream is null) return;
            if (!Connected) return;

            byte[] bytesToRead = new byte[client.ReceiveBufferSize];
            int bytesRead = await networkStream.ReadAsync(bytesToRead, 0, client.ReceiveBufferSize);
            string received = Encoding.ASCII.GetString(bytesToRead, 0, bytesRead);
            Console.WriteLine($"Received: {received}");
        }
    }
}

服务器:

internal class Program
{
    private const string serverIP = "MyServerIp";
    private const int port = myPort;

    private static void Main(string[] args)
    {
        Listener();
        Console.ReadLine();
    }

    public static async Task Listener()
    {
        //---listen at the specified IP and port no.---
        TcpListener listener = new TcpListener(IPAddress.Parse(serverIP), port);
        listener.Start();
        Console.WriteLine("Listening...");

        while (true)
        {
            //---incoming client connected---
            ReceiveClient(await listener.AcceptTcpClientAsync());
        }
    }

    public static async Task ReceiveClient(TcpClient client)
    {
        if (client is null) return;
        Console.WriteLine("Client Connected");

        //---get the incoming data through a network stream---
        NetworkStream networkStream = client.GetStream();
        byte[] buffer = new byte[client.ReceiveBufferSize];

        while (client != null && client.Connected)
        {
            //---read incoming stream---
            int bytesRead = await networkStream.ReadAsync(buffer, 0, client.ReceiveBufferSize);
            if (bytesRead == 0) break;

            //---convert the data received into a string---
            string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received : " + dataReceived);

            //---write back the text to the client---
            Console.WriteLine("Sending back : " + dataReceived);
            networkStream.Write(buffer, 0, bytesRead);
        }

        client.Close();
        client.Dispose();
        Console.WriteLine("Client Disconnected");
    }
}

Answer 1

Surely ConnectAsync() should still work, even if the server starts listening after and is within the timeout?

不;这不是“超时”的意思。 “超时”并不意味着“重试”。

当您建立连接时，您的客户端应用程序将与在服务器计算机上运行的服务器应用程序联系。 “超时”只是客户端应用程序等待响应的时间。如果服务器计算机正在运行，但没有用于该端口的监听服务器应用程序，则服务器计算机将立即发送响应，指示没有服务器应用程序在运行。这将被发送回您的客户端应用程序。这是一个有效的“响应”，因此超时不会起作用。

如果您想重试连接，等待服务器，那么您需要自己编写该逻辑。