C#Async,await异步简单介绍

        static void Main(string[] args)
        {
            fun22();
            Console.WriteLine($"Main await ThreadId {Thread.CurrentThread.ManagedThreadId}");
            Console.ReadKey();
        }

        private async static void fun22()
        {
            //sync同步(相对于调用函数的线程)
            Console.WriteLine($"pre await ThreadId {Thread.CurrentThread.ManagedThreadId}");
            await HelloWorld();
            //async异步(相对于调用函数的线程)
            Console.WriteLine($"after await ThreadId {Thread.CurrentThread.ManagedThreadId}");
        }

        private static Task HelloWorld()
        {
            //sync同步(相对于调用函数的线程)
            Console.WriteLine($"pre Task ThreadId {Thread.CurrentThread.ManagedThreadId}");

            //async异步(相对于调用函数的线程)
            return Task.Factory.StartNew(() =>
            {
　　　　　　　　　　Thread.Sleep(1000);
                Console.WriteLine($"Task ThreadId {Thread.CurrentThread.ManagedThreadId}");
            });
        }

using System;
using System.IO;

namespace ConsoleApplication
{
    class Program
    {
        static async Task Main()
        {
            await ReadCharacters();
        }

        static async Task ReadCharacters()
        {
            String result;
            using (StreamReader reader = File.OpenText("existingfile.txt"))
            {
                Console.WriteLine("Opened file.");
                result = await reader.ReadToEndAsync();
                Console.WriteLine("Contains: " + result);
            }
        }
    }
}

        [HostProtection(ExternalThreading = true)]
        [ComVisible(false)]
        public Task ReadAsync(Byte[] buffer, int offset, int count)
        {
            return ReadAsync(buffer, offset, count, CancellationToken.None);
        }
 
        [HostProtection(ExternalThreading = true)]
        [ComVisible(false)]
        public virtual Task ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            // If cancellation was requested, bail early with an already completed task.
            // Otherwise, return a task that represents the Begin/End methods.
            return cancellationToken.IsCancellationRequested
                        ? Task.FromCancellation(cancellationToken)
                        : BeginEndReadAsync(buffer, offset, count);
        }
 
        private Task BeginEndReadAsync(Byte[] buffer, Int32 offset, Int32 count)
        {            
            return TaskFactory.FromAsyncTrim(
                        this, new ReadWriteParameters { Buffer = buffer, Offset = offset, Count = count },
                        (stream, args, callback, state) => stream.BeginRead(args.Buffer, args.Offset, args.Count, callback, state), // cached by compiler
                        (stream, asyncResult) => stream.EndRead(asyncResult)); // cached by compiler
        }