下面是一个完整的 C# Task 实现示例，包含运行(Running)、暂停(Paused)和结束(Completed)状态控制：
1. 基本实现（使用 CancellationToken 控制）
using System;
using System.Threading;
using System.Threading.Tasks;
public class TaskStateDemo
{
private CancellationTokenSource _cts;
private PauseTokenSource _pts;
private Task _task;
private bool _isRunning;
public enum TaskStatus
{
NotStarted,
Running,
Paused,
Completed,
Canceled
}
public TaskStatus CurrentStatus { get; private set; } = TaskStatus.NotStarted;
// 启动任务
public void Start()
{
if (_isRunning) return;
_cts = new CancellationTokenSource();
_pts = new PauseTokenSource();
_isRunning = true;
CurrentStatus = TaskStatus.Running;
_task = Task.Run(async () =>
{
try
{
int counter = 0;
while (!_cts.IsCancellationRequested)
{
Console.WriteLine($"Working... {counter++}");
// 检查暂停状态
await _pts.Token.WaitWhilePausedAsync();
await Task.Delay(1000, _cts.Token); // 模拟工作
}
CurrentStatus = TaskStatus.Completed;
}
catch (OperationCanceledException)
{
CurrentStatus = TaskStatus.Canceled;
}
finally
{
_isRunning = false;
}
}, _cts.Token);
}
// 暂停任务
public void Pause()
{
if (!_isRunning || CurrentStatus == TaskStatus.Paused) return;
_pts?.Pause();
CurrentStatus = TaskStatus.Paused;
Console.WriteLine("Task paused");
}
// 恢复任务
public void Resume()
{
if (!_isRunning || CurrentStatus != TaskStatus.Paused) return;
_pts?.Resume();
CurrentStatus = TaskStatus.Running;
Console.WriteLine("Task resumed");
}
// 停止任务
public async Task StopAsync()
{
if (!_isRunning) return;
_cts?.Cancel();
await (_task ?? Task.CompletedTask);
Console.WriteLine("Task stopped");
}
}
// 暂停令牌实现
public class PauseTokenSource
{
private volatile TaskCompletionSource<bool> _paused;
public PauseToken Token => new PauseToken(this);
public bool IsPaused => _paused != null;
public void Pause()
{
if (_paused == null)
Interlocked.CompareExchange(ref _paused, new TaskCompletionSource<bool>(), null);
}
public void Resume()
{
while (true)
{
var tcs = _paused;
if (tcs == null) return;
if (Interlocked.CompareExchange(ref _paused, null, tcs) == tcs)
{
tcs.SetResult(true);
break;
}
}
}
public Task WaitWhilePausedAsync()
{
var cur = _paused;
return cur != null ? cur.Task : Task.CompletedTask;
}
}
public struct PauseToken
{
private readonly PauseTokenSource _source;
public PauseToken(PauseTokenSource source) => _source = source;
public bool IsPaused => _source?.IsPaused ?? false;
public Task WaitWhilePausedAsync() =>
_source?.WaitWhilePausedAsync() ?? Task.CompletedTask;
}2. 使用示例
class Program
{
static async Task Main(string[] args)
{
var demo = new TaskStateDemo();
Console.WriteLine("Starting task...");
demo.Start();
await Task.Delay(3000);
Console.WriteLine($"Status: {demo.CurrentStatus}");
Console.WriteLine("Pausing task...");
demo.Pause();
await Task.Delay(2000);
Console.WriteLine($"Status: {demo.CurrentStatus}");
Console.WriteLine("Resuming task...");
demo.Resume();
await Task.Delay(3000);
Console.WriteLine($"Status: {demo.CurrentStatus}");
Console.WriteLine("Stopping task...");
await demo.StopAsync();
Console.WriteLine($"Final Status: {demo.CurrentStatus}");
}
}3. 输出示例
Starting task...
Working... 0
Working... 1
Working... 2
Status: Running
Pausing task...
Task paused
Status: Paused
Resuming task...
Task resumed
Working... 3
Working... 4
Working... 5
Status: Running
Stopping task...
Final Status: Canceled4. 高级实现（带状态变更事件）
public class AdvancedTaskStateDemo : TaskStateDemo
{
public event EventHandler<TaskStatus> StatusChanged;
private new TaskStatus CurrentStatus
{
get => base.CurrentStatus;
set
{
base.CurrentStatus = value;
StatusChanged?.Invoke(this, value);
}
}
public new void Start()
{
base.Start();
CurrentStatus = TaskStatus.Running;
}
public new void Pause()
{
base.Pause();
CurrentStatus = TaskStatus.Paused;
}
public new void Resume()
{
base.Resume();
CurrentStatus = TaskStatus.Running;
}
public new async Task StopAsync()
{
await base.StopAsync();
CurrentStatus = _cts.IsCancellationRequested ?
TaskStatus.Canceled : TaskStatus.Completed;
}
}5.高级应用：
using System;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var taskController = new AdvancedTaskStateDemo();
// 订阅状态变更事件
taskController.StatusChanged += (sender, status) =>
{
Console.ForegroundColor = GetStatusColor(status);
Console.WriteLine($"[事件通知] 任务状态变更为: {status}");
Console.ResetColor();
};
// 1. 启动任务
Console.WriteLine(">>> 启动任务");
taskController.Start();
await Task.Delay(2500); // 让任务运行2.5秒
// 2. 暂停任务
Console.WriteLine("\n>>> 暂停任务");
taskController.Pause();
await Task.Delay(2000); // 暂停2秒
// 3. 恢复任务
Console.WriteLine("\n>>> 恢复任务");
taskController.Resume();
await Task.Delay(3000); // 运行3秒
// 4. 停止任务
Console.WriteLine("\n>>> 停止任务");
await taskController.StopAsync();
// 5. 尝试在停止后恢复（应无效）
Console.WriteLine("\n>>> 尝试在停止后恢复");
taskController.Resume(); // 不会有任何效果
}
private static ConsoleColor GetStatusColor(TaskStateDemo.TaskStatus status)
{
return status switch
{
TaskStateDemo.TaskStatus.Running => ConsoleColor.Green,
TaskStateDemo.TaskStatus.Paused => ConsoleColor.Yellow,
TaskStateDemo.TaskStatus.Completed => ConsoleColor.Blue,
TaskStateDemo.TaskStatus.Canceled => ConsoleColor.Red,
_ => ConsoleColor.White
};
}
}6. 高级应用输出：
>>> 启动任务
Working... 0
[事件通知] 任务状态变更为: Running
Working... 1
Working... 2
>>> 暂停任务
Task paused
[事件通知] 任务状态变更为: Paused
Working... 3
>>> 恢复任务
Task resumed
[事件通知] 任务状态变更为: Running
Working... 4
Working... 5
>>> 停止任务
Task stopped
[事件通知] 任务状态变更为: Canceled
>>> 尝试在停止后恢复
[事件通知] 任务状态变更为: Running