c#-异步编程-异步编程基(15.3)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

// c#-异步编程-调用异步方法
namespace ConsoleApp20
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            Program p = new Program();
            //p.main();
            // 使用多个异步方法
            //p.main2();
            // 使用ValueTasks
            //p.main3();
            //p.main4();
            p.main5();
            Thread.Sleep(8000);
        }
        // 创建任务-调用异步方法-使用Awaiter-延续任务
        void main() {

            //traceThreadAndTask("test");
            //同步任务
            //Greeting("test");
            //CallWhithAsync();
            //CallWhithSsync2();
            //CallerWithAwaiter();
            CallerWithContinuationTask();
        }

        void traceThreadAndTask(string info) {
            string taskInfo = Task.CurrentId == null ? "no task" : "task" + Task.CurrentId;
            Console.WriteLine($"{info} in thread {Thread.CurrentThread.ManagedThreadId} " + $"and {taskInfo}");

        }
        string Greeting(string name) {
            traceThreadAndTask($"running {nameof(Greeting)}");
            Task.Delay(3000).Wait();
            return $"hello,{name}";
        }
        Task<string> GreetingAsync(string name) => Task.Run<string>(() => {
            traceThreadAndTask($"running {nameof(GreetingAsync)}");
            return Greeting(name);
        });
        async void CallWhithAsync() {
            traceThreadAndTask($"started{nameof(CallWhithAsync)}");
            string result = await GreetingAsync("stephanie");
            Console.WriteLine(result);
            traceThreadAndTask($"ended  {nameof(CallWhithAsync)}");
        }
        async void CallWhithSsync2() {
            traceThreadAndTask($"started{nameof(CallWhithSsync2)}");
            Console.WriteLine(await GreetingAsync("stephanie2"));
            traceThreadAndTask($"ended  {nameof(CallWhithSsync2)}");
        }
        // 使用Awaiter
        void CallerWithAwaiter() {
            traceThreadAndTask($"started{nameof(CallerWithAwaiter)}");
            TaskAwaiter<string> awaiter = GreetingAsync("Matthias").GetAwaiter();
            awaiter.OnCompleted(OnCompleteAwaiter);
            void OnCompleteAwaiter()
            {
                Console.WriteLine(awaiter.GetResult());
                traceThreadAndTask($"started{nameof(CallerWithAwaiter)}");
            }
        }
        // 延续任务
        void CallerWithContinuationTask() {
            traceThreadAndTask($"started{nameof(CallerWithContinuationTask)}");
            var t1 = GreetingAsync("stephanie");
            t1.ContinueWith(t =>
            {
                string result = t.Result;
                Console.WriteLine(result);
                traceThreadAndTask($"ended  {nameof(CallerWithContinuationTask)}");
            });
        }
        
        // 使用多个异步方法
        void main2()
        {
            MultipleAsyncMethods();
        }
        // 使用多个异步方法-按顺序调用异步方法
        async void MultipleAsyncMethods() {
            string s1 = await GreetingAsync("stephandle");
            string s2 = await GreetingAsync("Matthias");
            Console.WriteLine($"Finished both methods.{Environment.NewLine} rusult1:{s1}{Environment.NewLine}result2:{s2 }");
        }
        // 使用组合器
        async void MultipleAsyncMethodsWhithCombination() {
            Task<string> t1 = GreetingAsync("stephandle");
            Task<string> t2 = GreetingAsync("Matthias");
            await Task.WhenAll(t1, t2);
            Console.WriteLine($"Finished both methods.{Environment.NewLine} rusult1:{t1.Result}{Environment.NewLine}result2:{t2.Result }");
        }
        async void MultipleAsyncMethodsWhithCombination2()
        {
            Task<string> t1 = GreetingAsync("stephandle");
            Task<string> t2 = GreetingAsync("Matthias");
            string[] result = await Task.WhenAll(t1, t2);
            Console.WriteLine($"Finished both methods.{Environment.NewLine} rusult1:{result[0]}{Environment.NewLine}result2:{result[1] }");
        }

        // 15.3.7 使用ValueTasks
        void main3()
        {
            //UseValueTask();
            UseValueTask2();
        }
        readonly static Dictionary<string, string> names = new Dictionary<string, string>();
        async ValueTask<string> CreetingValueTaskAsync(string name) {
            if (names.TryGetValue(name, out string result))
            {
                return result;
            }
            else {
                result = await GreetingAsync(name);
                names.Add(name, result);
                return result;
            }
        }
        ValueTask<string> CreetingValueTask2Async(string name) {
            if (names.TryGetValue(name, out string result))
            {
                return new ValueTask<string>(result);
            }
            else
            {
                Task<string> t1 = GreetingAsync(name);
                TaskAwaiter<string> awaiter = t1.GetAwaiter();
                awaiter.OnCompleted(OnCompletion);
                return new ValueTask<string>(t1);
                void OnCompletion() {
                    names.Add(name, awaiter.GetResult());
                }
            }
        }
        async void UseValueTask() {
            string result = await CreetingValueTaskAsync("katharina");// katharina 凯塔琳娜
            Console.WriteLine(result);
            string result2 = await CreetingValueTaskAsync("katharina");// katharina 凯塔琳娜
            Console.WriteLine(result2);
        }
        async void UseValueTask2()
        {
            string result = await CreetingValueTask2Async("katharina");// katharina 凯塔琳娜
            Console.WriteLine(result);
            string result2 = await CreetingValueTask2Async("katharina");// katharina 凯塔琳娜
            Console.WriteLine(result2);
        }
        // 15.3.7 使用 异步模式
        void main4() {
            ConvertingAsyncPattern();
        }
        async void ConvertingAsyncPattern() {
            HttpWebRequest request = WebRequest.Create("http://www.baidu.com") as HttpWebRequest;
            using (WebResponse response = await Task.Factory.FromAsync<WebResponse>(
                request.BeginGetResponse(null, null), request.EndGetResponse))
            {
                Stream stream = response.GetResponseStream();
                using (var reader = new StreamReader(stream))
                {
                    string content = reader.ReadToEnd();
                    Console.WriteLine(content.Substring(0, 100));
                }
            }
        }

        
        void main5() {
            //OnStartAsync();
            OnStartAsynConfigureAwait();
        }
        async void OnStartAsync()
        {
            play($"Ui thread:{GetThread()}");
            await Task.Delay(1000);
            play($"after thread:{GetThread()}");
        }
        void play(string str) {
            Console.WriteLine(str);
        }
        string GetThread() => $"thread:{Environment.CurrentManagedThreadId}";
        async void OnStartAsynConfigureAwait() {
            play($"Ui thread:{GetThread()}");
            string s = await AsyncFunction().ConfigureAwait(continueOnCapturedContext: false);
            play($"{s}");
            play($"after thread:{GetThread()}");
        }
        async Task<string> AsyncFunction() {
            string result = $"\nasync function:{GetThread()}";
            await Task.Delay(1000).ConfigureAwait(continueOnCapturedContext: false);
            result += $"\nasync function after:{GetThread()}";
            return result;
        }
    }
}