发帖
翼度科技»论坛 › 编程开发 › .net › 查看内容

.NET 4.0下实现.NET4.5的Task类相似功能组件

叶从峰

11

主题

11

帖子

33

积分

新手上路

Rank: 1

积分
33
显示全部楼层
实现 .NET 4.0 下的 Task 类相似功能：TaskExCum 组件详解

引言

随着 .NET 技术的发展，异步编程模型逐渐成为现代应用程序开发中的标准实践之一。.NET 4.5 引入了 Task 类，极大地简化了异步编程的过程。然而，许多遗留系统仍在使用 .NET 4.0 或更低版本，这些版本并未直接支持 Task 类的全部功能。为此，我们开发了 TaskExCum 组件，旨在为 .NET 4.0 提供与 .NET 4.5 相似的 Task 功能，包括 Task.Run() 和 Task.WhenAll() 方法。
组件概述

TaskExCum 是一个静态类，提供了以下主要功能：

  • Run 方法：用于异步执行任务，并获取任务的结果。
  • WhenAll 方法：用于等待多个任务完成，并收集所有任务的结果。
实现步骤

接下来，我们将详细讲解 TaskExCum 组件的实现步骤，以便读者能够更好地理解其工作原理，并将其应用于自己的项目中。
步骤 1: 创建 TaskExCum 类

首先，我们需要创建一个静态类 TaskExCum，并在其中定义静态方法。
  1. public static class TaskExCum
  2. {
  3.     // 方法定义将在后续步骤中添加
  4. }
复制代码
步骤 2: 实现 Run 方法

Run 方法允许开发者异步执行任务，并获取任务的结果。我们为 Run 方法提供了两种重载形式，分别用于执行无返回值的操作（Action）和有返回值的操作（Func）。
  1. public static Task<TResult> Run<TResult>(Func<TResult> function)
  2. {
  3. #if NET45
  4.     // 如果目标框架是 .NET 4.5 或更高版本，使用 Task.Run 方法
  5.     return Task.Run(function);
  6. #else
  7.     // 如果目标框架是 .NET 4.0，使用 Task.Factory.StartNew 方法
  8.     return Task.Factory.StartNew(
  9.         function,
  10.         CancellationToken.None,
  11.         TaskCreationOptions.None,
  12.         TaskScheduler.Default
  13.     );
  14. #endif
  15. }
  17. public static Task Run(Action action)
  18. {
  19. #if NET45
  20.     // 如果目标框架是 .NET 4.5 或更高版本，使用 Task.Run 方法
  21.     return Task.Run(action);
  22. #else
  23.     // 如果目标框架是 .NET 4.0，使用 Task.Factory.StartNew 方法
  24.     return Task.Factory.StartNew(
  25.         action,
  26.         CancellationToken.None,
  27.         TaskCreationOptions.None,
  28.         TaskScheduler.Default
  29.     );
  30. #endif
  31. }
复制代码
详细解释：

  • 条件编译：使用 #if NET45 编译符号，当项目目标框架为 .NET 4.5 及更高版本时，使用 Task.Run 方法。
  • Task.Factory.StartNew：当项目目标框架为 .NET 4.0 时，使用 Task.Factory.StartNew 方法来启动任务。

    • CancellationToken.None：表示没有取消令牌，任务不会被外部取消。
    • TaskCreationOptions.None：表示没有特殊的任务创建选项。
    • TaskScheduler.Default：这是关键点之一。TaskScheduler.Default 表示使用默认的线程池调度器，这意味着任务会在线程池中的一个线程上执行，而不是每次都启动一个新的线程。这有助于提高性能和资源利用率。

步骤 3: 实现 WhenAll 方法

