C#使用异步的几种方法对比示例

叁歲伎倆 2023-09-27 17:49 110阅读 0赞

在C\#中，异步操作（Asynchronous Operations）可以提高程序的性能和响应能力。通常情况下，程序会等待某个操作完成之后才会继续执行下一个操作，这会导致程序的运行速度变慢。而异步操作可以让程序在等待某个操作完成的同时，执行其他操作，从而提高程序的运行效率。

在C\#中，实现异步操作的方式有以下几种：

1.使用异步方法

C\# 5.0引入了异步方法（Async Methods）的概念，使得编写异步代码变得更加容易。异步方法使用async关键字标记，返回类型必须是Task或Task<T>，方法中使用await关键字来等待异步操作完成。

以下是一个使用异步方法实现异步操作的示例：

public async Task<int> DownloadFileAsync(string url, string savePath)
    {
        using (var httpClient = new HttpClient())
        {
            var response = await httpClient.GetAsync(url);
            using (var fileStream = new FileStream(savePath, FileMode.Create))
            {
                await response.Content.CopyToAsync(fileStream);
            }
        }
        return 0;
    }

在上面的示例中，DownloadFileAsync方法使用async关键字标记，返回类型是Task<int>。方法中使用await关键字等待HttpClient.GetAsync和Stream.CopyToAsync方法完成异步操作。

2.使用Task.Run方法

Task.Run方法可以在新的线程上执行代码，因此也可以用来实现异步操作。使用Task.Run方法需要传入一个委托，该委托中的代码将在新的线程上执行。

以下是一个使用Task.Run方法实现异步操作的示例：

public async Task<int> DownloadFileAsync(string url, string savePath)
    {
        await Task.Run(() =>
        {
            using (var httpClient = new HttpClient())
            {
                var response = httpClient.GetAsync(url).Result;
                using (var fileStream = new FileStream(savePath, FileMode.Create))
                {
                    response.Content.CopyToAsync(fileStream).Wait();
                }
            }
        });
        return 0;
    }

在上面的示例中，DownloadFileAsync方法使用await关键字等待Task.Run方法执行的委托完成异步操作。

3.使用TaskCompletionSource类

TaskCompletionSource类可以用来创建一个可以异步完成的任务，然后通过SetResult或SetException方法来完成任务。使用TaskCompletionSource类需要手动编写异步代码。

以下是一个使用TaskCompletionSource类实现异步操作的示例：

public static Task<string> GetResultAsync()
    {
        var tcs = new TaskCompletionSource<string>();
        SomeMethod(result => tcs.SetResult(result));
        return tcs.Task;
    }

这个示例的作用是，异步获取一个字符串结果。它使用了 `TaskCompletionSource` 类来创建一个 `Task<string>` 对象，并在回调方法中将结果传递给该对象。

以下是重写后的示例，更加简洁易懂：

public static async Task<string> GetResultAsync()
    {
        return await Task.Run(() => SomeMethod());
    }

在这个示例中，使用了 `Task.Run` 方法来将 `SomeMethod` 方法包装成一个 `Task<string>` 对象，并通过 `await` 关键字来等待该对象的完成。

相比于使用 `TaskCompletionSource` 类来手动管理异步操作，使用 `Task.Run` 方法和 `await` 关键字更加简洁和易懂。同时，它也能够充分利用 .NET Framework 4.5 引入的异步编程模型，更好地利用系统资源，提高程序的性能和响应速度。

4.使用`async`和`await`异步编程

`async`和`await`是.NET Framework 4.5引入的一种新的异步编程模型，它基于`Task`和`Task<TResult>`，使异步编程更加简单和直观。使用`async`和`await`可以让程序员专注于异步操作的逻辑，而不是繁琐的状态管理和线程调度。

以下是使用`async`和`await`编写一个简单异步操作的示例：

public async Task<int> AsyncMethodAsync(int arg)
    {
        int result = await Task.Run(() =>
        {
            return arg * 2; // 异步操作
        });
    
        return result; // 返回异步操作的结果
    }

5.使用`Parallel`类进行并行编程

`Parallel`类是.NET Framework提供的一种用于执行并行操作的工具类，它提供了一些方法，可以让程序员轻松地编写并行操作，以提高程序的性能和效率。

以下是使用`Parallel`类执行并行操作的示例：

public int[] ParallelMethod(int[] arr)
    {
        Parallel.For(0, arr.Length, i =>
        {
            arr[i] = arr[i] * 2; // 并行操作
        });
    
        return arr; // 返回并行操作的结果
    }

区别：

这几种异步编程方法都可以实现异步操作，但它们之间存在一些差异：

*  `BeginInvoke/EndInvoke`方式是.NET Framework较早期的异步编程模型，适用于.NET Framework 1.1和2.0版本，它需要使用委托和回调函数进行异步操作的管理和完成。但是它比较繁琐，难以理解和维护，因此已经逐渐被`Task`和`async/await`方式所取代。
 *  `Task`和`Task<TResult>`方式是.NET Framework 4.0引入的一种新的异步编程模型，它更加灵活和直观，可以方便地管理和控制异步操作的状态和结果。使用`Task`和`Task<TResult>`可以轻松地实现异步操作的取消、

