基于任務(wù)的異步模式 (TAP) ，該模式使用單一方法表示異步操作的開始和完成。 TAP 是在 .NET Framework 4 中引入的。這是在 .NET 中進行異步編程的推薦方法。 C# 中的 async 和 await 關(guān)鍵詞以及 Visual Basic 中的 Async 和 Await 運算符為 TAP 添加了語言支持。有關(guān)詳細信息，請參閱基于任務(wù)的異步模式 (TAP)。
基于事件的異步模式 (EAP)，是提供異步行為的基于事件的舊模型。這種模式需要后綴為 Async 的方法，以及一個或多個事件、事件處理程序委托類型和 EventArg 派生類型。 EAP 是在 .NET Framework 2.0 中引入的。建議新開發(fā)中不再使用這種模式。有關(guān)詳細信息，請參閱基于事件的異步模式 (EAP)。
異步編程模型 (APM) 模式（也稱為 IAsyncResult 模式），這是使用 IAsyncResult 接口提供異步行為的舊模型。在這種模式下，同步操作需要 Begin 和 End 方法（例如，BeginWrite 和 EndWrite以實現(xiàn)異步寫入操作）。不建議新的開發(fā)使用此模式。有關(guān)詳細信息，請參閱異步編程模型 (APM)。

C#異步有四種實現(xiàn)方式

C# 異步有多種實現(xiàn)方式，可歸納為以下幾類：

1、異步方法（Async Method TAP模式）

使用async/await關(guān)鍵字實現(xiàn)異步編程，這是比較常用的一種異步實現(xiàn)方式。例如：

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

2、任務(wù)并行庫（TPL, Task Parallel Library TAP模式）

通過 Task 和 Task<T> 類型實現(xiàn)異步編程，可以利用多核處理器，并發(fā)執(zhí)行多個獨立的任務(wù)。例如：

public static async void Main(string[] args)
    {
        await Task.Run(() =>
        {
            Console.WriteLine("Test Task 1 completed.");
        });
        await Task.Run(() =>
        {
            Console.WriteLine("Test Task 2 completed.");
        });
        // 等待所有任務(wù)完成
        Task.WaitAll();
    }

3、Asynchronous Programming Model（APM模式）

是一種經(jīng)典的異步編程模式，需要手動創(chuàng)建回調(diào)函數(shù)，用于處理完成或錯誤的通知?？梢酝ㄟ^ IAsyncResult 設(shè)計模式的 Begin 和 End 方法來實現(xiàn)，其中 Begin 方法開始異步操作，而 End 方法在異步操作完成時執(zhí)行，并返回異步操作的結(jié)果。

需要注意的是，APM 模式通過 IAsyncResult 接口來存儲異步操作的狀態(tài)和結(jié)果，相對比較復(fù)雜，代碼量也較大。同時，在使用 APM 模式時，還需要手動處理回調(diào)函數(shù)和等待異步操作完成等細節(jié)工作，使得開發(fā)起來相對較為繁瑣。

class Program
    {
        static void Main(string[] args)
        {
            // 創(chuàng)建異步操作類實例
            MyAsyncClass asyncClass = new MyAsyncClass();

            // 開始異步操作
            IAsyncResult result = asyncClass.BeginDoWork(null, null);

            // 主線程執(zhí)行其他操作
            // 等待異步操作完成并獲取結(jié)果
            int res = asyncClass.EndDoWork(result);

            // 處理異步操作的結(jié)果
            Console.WriteLine("Result: " + res);

            Console.ReadLine();
        }
    }

    class MyAsyncClass
    {
        /// <summary>
        /// 異步執(zhí)行的方法
        /// </summary>
        /// <param name="callback">callback</param>
        /// <param name="state">state</param>
        /// <returns></returns>
        public IAsyncResult BeginDoWork(AsyncCallback callback, object state)
        {
            // 創(chuàng)建一個新的異步操作對象
            MyAsyncResult result = new MyAsyncResult(state);

            // 開始異步操作
            Thread thread = new Thread(() =>
            {
                try
                {
                    // 執(zhí)行一些操作
                    int res = 1 + 2;

                    // 設(shè)置異步操作的結(jié)果
                    result.Result = res;

                    // 觸發(fā)回調(diào)函數(shù)
                    callback?.Invoke(result);
                }
                catch (Exception ex)
                {
                    // 設(shè)置異步操作的異常
                    result.Error = ex;

                    // 觸發(fā)回調(diào)函數(shù)
                    callback?.Invoke(result);
                }

            });
            thread.Start();

            // 返回異步操作對象
            return result;
        }

        /// <summary>
        /// 結(jié)束異步執(zhí)行的方法
        /// </summary>
        /// <param name="result">result</param>
        /// <returns></returns>
        public int EndDoWork(IAsyncResult result)
        {
            // 將 IAsyncResult 轉(zhuǎn)換為 MyAsyncResult 類型，并等待異步操作完成
            MyAsyncResult myResult = (MyAsyncResult)result;
            myResult.AsyncWaitHandle.WaitOne();

            // 在異步操作中拋出異常
            if (myResult.Error != null)
            {
                throw myResult.Error;
            }

            // 返回異步操作的結(jié)果
            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>
        /// 存儲異步操作的結(jié)果或異常信息
        /// </summary>
        public Exception Error { get; set; }

        /// <summary>
        /// 構(gòu)造函數(shù)
        /// </summary>
        /// <param name="asyncState">asyncState</param>
        public MyAsyncResult(object asyncState)
        {
            AsyncState = asyncState;
        }
    }

4、Event-based Asynchronous Pattern（EAP模式）

一種已過時的異步編程模式，需要使用事件來實現(xiàn)異步編程。例如：

需要注意的是，EAP 模式通過事件來實現(xiàn)異步編程，相對于 APM 模式更加簡潔易懂，同時也避免了手動處理回調(diào)函數(shù)等細節(jié)工作。但是，EAP 模式并不支持 async/await 異步關(guān)鍵字，因此在一些特定的場景下可能不夠靈活。

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>
        /// 異步執(zhí)行方法，接受一個參數(shù) arg
        /// </summary>
        /// <param name="arg"></param>
        public void DoWorkAsync(int arg)
        {
            // 將異步操作放入線程池中執(zhí)行
            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;

            // 觸發(fā)事件，傳遞異步操作的結(jié)果
            OperationNameCompleted?.Invoke(res);
        }
    }

以上就是C#實現(xiàn)異步的常用方式總結(jié)的詳細內(nèi)容，更多關(guān)于C#異步的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: