WinForms后台Worker实时打印另一任务添加的字符串列表问题

问题场景 #

WinForms开发中，调用第三方API obj.PerformOperation(value, out log) 时，该API会向List<string>持续写入日志内容，需要通过BackgroundWorker实时将新增日志同步到GUI文本框，但现有代码无法实现预期效果。

原API调用代码：

List<string> log = new List<string>();
obj.PerformOperation(value, out log);

尝试的无效代码：

private void configWorker_DoWork(object sender, DoWorkEventArgs e)
{
    List<string> log = new List<string>();
    logWorker.RunWorkerAsync(log);
    obj.PerformOperation(value, out log);
}

private void logWorker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
    BackgroundWorker worker = sender as BackgroundWorker;
    List<string> log = e.Argument as List<string>;
    int log_index = 0;
    do
    {
        this.Invoke(new MethodInvoker(delegate ()
        {
            if (log.Count > log_index)
            {
                do
                {
                    logTextBox.RecordLog(log[log_index++]);
                } while (log_index < log.Count);
            }
        }));
    } while (!worker.CancellationPending);
}

问题根源 #

1. List引用被替换：obj.PerformOperation的out参数会重新赋值log变量，导致logWorker持有的是旧List引用，无法获取新增日志。
2. 循环无意义消耗：logWorker的循环频繁调用Invoke且无延迟，占用大量CPU资源，还可能因线程同步问题导致UI更新不及时。
3. 线程安全隐患：List<string>非线程安全集合，API后台写日志时，logWorker跨线程访问可能引发异常。

解决方案 #

核心思路 #

通过自定义List子类拦截API的日志写入操作，将内容同步到线程安全集合，同时优化BackgroundWorker的监控逻辑，保证UI实时更新且资源占用合理。

修改后的完整代码 #

// 线程安全的日志队列，用于跨线程传递日志
private ConcurrentQueue<string> _logQueue = new ConcurrentQueue<string>();

private void configWorker_DoWork(object sender, DoWorkEventArgs e)
{
    // 自定义List子类，拦截Add操作同步到队列
    var interceptLog = new InterceptList<string>(item => _logQueue.Enqueue(item));
    // 启动日志监控Worker，传入线程安全队列
    logWorker.RunWorkerAsync(_logQueue);
    // 调用API，此时API写入的日志会被同步到队列
    obj.PerformOperation(value, out interceptLog);
}

// 自定义List子类，拦截Add/AddRange操作
public class InterceptList<T> : List<T>
{
    private readonly Action<T> _onAdd;

    public InterceptList(Action<T> onAdd)
    {
        _onAdd = onAdd;
    }

    public new void Add(T item)
    {
        base.Add(item);
        _onAdd?.Invoke(item);
    }

    public new void AddRange(IEnumerable<T> collection)
    {
        base.AddRange(collection);
        foreach (var item in collection)
        {
            _onAdd?.Invoke(item);
        }
    }
}

private void logWorker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
    BackgroundWorker worker = sender as BackgroundWorker;
    ConcurrentQueue<string> logQueue = e.Argument as ConcurrentQueue<string>;
    
    while (!worker.CancellationPending)
    {
        if (logQueue.TryDequeue(out string logItem))
        {
            // 异步更新UI，避免阻塞后台线程
            this.BeginInvoke(new MethodInvoker(delegate ()
            {
                logTextBox.RecordLog(logItem);
            }));
        }
        else
        {
            // 无新日志时短暂休眠，降低CPU消耗
            Thread.Sleep(100);
        }
    }
}

// 任务完成后终止日志监控Worker
private void configWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (logWorker.IsBusy)
    {
        logWorker.CancelAsync();
    }
}

关键说明 #

• 拦截List写入：自定义InterceptList子类，拦截API对List的Add/AddRange操作，将日志同步到ConcurrentQueue，规避out参数替换引用的问题。
• 线程安全保障：使用ConcurrentQueue处理多线程读写，避免并发访问异常。
• UI优化：用BeginInvoke异步更新UI，避免阻塞后台线程；无新日志时休眠100ms，减少CPU占用。
• 生命周期管理：在任务完成后终止logWorker，避免线程泄漏。

内容的提问来源于stack exchange，提问作者Grant Dare