通常我会在表单上使用这样的代码：
private void PerformLongRunningOperation()
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate
{
// perform long running operation here
};
worker.RunWorkerAsync();
}
BackgroundWorker的释放，如果我是通过表单设计器添加它的话，它应该会被释放掉。_saveWorker然后从表单的dispose方法中调用Dispose是否更正确？是的，你应该处理背景工作者。
你可能会发现使用ThreadPool.QueueUserWorkItem(...)更容易，因为它不需要任何后续清理操作。
为什么你应该总是调用Dispose()的附加详细信息：
尽管如果你查看BackgroundWorker类，它实际上并没有在其dispose方法中执行任何线程清理，但调用Dispose仍然很重要，因为该类对垃圾回收器的影响。
具有终结器的类不会立即被GC回收。它们被保留并添加到终结器队列中。然后终结器线程运行（遵循标准模式调用dispose）。这意味着对象将存活到GC第1代。而且gen 1集合比gen 0集合要少得多，因此对象在内存中存在的时间更长。
然而，如果你调用Dispose，该对象将不会被添加到终结器队列中，因此可自由进行垃圾回收。
这不是真正的大问题，但如果你正在创建许多对象，则最终会使用比必要更多的内存。通常应始终在具有dispose方法的对象上调用dispose。
所以总的来说，并不是100%的硬性要求。如果你不调用Dispose()，你的应用程序不会爆炸（甚至不会泄漏内存），但在某些情况下可能会产生负面影响。背景工作者是为作为WinForms组件使用而设计的，因此如果你有不同的要求并且不想将其用作WinForms组件，则不要使用它，要使用正确的工具来完成工作，例如ThreadPool。
挑战在于确保只有在 BackgroundWorker 完成运行后才将其释放。你不能在 Completed 事件中这样做，因为该事件是由 BackgroundWorker 自身引发的。
BackgroundWorker 真正意图用于作为 WinForms 表单上的组件，因此我建议您要么这样做，要么切换到像 Thread.QueueUserWorkItem 这样的东西。这将使用一个线程池线程，并且完成后不需要任何特殊的清理。
BackgroundWorker 作为 WinForms 组件使用。 - Brian总的来说，如果它是IDisposable，那么在使用完毕后应该Dispose()。即使当前实现的BackgroundWorker不需要被处理，你也不想被未来可能出现的内部实现所困扰。
IDisposable 的对象上始终调用 Dispose() 的原因。 - Neil Barnwell我觉得没必要担心，BackgroundWorker（后台工作者）只能持有线程（Thread），如果你的委托（delegate）中没有无限循环，那么就没有问题。
BackgroundWorker从Component继承了IDisposable()，但实际上并不需要它。
可以将其与直接将方法推送到线程池（ThreadPool）进行比较。你不能Dispose线程，尤其是来自线程池的线程。
但是，如果你的示例在使用Completed事件或Progress/Cancel特性方面是完整的，那么你也可以使用ThreadPool.QueueUserWorkItem()。
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
using语句是为了不需要try/finally块而方便的。因此，如果编译器内部生成了一个finally，那么在RunWorkerAsync调用之后，finally将立即被调用。 - Brett RyanRunWorkerCompleted事件中调用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();
Dispose会被调用。完成处理程序在原始线程上运行（即不是来自线程池的后台线程）！您的测试结果实际上证实了这个前提。