WhenAll 方法用于等待多个任务完成，并收集所有任务的结果。我们为 WhenAll 方法提供了多种重载形式，以支持不同类型的任务集合。
  1. public static Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>> tasks)
  2. {
  3. #if NET45
  4.     // 如果目标框架是 .NET 4.5 或更高版本，使用 Task.WhenAll 方法
  5.     return Task.WhenAll(tasks);
  6. #else
  7.     // 如果目标框架是 .NET 4.0，调用 WhenAllCore 方法
  8.     return WhenAllCore(tasks);
  9. #endif
  10. }
  12. public static Task<TResult[]> WhenAll<TResult>(params Task<TResult>[] tasks)
  13. {
  14. #if NET45
  15.     // 如果目标框架是 .NET 4.5 或更高版本，使用 Task.WhenAll 方法
  16.     return Task.WhenAll(tasks);
  17. #else
  18.     // 如果目标框架是 .NET 4.0，调用 WhenAllCore 方法
  19.     return WhenAllCore(tasks);
  20. #endif
  21. }
  23. public static Task WhenAll(IEnumerable<Task> tasks)
  24. {
  25. #if NET45
  26.     // 如果目标框架是 .NET 4.5 或更高版本，使用 Task.WhenAll 方法
  27.     return Task.WhenAll(tasks);
  28. #else
  29.     // 如果目标框架是 .NET 4.0，调用 WhenAllCore 方法
  30.     return WhenAllCore(tasks);
  31. #endif
  32. }
复制代码
详细解释：

  • 条件编译：使用 #if NET45 编译符号，当项目目标框架为 .NET 4.5 及更高版本时，使用 Task.WhenAll 方法。
  • WhenAllCore：当项目目标框架为 .NET 4.0 时，调用 WhenAllCore 方法来实现相同的功能。
步骤 4: 实现 WhenAllCore 方法

