C# Task 模式实现 Demo（含运行、暂停、结束状态）

下面是一个完整的 C# Task 实现示例，包含运行(Running)、暂停(Paused)和结束(Completed)状态控制：

1. 基本实现（使用 CancellationToken 控制）

cs 复制代码

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;
}

使用示例

cs 复制代码

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}");
    }
}

输出示例

cs 复制代码

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: Canceled

高级实现（带状态变更事件）

cs 复制代码

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.高级应用：

cs 复制代码

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
        };
    }
}

高级应用输出：

>>> 启动任务

Working... 0

$事件通知$ 任务状态变更为: Running

Working... 1

Working... 2

>>> 暂停任务

Task paused

$事件通知$ 任务状态变更为: Paused

Working... 3

>>> 恢复任务

Task resumed

$事件通知$ 任务状态变更为: Running

Working... 4

Working... 5

>>> 停止任务

Task stopped

$事件通知$ 任务状态变更为: Canceled

>>> 尝试在停止后恢复

$事件通知$ 任务状态变更为: Running