C#：我需要处置在运行时创建的BackgroundWorker吗？

Question

我通常在表单上有这样的代码：

    private void PerformLongRunningOperation()
    {
        BackgroundWorker worker = new BackgroundWorker();

        worker.DoWork += delegate
        {
            // perform long running operation here
        };

        worker.RunWorkerAsync();
    }

这意味着我不会处置 BackgroundWorker，而如果我由表单设计者添加它，那么我认为它会被处置。

这会导致任何问题吗？声明一个模块级 _saveWorker，然后从表单的 dispose 方法中调用 Dispose 是否更正确？

Answer 1

是的，你应该处理掉后台工作者。

您可能会发现使用 ThreadPool.QueueUserWorkItem(...) 更容易，之后不需要任何清理。

---

关于为什么应该始终调用 Dispose() 的其他详细信息：

虽然如果您查看 BackgroundWorker 类，它实际上并没有在其 dispose 方法中执行任何线程清理，但调用 Dispose 仍然很重要，因为该类对垃圾收集器。

带有终结器的类不会立即被 GC 处理。它们被保留并添加到终结器队列中。然后，终结器线程运行（遵循标准模式调用 dispose）。这意味着该对象将在 GC 第 1 代中存活。第 1 代收集比第 0 代收集少得多，因此对象在内存中停留的时间更长。

然而，如果您调用 Dispose()，该对象将不会被添加到终结队列中，因此可以自由地被垃圾收集。

这并不是什么大问题，但如果您创建很多它们，您最终会使用比必要的更多的内存。始终对具有 dispose 方法的对象调用 dispose 确实应该被视为良好实践。

所以我想，总而言之，这不是一个 100% 硬性要求。如果您不调用 Dispose()，您的应用程序不会爆炸（甚至泄漏内存），但在某些情况下可能会产生负面影响。后台工作程序被设计为用作 WinForms 组件，因此以这种方式使用它，如果您有不同的要求并且不想将其用作 WinForms 组件，请不要使用它，请使用正确的工具来完成工作，就像线程池一样。

Answer 2

挑战在于确保仅在 BackgroundWorker 运行完毕后对其进行处置。您不能在 Completed 事件中执行此操作，因为该事件是由 BackgroundWorker 本身引发的。

BackgroundWorker 实际上是用作 WinForms 表单上的组件，因此我建议要么这样做，要么切换到 Thread.QueueUserWorkItem 之类的东西。这将使用线程池线程，并且完成后不需要任何特殊的清理。

Answer 3

在我看来，一般来说，如果它是 IDisposable，那么当你完成它时，它应该是 Dispose()d。即使从技术上讲，BackgroundWorker 的当前实现不需要被处置，您也不希望对以后可能需要处置的内部实现感到惊讶。

Answer 4

我不会打扰，Bgw 可以保留的唯一资源是线程，如果您的委托中没有无限循环，那么就可以了。

BackgroundWorker 从 Component 继承了 IDisposable() ，但实际上并不需要它。

将其与直接将方法推送到线程池进行比较。您不（不能）处置线程，当然不能处置池中的线程。

但是，如果您的示例是完整的，即您没有使用 Completed 事件或 Progress/Cancel 功能，那么您也可以使用 ThreadPool.QueueUserWorkItem() 。

Answer 5

为什么不包含在 using 语句中？不需要太多额外的努力，你就得到了处置：

private void PerformLongRunningOperation()
    {
        using (BackgroundWorker worker = new BackgroundWorker())
        {
            worker.DoWork += delegate
                             {
                                 // perform long running operation here 
                             };
            worker.RunWorkerAsync();
        }
    }

编辑：

好吧，我做了一个小测试，看看处置发生了什么以及什么：

using System;
using System.ComponentModel;
using System.Threading;

namespace BackgroundWorkerTest
{
    internal class Program
    {
        private static BackgroundWorker _privateWorker;

        private static void Main()
        {
            PrintThread("Main");
            _privateWorker = new BackgroundWorker();
            _privateWorker.DoWork += WorkerDoWork;
            _privateWorker.RunWorkerCompleted += WorkerRunWorkerCompleted;
            _privateWorker.Disposed += WorkerDisposed;
            _privateWorker.RunWorkerAsync();
            _privateWorker.Dispose();
            _privateWorker = null;

            using (var BW = new BackgroundWorker())
            {
                BW.DoWork += delegate
                                 {
                                     Thread.Sleep(2000);
                                     PrintThread("Using Worker Working");
                                 };
                BW.Disposed += delegate { PrintThread("Using Worker Disposed"); };
                BW.RunWorkerCompleted += delegate { PrintThread("Using Worker Completed"); };
                BW.RunWorkerAsync();
            }

            Console.ReadLine();
        }

        private static void WorkerDisposed(object sender, EventArgs e)
        {
            PrintThread("Private Worker Disposed");
        }

        private static void WorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            PrintThread("Private Worker Completed");
        }

        private static void WorkerDoWork(object sender, DoWorkEventArgs e)
        {
            Thread.Sleep(2000);
            PrintThread("Private Worker Working");
        }

        private static void PrintThread(string caller)
        {
            Console.WriteLine("{0} Thread: {1}", caller, Thread.CurrentThread.ManagedThreadId);
        }
    }
}

这是输出：

Main Thread: 1
Private Worker Disposed Thread: 1
Using Worker Disposed Thread: 1
Private Worker Working Thread: 3
Using Worker Working Thread: 4
Using Worker Completed Thread: 4
Private Worker Completed Thread: 3

从一些测试来看，Dispose() 基本上没有对已启动的BackgroundWorker 的影响。无论您是否在 using 语句的范围内调用它，或者使用在代码中声明的它并立即处置它并取消引用它，它仍然正常运行。 Dispose 事件发生在主线程上，DoWork 和 RunWorkerCompleted 发生在线程池线程上（事件触发时可用的线程）。我尝试了一种情况，在调用 Dispose 之后（因此在 DoWork 有机会完成之前）立即注销了 RunWorkerCompleted 事件，并且 RunWorkerCompleted 没有触发。这让我相信，尽管 BackgroundWorker 对象已被释放，您仍然可以对其进行操作。

因此，正如其他人所提到的，此时似乎确实不需要调用 Dispose。然而，至少从我的经验和这些测试来看，我也不认为这样做有什么坏处。

Answer 6

在 RunWorkerCompleted 事件中调用 dispose。

BackgroundWorker wkr = new BackgroundWorker();
wkr.DoWork += (s, e) => {
    // Do long running task.
};
wkr.RunWorkerCompleted += (s, e) => {
    try {
        if (e.Error != null) {
            // Handle failure.
        }
    } finally {
        // Use wkr outer instead of casting.
        wkr.Dispose();
    }
};
wkr.RunWorkerAsync();

额外的 try/finally 是为了确保在完成代码引发异常时调用 Dispose。

Answer 7

为所有 IDisposable 对象调用 Dispose() 被认为是最佳实践。这允许他们释放他们可能持有的非托管资源，例如句柄。 IDisposable 类还应该具有终结器，它的存在会延迟 GC 完全收集这些对象的时间。

如果您的类分配了 IDisposable 并将其分配给成员变量，那么通常它本身也应该是 IDisposable。

但是，如果不调用Dispose()，那么Finalizer最终会被调用，资源最终会被清理掉。显式调用它的优点是这些事情可以更快地发生并且开销更少，从而提高应用程序性能并减少内存压力。

Answer 8

完成处理程序在原始线程上运行（即，不是线程池中的后台线程）！你的测试结果实际上证实了这个前提。