WhenAllCore 方法是 WhenAll 方法的核心实现，负责处理任务集合，等待所有任务完成，并收集结果或异常信息。
  1. private static Task WhenAllCore(IEnumerable<Task> tasks)
  2. {
  3.     return WhenAllCore(tasks, (completedTasks, tcs) => tcs.TrySetResult(null));
  4. }
  6. private static Task<TResult[]> WhenAllCore<TResult>(IEnumerable<Task<TResult>> tasks)
  7. {
  8.     return WhenAllCore(tasks.Cast<Task>(), (completedTasks, tcs) =>
  9.     {
  10.         tcs.TrySetResult(completedTasks.Select(t => ((Task<TResult>)t).Result).ToArray());
  11.     });
  12. }
  14. private static Task<TResult> WhenAllCore<TResult>(IEnumerable<Task> tasks, Action<Task[], TaskCompletionSource<TResult>> setResultAction)
  15. {
  16.     if (tasks == null)
  17.     {
  18.         throw new ArgumentNullException("tasks");
  19.     }
  21.     Contract.EndContractBlock();
  22.     Contract.Assert(setResultAction != null);
  24.     var tcs = new TaskCompletionSource<TResult>();
  25.     var array = (tasks as Task[]) ?? tasks.ToArray();
  27.     if (array.Length == 0)
  28.     {
  29.         // 如果任务集合为空，直接设置结果
  30.         setResultAction(array, tcs);
  31.     }
  32.     else
  33.     {
  34.         Task.Factory.ContinueWhenAll(array, completedTasks =>
  35.         {
  36.             var exceptions = new List<Exception>();
  37.             bool hasCanceled = false;
  39.             foreach (var task in completedTasks)
  40.             {
  41.                 if (task.IsFaulted)
  42.                 {
  43.                     // 收集所有失败任务的异常信息
  44.                     exceptions.AddRange(task.Exception.InnerExceptions);
  45.                 }
  46.                 else if (task.IsCanceled)
  47.                 {
  48.                     // 检查是否有任务被取消
  49.                     hasCanceled = true;
  50.                 }
  51.             }
  53.             if (exceptions.Count > 0)
  54.             {
  55.                 // 如果有异常，设置异常结果
  56.                 tcs.TrySetException(exceptions);
  57.             }
  58.             else if (hasCanceled)
  59.             {
  60.                 // 如果有任务被取消，设置取消结果
  61.                 tcs.TrySetCanceled();
  62.             }
  63.             else
  64.             {
  65.                 // 如果没有异常且没有任务被取消，设置成功结果
  66.                 setResultAction(completedTasks, tcs);
  67.             }
  68.         }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
  69.     }
  71.     return tcs.Task;
  72. }
复制代码
详细解释：

  • 参数验证：检查传入的任务集合是否为 null，如果是，则抛出 ArgumentNullException。
  • TaskCompletionSource：创建一个 TaskCompletionSource 对象，用于管理任务的完成状态。
  • 任务转换：将任务集合转换为数组，以便于后续处理。
  • 任务数量检查：如果任务集合为空，直接调用 setResultAction 设置结果。
  • 等待所有任务完成：使用 Task.Factory.ContinueWhenAll 方法等待所有任务完成。

    • 异常处理：遍历已完成的任务，收集所有失败任务的异常信息。
    • 取消处理：检查是否有任务被取消。
    • 设置结果：如果没有异常且没有任务被取消，调用 setResultAction 设置结果。
    • TaskScheduler.Default：这里再次使用 TaskScheduler.Default，确保任务在默认的线程池中执行，而不是每次都启动新的线程。

步骤 5: 添加异常处理逻辑

为了确保组件的健壮性，我们还需要在 WhenAllCore 方法中添加异常处理逻辑，确保所有异常都能被捕获并正确处理。
  1. private static void AddPotentiallyUnwrappedExceptions(ref List<Exception> targetList, Exception exception)
  2. {
  3.     var ex = exception as AggregateException;
  4.     Contract.Assert(exception != null);
  5.     Contract.Assert(ex == null || ex.InnerExceptions.Count > 0);
  7.     if (targetList == null)
  8.     {
  9.         targetList = new List<Exception>();
  10.     }
  12.     if (ex != null)
  13.     {
  14.         // 如果异常是 AggregateException，添加其内部异常
  15.         targetList.Add(ex.InnerExceptions.Count == 1 ? ex.InnerExceptions[0] : ex);
  16.     }
  17.     else
  18.     {
  19.         // 否则，直接添加异常
  20.         targetList.Add(exception);
  21.     }
  22. }
复制代码
详细解释：

  • 异常类型检查：检查传入的异常是否为 AggregateException。
  • 异常列表初始化：如果 targetList 为 null，则初始化一个新的列表。
  • 异常添加：根据异常的类型，将异常或其内部异常添加到列表中。
示例代码

为了帮助读者更好地理解如何使用 TaskExCum 组件，下面是一些示例代码。
示例 1: 使用 Run 方法
  1. using System;
  2. using System.Threading.Tasks;
  4. class Program
  5. {
  6.     static void Main(string[] args)
  7.     {
  8.         try
  9.         {
  10.             // 异步执行任务并等待结果
  11.             string result = TaskExCum.Run(() => "Hello from Task!").Result;
  12.             Console.WriteLine(result);
  13.         }
  14.         catch (Exception ex)
  15.         {
  16.             Console.WriteLine($"Error: {ex.Message}");
  17.         }
  18.     }
  19. }
复制代码
示例 2: 使用 WhenAll 方法
  1. using System;
  2. using System.Linq;
  3. using System.Threading.Tasks;
  5. class Program
  6. {
  7.     static void Main(string[] args)
  8.     {
  9.         try
  10.         {
  11.             // 创建多个任务
  12.             var tasks = Enumerable.Range(1, 5).Select(i => TaskExCum.Run(() => i * i)).ToArray();
  13.             
  14.             // 等待所有任务完成并获取结果
  15.             int[] results = TaskExCum.WhenAll(tasks).Result;
  16.             
  17.             // 输出结果
  18.             foreach (var result in results)
  19.             {
  20.                 Console.WriteLine(result);
  21.             }
  22.         }
  23.         catch (Exception ex)
  24.         {
  25.             Console.WriteLine($"Error: {ex.Message}");
  26.         }
  27.     }
  28. }
复制代码
结论

通过 TaskExCum 组件，即使是在 .NET 4.0 这样的老框架版本中，我们也能够享受到现代异步编程模型带来的便利。希望这个组件能够帮助那些需要在旧版 .NET 框架中实现异步操作的开发者们，提高他们的开发效率和代码质量。如果你有任何建议或改进意见，欢迎留言交流！
详情请看：https://www.cnblogs.com/Bob-luo/p/18515670
以上就是关于 TaskExCum 组件的详细介绍。希望通过这篇文章，读者能够更好地理解和使用这个组件，从而在自己的项目中实现高效的异步编程。如果有任何问题或需要进一步的帮助，请随时留言！

来源:https://www.cnblogs.com/Bob-luo/p/18515670
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

上一篇: 从入门到放弃，我们为何从 Blazor 回到 Vue

下一篇: 深入浅出：AutoMapper 的使用与最佳实践

发表于 2024-10-31 15:12:47

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4