【愚公系列】2023年08月 .NET/C#知识点-异步四种实现方式 | 技术创作特训营第一期

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