C#中异步是4种实现方式详解

    public async Task TestDoSomeAsync()
    {
        await Task.Delay(1000*10);
        Console.WriteLine("Async method completed.");
    }

 public static void TestTaskParallel()
        {
            var task1 = Task.Run(() =>
            {
                Console.WriteLine("Task 1 completed.");
            });
 
            var task2 = Task.Run(() =>
            {
                Console.WriteLine("Task 2 completed.");
            });
 
            Task<int> task3 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("Task 3 completed.");
                return 20;// 返回一个整数值
            });
 
            //等待所有任务完成
            Task.WaitAll(task1, task2, task3);
        }

class Program
    {
        static void Main(string[] args)
        {
            // 创建异步操作类实例
            MyAsyncClass asyncClass = new MyAsyncClass();
 
            // 开始异步操作
            IAsyncResult result = asyncClass.BeginDoWork(null, null);
 
            // 主线程执行其他操作
            // 等待异步操作完成并获取结果
            int res = asyncClass.EndDoWork(result);
 
            // 处理异步操作的结果
            Console.WriteLine("Result: " + res);
 
            Console.ReadLine();
        }
    }
 
    class MyAsyncClass
    {
        /// <summary>
        /// 异步执行的方法
        /// </summary>
        /// <param name="callback">callback</param>
        /// <param name="state">state</param>
        /// <returns></returns>
        public IAsyncResult BeginDoWork(AsyncCallback callback, object state)
        {
            // 创建一个新的异步操作对象
            MyAsyncResult result = new MyAsyncResult(state);
 
            // 开始异步操作
            Thread thread = new Thread(() =>
            {
                try
                {
                    // 执行一些操作
                    int res = 1 + 2;
 
                    // 设置异步操作的结果
                    result.Result = res;
 
                    // 触发回调函数
                    callback?.Invoke(result);
                }
                catch (Exception ex)
                {
                    // 设置异步操作的异常
                    result.Error = ex;
 
                    // 触发回调函数
                    callback?.Invoke(result);
                }
 
            });
            thread.Start();
 
            // 返回异步操作对象
            return result;
        }
 
        /// <summary>
        /// 结束异步执行的方法
        /// </summary>
        /// <param name="result">result</param>
        /// <returns></returns>
        public int EndDoWork(IAsyncResult result)
        {
            // 将 IAsyncResult 转换为 MyAsyncResult 类型，并等待异步操作完成
            MyAsyncResult myResult = (MyAsyncResult)result;
            myResult.AsyncWaitHandle.WaitOne();
 
            // 在异步操作中抛出异常
            if (myResult.Error != null)
            {
                throw myResult.Error;
            }
 
            // 返回异步操作的结果
            return myResult.Result;
        }
    }
 
    class MyAsyncResult : IAsyncResult
    {
        public bool IsCompleted => AsyncWaitHandle.WaitOne(0);
        public WaitHandle AsyncWaitHandle { get; } = new ManualResetEvent(false);
        public object AsyncState { get; }
        public bool CompletedSynchronously => false;
 
        public int Result { get; set; }
 
        /// <summary>
        /// 存储异步操作的结果或异常信息
        /// </summary>
        public Exception Error { get; set; }
 
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="asyncState">asyncState</param>
        public MyAsyncResult(object asyncState)
        {
            AsyncState = asyncState;
        }
    }

public class MyAsyncClass : Component
    {
        /// <summary>
        /// 声明一个委托类型，用于定义异步操作的方法签名
        /// </summary>
        /// <param name="arg"></param>
        /// <returns></returns>
        public delegate int MyAsyncDelegate(int arg);
 
        /// <summary>
        /// 声明一个事件，用于通知异步操作的完成
        /// </summary>
        public event MyAsyncDelegate OperationNameCompleted;
 
        /// <summary>
        /// 异步执行方法，接受一个参数 arg
        /// </summary>
        /// <param name="arg"></param>
        public void DoWorkAsync(int arg)
        {
            // 将异步操作放入线程池中执行
            ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), arg);
        }
 
        /// <summary>
        /// 真正的异步操作
        /// </summary>
        /// <param name="obj"></param>
        private void DoWork(object obj)
        {
            int arg = (int)obj;
            int res = arg + 1;
 
            // 触发事件，传递异步操作的结果
            OperationNameCompleted?.Invoke(res);
        }
    }