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

Question

I want to create a simple TCP server in .NET Core 2.0 using asynchrony (because from what I understand, it's more reasonable than spawning threads) with the async/await approach (because I believe it's more up-to-date than the one with IAsyncResult and *Begin/*End methods).

I've written this small server that accepts new connections from clients and then begins to send them 100 messages (with a 1s delay between them).

The main question is:

If I'm not spawning new threads, then how the server continues to send delayed messages to several clients, when in fact it's "waiting for connection" ? Are there any hidden low-level signals/events involved, or are there really just new threads?

The second question is:

If I'm not using this brand new async Main syntax sugar and I'm not "awaiting" the async task of sending the messages -- am I using the asynchrony correctly?

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();
    }
}

What is the difference between the original code and the version below? What difference does async Main make?

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

The answer to the main question:

In the background, as a rule, objects work with some api(winapi for windows). These api can implement asynchrony differently. For example, events(winapi events) or callbacks. So the answer is yes - there are hidden signals or threads. For example, you can see the Ping class. Ping.InternalSend using ThreadPool.RegisterWaitForSingleObject for the task of asynchrony.

The answer about async Main:

In your first code because StartServer is not async the Main method will not get back control until your "accept" cycle ends.

In your second code, the Main method will get back control then listener.AcceptTcpClientAsync invoked. But because you using await StartServer(); the Main method will be wait until StartServer ends.

Some code for to explain:

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");
        }        
    }
}

This code generate this output:

StartServer enter
Main StartServer finished
SendHundredMessages enter
SendHundredMessages enter
SendHundredMessages exit
SendHundredMessages enter
StartServer exit
task.Wait() finished
SendHundredMessages exit
SendHundredMessages exit

As you can see, the Main method continued execution right after first Task.Delay .

A warning:

You do not wait end of SendHundredMessages , and this is very bad. In example output you can see that " SendHundredMessages ending " after " task.Wait() finished ". In example application of course it not danger, but in real project you can get big problem.