C#调试模式下如何让多任务串行执行（少用编译器开关）

需求背景 #

发布版代码中，所有计划任务由Task调度器管理，可在任意线程执行，任务间无依赖或并发问题。当前实现是启动所有任务后等待完成，但调试时频繁的上下文切换十分麻烦，冻结线程的方式在任务较多时仍不便。希望在调试模式下强制任务串行执行，且尽量少用编译器开关。目前通过派生类加编译器开关实现此需求，但想寻求更便捷的方案；了解TaskScheduler.FromCurrentSynchronizationContext()，但不确定即使在主线程是否仍会切换任务。

当前并行执行实现 #

public void Run()
{
    foreach (var task in this.Tasks)
    {
        task.Start();
    }

    var runningTasks = this.Tasks.ToArray();

    var completedTasks = new List<Task>();

    while (runningTasks.Any())
    {
        try
        {
            var taskIndex = Task.WaitAny(runningTasks, this.ParentCancellationToken);

            var task = runningTasks[taskIndex];

            completedTasks.Add(task);

            if (task.IsFaulted)
            {
                this.CancelGroup(runningTasks);
            }

            runningTasks = this.Tasks
                .Except(completedTasks)
                .ToArray();
        }
        catch (OperationCanceledException) //happens in WaitAny() when _parentCancellationToken is cancelled
        {
            this.CancelGroup(runningTasks);

            break;
        }
    }
}

当前调试串行实现 #

public override void Run()
{
    foreach (var task in this.Tasks)
    {
        task.Start();

        var runningTasks = new List<Task> { task };

        while (!task.IsCompleted)
        {
            if (this.ParentCancellationToken.IsCancellationRequested)
            {
                this.CancelGroup(runningTasks);

                return;
            }

            Thread.Sleep(100);
        }

        if (task.IsFaulted)
        {
            this.CancelGroup(runningTasks);
        }
    }
}

核心疑问解答 #

使用task.Start(TaskScheduler.FromCurrentSynchronizationContext());是否仍会出现任务切换？ #

会出现任务切换，原因如下：

• 如果当前是WinForms/WPF主线程，该调度器会将任务放入UI消息队列，主线程会在处理任务的间隙处理其他UI消息（如鼠标点击、重绘），导致任务执行被打断，产生上下文切换。
• 如果当前是无同步上下文的普通线程（如控制台线程），该调度器会回退到默认线程池调度器，任务仍会并行执行，达不到串行目的。

更便捷的优化方案 #

方案1：基于调试状态自动切换执行模式（无编译器开关） #

利用Debugger.IsAttached在运行时判断是否处于调试状态，调试时同步执行任务，发布版保持并行：

public void Run()
{
    if (Debugger.IsAttached)
    {
        // 调试模式：串行同步执行，无线程切换
        foreach (var task in this.Tasks)
        {
            if (ParentCancellationToken.IsCancellationRequested)
            {
                CancelGroup(new[] { task });
                return;
            }

            try
            {
                task.RunSynchronously(); // 在当前线程同步执行任务
            }
            catch
            {
                if (task.IsFaulted)
                {
                    CancelGroup(new[] { task });
                    return;
                }
                throw;
            }
        }
    }
    else
    {
        // 发布版：原并行执行逻辑
        foreach (var task in this.Tasks)
        {
            task.Start();
        }

        var runningTasks = this.Tasks.ToArray();
        var completedTasks = new List<Task>();

        while (runningTasks.Any())
        {
            try
            {
                var taskIndex = Task.WaitAny(runningTasks, this.ParentCancellationToken);
                var task = runningTasks[taskIndex];

                completedTasks.Add(task);

                if (task.IsFaulted)
                {
                    CancelGroup(runningTasks);
                }

                runningTasks = this.Tasks.Except(completedTasks).ToArray();
            }
            catch (OperationCanceledException)
            {
                CancelGroup(runningTasks);
                break;
            }
        }
    }
}

该方案优势：无需派生类，无额外线程，调试时任务在当前线程连续执行，完全避免上下文切换，调试体验最佳。

方案2：自定义单线程调度器（保留异步语义） #

如果需要保留Task的异步执行语义但强制串行，可实现自定义单线程调度器，调试时启用：

public class SingleThreadTaskScheduler : TaskScheduler
{
    private readonly Queue<Task> _tasks = new Queue<Task>();
    private readonly Thread _executionThread;
    private bool _isRunning = true;

    public SingleThreadTaskScheduler()
    {
        _executionThread = new Thread(ProcessTaskQueue) { IsBackground = true };
        _executionThread.Start();
    }

    protected override void QueueTask(Task task)
    {
        lock (_tasks)
        {
            _tasks.Enqueue(task);
            Monitor.Pulse(_tasks);
        }
    }

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        return Thread.CurrentThread == _executionThread && TryExecuteTask(task);
    }

    protected override IEnumerable<Task> GetScheduledTasks()
    {
        lock (_tasks)
        {
            return _tasks.ToList();
        }
    }

    private void ProcessTaskQueue()
    {
        while (_isRunning)
        {
            Task task;
            lock (_tasks)
            {
                while (_tasks.Count == 0 && _isRunning)
                {
                    Monitor.Wait(_tasks);
                }
                if (!_isRunning) break;
                task = _tasks.Dequeue();
            }
            TryExecuteTask(task);
        }
    }

    public void Shutdown()
    {
        lock (_tasks)
        {
            _isRunning = false;
            Monitor.Pulse(_tasks);
        }
        _executionThread.Join();
    }
}

在Run方法中切换调度器：

public void Run()
{
    TaskScheduler targetScheduler = Debugger.IsAttached ? new SingleThreadTaskScheduler() : TaskScheduler.Default;

    foreach (var task in this.Tasks)
    {
        task.Start(targetScheduler);
    }

    try
    {
        Task.WaitAll(this.Tasks.ToArray(), ParentCancellationToken);
    }
    catch (OperationCanceledException)
    {
        CancelGroup(this.Tasks.ToArray());
    }
    catch (AggregateException)
    {
        CancelGroup(this.Tasks.ToArray());
        // 按需处理异常
    }
}

该方案优势：保留Task异步执行的封装性，调试时所有任务在单独线程串行执行，避免线程池上下文切换，适合需要模拟异步流程的调试场景。

内容的提问来源于stack exchange，提问作者Dee J. Doena