了解 C# 控制台 TCP 服务器的异步行为

Question

我想在 .NET Core 2.0 中使用 async/await 方法使用异步（因为据我了解，它比生成线程更合理）（因为我相信它比具有IAsyncResult 和*Begin/*End 方法的那个）。

我编写了这个小型服务器，它接受来自客户端的新连接，然后开始向它们发送 100 条消息（它们之间有 1 秒的延迟）。

主要问题是：

如果我没有产生新线程，那么服务器如何继续向多个客户端发送延迟消息，而实际上它是“等待连接”？ 是否涉及任何隐藏的低级信号/事件，或者真的只是新线程？

第二个问题是：

如果我没有使用这个全新的 async Main 语法糖并且我没有“等待”发送消息的 async 任务——我是否正确使用了异步？

class Program
{
    public static void Main(string[] args)
    {
        StartServer();
    }

    public static void StartServer()
    {
        IPAddress localhost = IPAddress.Parse("127.0.0.1");
        TcpListener listener = new TcpListener(localhost, 5567);

        Console.WriteLine($"Starting listening on {listener.Server.LocalEndPoint}");
        listener.Start();
        while (true)
        {
            Console.WriteLine("Waiting for connection...");
            var client = listener.AcceptTcpClient(); // synchronous
            Console.WriteLine($"Connected with {client.Client.RemoteEndPoint}!");

            Console.WriteLine("Starting sending messages...");
            SendHundredMessages(client); // not awaited -- StartServer is not async
        }
    }


    public static async Task SendHundredMessages(TcpClient client)
    {
        var stream = client.GetStream();

        for (int i=0; i<100; i++)
        {
            var msg = Encoding.UTF8.GetBytes($"Message no #{i}\n");
            await stream.WriteAsync(msg, 0, msg.Length);    // returning back to caller?

            await Task.Delay(1000);     // and what about here?
        }
        client.Close();
    }
}

原代码和下面的版本有什么区别？ async Main 有什么不同？

class Program
{
    public static async Task Main(string[] args)
    {
        await StartServer();
    }

    public static async Task StartServer()
    {
        IPAddress localhost = IPAddress.Parse("127.0.0.1");
        TcpListener listener = new TcpListener(localhost, 5567);

        Console.WriteLine($"Starting listening on {listener.Server.LocalEndPoint}");
        listener.Start();
        while (true)
        {
            Console.WriteLine("Waiting for connection...");
            var client = await listener.AcceptTcpClientAsync(); // does it make any difference when done asynchronously?
            Console.WriteLine($"Connected with {client.Client.RemoteEndPoint}!");

            Console.WriteLine("Starting sending messages...");
            SendHundredMessages(client); // cannot await here, because it blocks next connections
        }
    }


    public static async Task SendHundredMessages(TcpClient client)
    {
        var stream = client.GetStream();

        for (int i=0; i<100; i++)
        {
            var msg = Encoding.UTF8.GetBytes($"Message no #{i}\n");
            var result = stream.WriteAsync(msg, 0, msg.Length);

            await Task.Delay(1000);
            await result;
        }
        client.Close();
    }
}

Answer 1

主要问题的答案：

在后台，对象通常使用一些 api（windows 的 winapi）。这些 api 可以不同地实现异步。例如，事件（winapi 事件）或回调。所以答案是肯定的——存在隐藏的信号或线程。例如，您可以看到 Ping 类。 Ping.InternalSend 使用 ThreadPool.RegisterWaitForSingleObject 来完成异步任务。

关于 async Main 的答案：

在您的第一个代码中，因为 StartServer 不是异步的，所以 Main 方法在您的“接受”周期结束之前不会重新获得控制权。

在您的第二个代码中，Main 方法将重新获得控制权，然后调用 listener.AcceptTcpClientAsync。但是因为您使用await StartServer();，所以 Main 方法将等到StartServer 结束。

一些代码解释：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace TestConsole
{
    class Program
    {
        static void Main(string[] args)
        {   
            // not await for exploration
            var task = StartServer();

            Console.WriteLine("Main StartServer finished");
            task.Wait();
            Console.WriteLine("task.Wait() finished");
            Console.ReadKey();
        }        

        static async Task StartServer()
        {
            Console.WriteLine("StartServer enter");

            for(int i = 0; i < 3; i++) {
                await Task.Delay(1000); // listener.AcceptTcpClientAsync simulation
                SendHundredMessages();
            }

            Console.WriteLine("StartServer exit");
        }

        static async Task SendHundredMessages()
        {
            Console.WriteLine("SendHundredMessages enter");

            await Task.Run(() => {
                Thread.Sleep(2000);
            });

            Console.WriteLine("SendHundredMessages exit");
        }        
    }
}

此代码生成此输出：

StartServer进入
主 StartServer 完成
SendHundredMessages 输入
SendHundredMessages 输入
SendHundredMessages 退出
SendHundredMessages 输入
启动服务器退出
task.Wait() 完成
SendHundredMessages 退出
SendHundredMessages 退出

如您所见，Main 方法在第一个 Task.Delay 之后继续执行。

警告：

你不等待SendHundredMessages 的结束，这很糟糕。在示例输出中，您可以看到“task.Wait() 完成”之后的“SendHundredMessages ending”。在示例应用中当然没有危险，但在实际项目中可能会遇到大问题。