6.通过事件（Event）异步调用

使用事件机制也是一种实现异步编程的方式。这种方式的核心思想是，调用者注册一个事件处理程序，然后异步操作执行完毕时，会调用该事件处理程序并传递操作结果。

以下是使用事件实现异步编程的示例代码：

public class AsyncOperation
    {
        public event EventHandler Completed;
    
        public void Start()
        {
            // 模拟异步操作
            Task.Delay(1000).ContinueWith(task => {
                OnCompleted(new EventArgs());
            });
        }
    
        protected virtual void OnCompleted(EventArgs e)
        {
            Completed?.Invoke(this, e);
        }
    }
    
    // 调用异步操作
    var operation = new AsyncOperation();
    operation.Completed += (sender, e) => {
        Console.WriteLine("异步操作完成！");
    };
    operation.Start();

7.使用异步委托（Async delegate）

使用异步委托也是一种实现异步编程的方式。异步委托是指一个返回类型为 `Task` 或 `Task<T>` 的委托，可以使用 `async` 和 `await` 关键字来异步调用。

以下是使用异步委托实现异步编程的示例代码：

public class AsyncOperation
    {
        public async Task<int> StartAsync()
        {
            // 模拟异步操作
            await Task.Delay(1000);
            return 42;
        }
    }
    
    // 调用异步操作
    var operation = new AsyncOperation();
    var result = await operation.StartAsync();
    Console.WriteLine($"异步操作完成，结果为：{result}");

使用异步委托的好处是可以在调用方使用 `await` 关键字来等待异步操作完成，并且可以直接获取异步操作的结果。

8.使用异步的 LINQ（LINQ with async）

LINQ（Language Integrated Query）是 C\# 的一种语言特性，可以方便地进行数据查询和转换操作。在 .NET Framework 4.5 中，引入了一些新的异步操作符，使得 LINQ 查询可以以异步方式进行。

以下是使用异步的 LINQ 实现异步编程的示例代码：

var numbers = Enumerable.Range(1, 10);
    
    // 异步筛选出偶数
    var evenNumbers = await Task.Run(() => numbers.Where(n => n % 2 == 0));
    
    Console.WriteLine("筛选出的偶数为：");
    foreach (var number in evenNumbers)
    {
        Console.WriteLine(number);
    }

使用异步的 LINQ 可以简化代码，并且可以在查询操作比较耗时的情况下提高程序的性能。

区别和选择

上面介绍了几种常用的异步编程方式，每种方式都有自己的优缺点，适用于不同的场景。下面是它们之间的一些区别和选择：

1.  通过委托实现异步编程，适用于简单的异步操作，调用方只需要等待异步操作完成即可，不需要对结果进行处理。
2.  使用 Task 或 Task<T> 类。Task 和 Task<T> 是 .NET 框架中的一部分，是异步编程的基本构建块。它们可以用于创建异步操作、处理异步结果和执行连续异步操作。
    
    Task 是一个代表异步操作的类，它没有返回值。Task<T> 是一个代表异步操作的类，它返回一个 T 类型的值。使用 Task 或 Task<T> 可以很方便地执行异步操作，因为它们可以与 async 和 await 关键字一起使用，从而使异步代码看起来像同步代码。
    
    以下是使用 Task 和 Task<T> 的示例：  
    
    
        // 使用 Task 执行异步操作
        public async Task DoAsyncOperation()
        {
            await Task.Run(() =>
            {
                // 异步操作代码
            });
        }
        
        // 使用 Task<T> 执行异步操作并返回结果
        public async Task<string> DoAsyncOperationWithResult()
        {
            var result = await Task.Run(() =>
            {
                // 异步操作代码
                return "result";
            });
        
            return result;
        }
    
    在上面的示例中，DoAsyncOperation 和 DoAsyncOperationWithResult 方法都使用 Task 或 Task<T> 类来执行异步操作。它们使用 await 关键字等待异步操作完成，然后返回结果（如果有）。
    
    Task 和 Task<T> 的区别在于 Task<T> 可以返回一个值，而 Task 不可以。另外，Task 和 Task<T> 之间的其他区别与使用 async/await 关键字的异步方法和异步 Lambda 表达式的区别类似。在执行异步操作时，Task.Run 方法是最常用的方法之一，因为它允许您在一个新的线程上执行操作。  
    
    
        await Task.Run(() =>
        {
            // 异步操作代码
        });
    
    上面的代码将在一个新的线程上执行异步操作。在这种情况下，Task.Run 返回一个 Task 对象，该对象代表异步操作。由于使用了 async 和 await 关键字，所以可以等待异步操作完成，然后继续执行其他代码。
    
    使用 Task 或 Task<T> 的主要优点是，它们提供了一种更灵活的方式来执行异步操作，因为它们允许您在异步操作完成之前执行其他代码。此外，Task.Run 方法可以让您在单独的线程上执行操作，这使得异步编程更容易。但是，由于 Task.Run 创建了新的线程，所以使用 Task.Run 可能会增加应用程序的负载。因此，应该根据具体情况谨慎使用 Task.Run。