C#并发编程之async和await关键字详解

static void Main(string[] args) // 由于 Main 方法不支持 async，所以只能通过 AsyncTask() 来调用异步方法
{
    Console.WriteLine("--开始!");
    Console.WriteLine($"--下面我（主线程）先通知下儿子（子线程）也开始。 我的 ID：{Thread.CurrentThread.ManagedThreadId}");
    // 调用 async 修饰的方法，也就是异步执行的方法
    AsyncTask(); // 异步方法，不占用主线程，是另新创建的新的子线程
    Console.WriteLine("--我（主线程）已经让我儿子（子线程）开始工作了，我也继续工作");
    Console.WriteLine($"--我（主线程）完成! 我的 ID：{Thread.CurrentThread.ManagedThreadId}");
    Console.ReadLine();
}
// async 修饰的方法，也就是异步方法，不占用主线程
public static async Task AsyncTask()
{
    Thread.Sleep(1000);
    Console.WriteLine($"--我刚到，还没找到儿子（子线程）的房间，我的 ID：{Thread.CurrentThread.ManagedThreadId}");
    var result = await WasteTime(); // 主线程遇到 await，是不会等待的，直接继续执行，接下来的事情交给子线程
    Console.WriteLine(result);
    Console.WriteLine($"儿子（子线程）已经干完了应该干的事情! 我的 ID：{Thread.CurrentThread.ManagedThreadId}");
}
// async 修饰的方法，也就是异步方法，不占用主线程
private static async Task<string> WasteTime()
{
    Console.WriteLine($"--我终于找到了，下面准备让儿子（子线程）开干！我的 ID：{Thread.CurrentThread.ManagedThreadId}");
    return await Task.Run(() => // 创建一个子线程
    {
        Console.WriteLine($"儿子（子线程）开始异步执行了! 我的 ID：{Thread.CurrentThread.ManagedThreadId}");
        // 模拟耗时操作
        Thread.Sleep(5000);
        return $"儿子（子线程）异步执行完了。我的 ID：{Thread.CurrentThread.ManagedThreadId}";
    });
}

public async Task<int> ExampleMethodAsync()
{
    //...
}

public static async Task Main()
{
    Task<int> downloading = DownloadDocsMainPageAsync(); // 【1】
    Console.WriteLine($"{nameof(Main)}: 启动下载。。。ThreadID:{Thread.CurrentThread.ManagedThreadId}");
    int bytesLoaded = await downloading; // 【3】
    Console.WriteLine($"{nameof(Main)}: 共下载了 {bytesLoaded} bytes。ThreadID:{Thread.CurrentThread.ManagedThreadId}");
    Console.ReadLine();
}
private static async Task<int> DownloadDocsMainPageAsync()
{
    Console.WriteLine($"{nameof(DownloadDocsMainPageAsync)}: 即将开始下载。ThreadID:{Thread.CurrentThread.ManagedThreadId}");
    var client = new HttpClient();
    byte[] content = await client.GetByteArrayAsync("https://learn.microsoft.com/en-us/"); // 【2】
    Console.WriteLine($"{nameof(DownloadDocsMainPageAsync)}: 完成下载。ThreadID:{Thread.CurrentThread.ManagedThreadId}");
    return content.Length;
}

public class Program
{
    static async Task Main(string[] args)
    {
        const int count = 5;
        ConsoleExt.WriteLineAsync($"-------------------1开始示例异步测试");
        //ConsoleExt.WriteLineAsync($"-------------------2开始示例异步测试");
        //ConsoleExt.WriteLineAsync($"-------------------3开始示例异步测试");
        // 创建一个新的任务，用于【生成】异步序列数据
        IAsyncEnumerable<int> pullBasedAsyncSequence = ProduceAsyncSumSeqeunc(count);
        // 创建一个新的任务，用于【使用】异步序列数据
        var consumingTask = Task.Run(() => ConsumeAsyncSumSeqeunc(pullBasedAsyncSequence));
        ConsoleExt.WriteLineAsync($"-------------------开始做其他耗时操作");
        await Task.Delay(TimeSpan.FromSeconds(3)); // 模拟耗时操作
        ConsoleExt.WriteLineAsync($"-------------------结束做其他耗时操作");
        await consumingTask; // 等待异步任务完成
        ConsoleExt.WriteLineAsync($"-------------------结束示例异步测试");
        Console.ReadLine();
    }
    static async Task ConsumeAsyncSumSeqeunc(IAsyncEnumerable<int> sequence) // 使用
    {
        ConsoleExt.WriteLineAsync($"ConsumeAsyncSumSeqeunc 被调用");
        await foreach (var value in sequence)
        {
            ConsoleExt.WriteLineAsync($"----接收延迟返回的值 {value}");
            await Task.Delay(TimeSpan.FromSeconds(1)); // 模拟耗时操作
        };
    }
    private static async IAsyncEnumerable<int> ProduceAsyncSumSeqeunc(int count) // 生成
    {
        ConsoleExt.WriteLineAsync($"ProduceAsyncSumSeqeunc 被调用");
        var sum = 0;
        for (var i = 0; i <= count; i++)
        {
            sum = sum + i;
            await Task.Delay(TimeSpan.FromSeconds(0.5)); // 模拟耗时操作
            ConsoleExt.WriteLineAsync($"ProduceAsyncSumSeqeunc 返回 sum：{sum}");
            yield return sum; // yield 关键字表示延迟加载，将全部返回值一个一个返回
        }
    }
}
public static class ConsoleExt
{
    public static void WriteLine(object message)
    {
        Console.WriteLine($"(Time: {DateTime.Now.ToString("HH:mm:ss.ffffff")},  Thread {Thread.CurrentThread.ManagedThreadId}): {message} ");
    }
    public static async void WriteLineAsync(object message)
    {
        await Task.Run(() => Console.WriteLine($"(Time: {DateTime.Now.ToString("HH:mm:ss.ffffff")},  Thread {Thread.CurrentThread.ManagedThreadId}): {message} "));
    }
}

// 【前提】先实现接口 IAsyncDisposable
public class ExampleClass : IAsyncDisposable
{
	private Stream _memoryStream = new MemoryStream();
	public ExampleClass()
	{	}
	public async ValueTask DisposeAsync()
	{
		await _memoryStream.DisposeAsync();
	}
}
// 【第一种】然后就可以使用 using 语法糖
await using var s = new ExampleClass()
{
	// 具体操作。。。
};
// 【第二种】优化 同样是对象 s 只存在于当前代码块
await using var s = new ExampleClass();
// 具体操作。。。

class Program
{
    static void Main()
    {
        var task = Task.Run(() => {
            return GetName();
        });
        task.GetAwaiter().OnCompleted(() => {
            var name = task.Result;
            ConsoleExt.WriteLine("获取到的名称为：" + name);
        });
        ConsoleExt.WriteLine("主线程执行完毕");
        Console.ReadLine();
    }
    static string GetName()
    {
        ConsoleExt.WriteLine("另外一个线程在获取名称");
        Thread.Sleep(2000);
        return "GetName--名称";
    }
}
public static class ConsoleExt
{
    public static void WriteLine(object message)
    {
        Console.WriteLine($"(Time: {DateTime.Now.ToString("HH:mm:ss.ffffff")},  Thread {Thread.CurrentThread.ManagedThreadId}): {message} ");
    }
    public static async void WriteLineAsync(object message)
    {
        await Task.Run(() => Console.WriteLine($"(Time: {DateTime.Now.ToString("HH:mm:ss.ffffff")},  Thread {Thread.CurrentThread.ManagedThreadId}): {message} "));
    }
}

// GetResult() 方法就是阻塞线程，直到 task 执行完成，返回结果 name
var name = task.GetAwaiter().GetResult();
// 上边这行的效果，等同于
var name = await task;