c#中的task类用于处理异步操作，通过封装耗时任务并使其在后台运行，避免阻塞主线程。1. task.run() 是最常用方法，适合将同步代码异步化，默认使用线程池；2. new task().start() 提供更细粒度控制，适合延迟启动或需额外配置的任务；3. task.factory.startnew() 功能强大但复杂，适用于需要高级控制的场景。相比直接使用thread，task利用线程池提升效率，并与async/await集成，简化异步编程模型。异常可通过 await 或检查 exception 属性捕获，取消则通过 cancellationtoken 实现，确保任务安全退出，从而构建更稳定、响应性更强的应用程序。
C#里的
Task
类，简单来说，就是用来处理异步操作的。它把一个可能耗时的工作封装起来，让这个工作可以在后台默默进行，不阻塞主线程，这样程序界面就不会卡死，用户体验就好很多。创建任务通常用
Task.Run()
或者直接实例化
Task
然后
Start()
。
解决方案
Task
在.NET中扮演的角色，远不止是“开个线程干活”那么简单。它其实是异步编程模型的核心，尤其是在有了
async
和
await
关键字之后，
Task
就成了连接同步和异步世界的桥梁。它代表了一个可能在未来某个时间点完成的操作。
当你需要执行一个操作，比如从网络下载数据、读写大文件、或者进行复杂的计算，这些操作如果直接在UI线程或者主线程上执行，就会导致程序“假死”。
Task
就是来解决这个问题的。它抽象了底层的线程管理，让你不用直接和线程打交道，而是关注于“做什么”而不是“怎么做”（比如线程池管理、上下文切换等）。
创建
Task
的方法有很多种，最常用、也最推荐的是
Task.Run()
。
使用
Task.Run()
(推荐)这是最简洁、也最常用的方式，尤其适合把一个同步方法放到线程池里异步执行。
// 假设有一个耗时操作string DoSomethingTimeConsuming(){ System.Threading.Thread.Sleep(2000); // 模拟耗时2秒 return "操作完成！";}// 创建并启动一个任务Task myTask = Task.Run(() => DoSomethingTimeConsuming());// 你可以在这里做其他事情，不用等待任务完成Console.WriteLine("任务已启动，我正在做别的事情...");// 当你需要结果时，使用await等待string result = await myTask;Console.WriteLine(result);
Task.Run()
会把你的委托放到线程池里执行，非常高效。
使用
new Task()
和
Start()
这种方式更显式，你可以先创建一个
Task
实例，但不立即启动它，等到需要的时候再调用
Start()
。
Task calculateTask = new Task(() =>{ Console.WriteLine("开始复杂计算..."); System.Threading.Thread.Sleep(3000); // 模拟计算3秒 return 123 + 456;});Console.WriteLine("任务已定义，但尚未启动。");// 可以在某个条件满足时再启动calculateTask.Start();Console.WriteLine("任务已显式启动。");int sum = await calculateTask;Console.WriteLine($"计算结果: {sum}");
这种方式给你的控制权更多，但通常不如
Task.Run()
方便，因为
Task.Run()
已经帮你处理了启动和线程池的细节。
使用
Task.Factory.StartNew()
这是老版本创建任务的方式，功能非常强大，但也相对复杂。在很多情况下，
Task.Run()
是
Task.Factory.StartNew()
的一个简化版本，更推荐使用
Task.Run()
。
Task powerTask = Task.Factory.StartNew(() =>{ Console.WriteLine("开始幂运算..."); return Math.Pow(2, 10);});double powerResult = await powerTask;Console.WriteLine($"2的10次方: {powerResult}");
除非你需要非常细粒度的控制，比如指定
TaskCreationOptions
（如
LongRunning
，表示任务可能长时间运行，不适合放在线程池中），否则
Task.Run()
通常是更好的选择。
为什么选择Task而不是直接使用Thread？
很多人刚接触异步编程时，可能会想到直接用
Thread
类来开新线程。但实际上，在现代C#应用中，直接操作
Thread
已经很少见了，除非是极特殊、需要对线程生命周期有极致控制的场景。
Task
的出现，就是为了解决
Thread
带来的诸多不便和效率问题。
一个主要原因是线程池的利用。每次创建和销毁一个
Thread
对象都是有开销的，系统资源需要分配和回收。如果你的应用需要频繁地执行短小的异步操作，反复创建销毁线程会造成巨大的性能损耗。
Task
则不然，它默认会利用.NET的线程池。线程池里维护了一组预先创建好的线程，任务来了就从池子里拿一个，任务完成就还回去，这样就大大减少了线程创建和销毁的开销，提高了效率。这就像你不需要每次都买辆新车来出行，而是用共享单车一样，用完就还。
其次是异步编程模型的集成。
Task
是
async/await
语法糖的基础。没有
Task
，
async/await
就无从谈起。
async/await
让异步代码看起来像同步代码一样直观，极大地降低了异步编程的复杂性。如果你用
Thread
，你就得自己管理线程的启动、等待、结果获取、异常处理，这些都非常繁琐，容易出错。
Task
提供了一套统一的API来处理这些，比如
Task.Wait()
、
Task.ContinueWith()
、
Task.WhenAll()
、
Task.WhenAny()
等，这些都让异步流程控制变得简单明了。
还有就是错误处理和上下文传递。在
Task
中，异常会被很好地捕获并传播，你可以通过
await
来捕获任务内部抛出的异常，或者通过
Task.Exception
属性来检查。而在
Thread
中，未处理的异常默认会直接终止进程，这显然不是我们希望看到的。此外，
Task
在某些情况下还能更好地处理执行上下文（比如UI线程的同步上下文），确保在任务完成后可以安全地更新UI。
所以，总的来说，
Task
提供了更高级、更安全、更高效、也更易于使用的抽象，是现代C#异步编程的首选。
Task.Run() 和 new Task().Start() 有什么区别？什么时候用哪个？
这两个方法都能启动一个任务，但它们在行为上确实有一些细微但重要的区别，这决定了你在不同场景下应该选择哪个。
最核心的区别在于任务的创建和启动时机。
Task.Run(Action action)
或
Task.Run(Func function)
Task.Run()
是一个静态方法，它会立即把你的委托（
Action
或
Func
）提交到线程池中执行。这意味着一旦你调用了
Task.Run()
，这个任务就“跑起来了”，它会等待线程池分配一个线程给它，然后开始执行。你拿到的是一个已经处于“运行中”或者“等待运行”状态的
Task
对象。
优点：
简洁方便： 一行代码搞定任务的创建和启动，无需关心底层细节。默认使用线程池： 效率高，适合CPU密集型或IO密集型任务。推荐用于将同步代码异步化： 当你有一个现成的同步方法，想让它在后台运行而不阻塞当前线程时，
Task.Run()
是最佳选择。
缺点：
无法控制启动时机： 任务一旦创建就自动开始，没有“准备好但未启动”的状态。
使用场景： 绝大多数情况下，当你需要执行一个后台操作时，都应该优先考虑
Task.Run()
。比如，点击按钮后执行一个数据库查询，或者在后台进行数据处理。
new Task(Action action)
或
new Task(Func function)
，然后调用
task.Start()
new Task()
是构造函数，它只会创建一个
Task
实例，但不会立即启动。这个任务对象在创建后处于
Created
状态。你需要显式地调用它的实例方法
Start()
，任务才会开始执行。
优点：
控制启动时机： 你可以先创建好任务，然后根据程序逻辑的需要，在任何时候调用
Start()
来启动它。这在某些复杂的流程控制中可能有用，比如需要等待多个条件都满足后才开始一系列任务。可以链式调用： 虽然不常见，但你可以对一个
Created
状态的
Task
做一些配置，然后再启动。
缺点：
多一步操作： 需要显式调用
Start()
，代码量稍微多一点。容易遗漏
Start()
： 如果忘记调用
Start()
，任务永远不会执行。不适合异步IO操作： 这种方式通常用于CPU密集型任务，对于IO密集型任务（如网络请求、文件读写），更推荐使用
async/await
模式下的异步IO方法（它们通常返回
Task
或
Task
，无需手动
Start
）。
使用场景： 比较少见，通常是在需要延迟启动、或者在任务启动前进行一些复杂设置的场景下才考虑。例如，你可能有一个任务队列，任务进入队列时先实例化，然后由一个调度器统一
Start()
。
总结一下，如果你的目标是简单地把一个同步操作扔到后台执行，让它不阻塞当前线程，那么
Task.Run()
是你的首选。它更符合现代C#异步编程的习惯。而
new Task().Start()
则提供了更细粒度的控制，但使用场景相对较少。
如何处理Task的异常和取消？
在异步编程中，正确地处理异常和任务取消是构建健壮应用的关键。如果处理不好，轻则程序崩溃，重则资源泄露或逻辑错误。
异常处理
Task
的异常处理和同步代码有点不一样，但有了
async/await
之后，又变得很像了。
使用
await
和
try-catch
这是最推荐的方式。当你在
await
一个
Task
时，如果该
Task
内部发生了未处理的异常，这个异常会被重新抛出到
await
它的调用栈上，这样你就可以像处理同步异常一样，用
try-catch
块来捕获它。
async Task SimulateErrorAsync(){ Console.WriteLine("任务开始，准备抛出异常..."); await Task.Delay(1000); // 模拟一些工作 throw new InvalidOperationException("哎呀，任务出错了！");}async Task CallWithErrorHandling(){ try { await SimulateErrorAsync(); Console.WriteLine("任务成功完成（这条不会打印）"); } catch (InvalidOperationException ex) { Console.WriteLine($"捕获到异常: {ex.Message}"); } catch (Exception ex) // 捕获其他类型的异常 { Console.WriteLine($"捕获到未知异常: {ex.Message}"); }}// 调用示例// await CallWithErrorHandling();
这种方式最直观，也最符合我们处理同步异常的习惯。
检查
Task.Exception
属性如果一个
Task
在没有被
await
的情况下完成了，并且内部抛出了异常，这个异常会被封装在一个
AggregateException
中，并存储在
Task
对象的
Exception
属性里。当你访问这个属性时，如果任务失败，异常就会被抛出。
Task failingTask = Task.Run(() =>{ Console.WriteLine("后台任务开始，即将抛出异常..."); throw new DivideByZeroException("除零错误！");});// 不使用await，让任务在后台运行Console.WriteLine("主线程继续执行...");try{ // 尝试等待任务完成，这时如果任务失败，异常会被抛出 failingTask.Wait(); // 或者 failingTask.Result;}catch (AggregateException ae){ Console.WriteLine($"捕获到聚合异常，包含 {ae.InnerExceptions.Count} 个内部异常:"); foreach (var ex in ae.InnerExceptions) { Console.WriteLine($"- {ex.GetType().Name}: {ex.Message}"); }}
AggregateException
设计用来处理一个
Task
可能包含多个内部异常的情况（比如
Task.WhenAll
）。通常情况下，一个简单的
Task
只会有一个内部异常。
注意： 如果不
await
也不
Wait()
或访问
Result
，并且不检查
Task.Exception
，那么未处理的
Task
异常最终可能会导致进程终止（在.NET Framework中默认如此，.NET Core中行为有所调整，但仍然建议显式处理）。
任务取消
任务取消是一种协作式的机制，意味着任务本身需要主动检查取消请求并响应。这比简单地“杀死”一个线程要优雅和安全得多。
使用
CancellationTokenSource
和
CancellationToken
这是实现任务取消的标准模式。
CancellationTokenSource
：负责发出取消信号。
CancellationToken
：由
CancellationTokenSource
创建，传递给任务，任务通过它来监听取消请求。
async Task DoWorkWithCancellation(CancellationToken cancellationToken){ for (int i = 0; i < 10; i++) { // 每次循环都检查是否收到取消请求 if (cancellationToken.IsCancellationRequested) { Console.WriteLine("任务收到取消请求，准备退出。"); // 可以选择抛出OperationCanceledException cancellationToken.ThrowIfCancellationRequested(); // 或者直接return; // return; } Console.WriteLine($"正在执行工作... 步骤 {i + 1}"); await Task.Delay(500, cancellationToken); // Task.Delay也支持CancellationToken } Console.WriteLine("任务正常完成。");}async Task RunCancellableTask(){ using (var cts = new CancellationTokenSource()) { Task longRunningTask = DoWorkWithCancellation(cts.Token); // 模拟一段时间后发出取消请求 await Task.Delay(2000); Console.WriteLine("发出取消请求..."); cts.Cancel(); try { await longRunningTask; } catch (OperationCanceledException) { Console.WriteLine("任务被成功取消了！"); } catch (Exception ex) { Console.WriteLine($"任务中发生其他异常: {ex.Message}"); } }}// 调用示例// await RunCancellableTask();
cancellationToken.ThrowIfCancellationRequested()
是一个方便的方法，它会在收到取消请求时抛出
OperationCanceledException
。这个异常是
await
能够捕获并识别为“任务被取消”的关键。如果你选择不抛出异常，而是直接
return
，那么任务的状态将是
RanToCompletion
，而不是
Canceled
。选择哪种方式取决于你的业务逻辑。通常，如果取消意味着任务未能完成其预期功能，抛出
OperationCanceledException
是更符合语义的做法。
正确地处理异常和取消，能够让你的异步程序更加稳定、响应迅速，并且易于调试。
以上就是C#的Task类是用来做什么的？如何创建任务？的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1439588.html
微信扫一扫 
支付宝扫一扫 
