当我的 C# 应用程序关闭时，它有时会陷入清理例程。具体来说，后台工作人员没有关闭。这基本上就是我试图关闭它的方式:

<罢工> private void App_FormClosing(object sender, FormClosingEventArgs e) { backgroundWorker1.CancelAsync(); while (backgroundWorker1.IsBusy) ;//卡在这里。 }

我应该采用其他方式吗？我正在使用 Microsoft Visual C# 2008 Express Edition。谢谢。

附加信息:

后台工作人员似乎没有退出。这是我的:

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
   while (!backgroundWorker1.CancellationPending)
   {
      // Do something.
   }
}

我还修改了清理代码:

private void App_FormClosing(object sender, FormClosingEventArgs e)
{
   while (backgroundWorker1.IsBusy)
   {
      backgroundWorker1.CancelAsync();
      System.Threading.Thread.Sleep(1000);
   }
}

还有什么我应该做的吗？

最佳答案

一些非常好的建议，但我认为它们没有解决根本问题:取消后台任务。

不幸的是，当使用 BackgroundWorker 时，任务的终止取决于任务本身。您的 while 循环终止的唯一方式是，如果您的后台任务检查其 Cancel 属性并返回或中断其当前进程。

示例库

例如，考虑

private readonly BackgroundWorker worker = new BackgroundWorker ();

public void SomeFormEventForStartingBackgroundTask ()
{
    worker.DoWork += BackgroundTask_HotelCalifornia;
    worker.WorkerSupportsCancellation = true;
    worker.RunWorkerAsync ();
}

// semantically, you want to perform this task for lifetime of
// application, you may even expect that calling CancelAsync
// will out and out abort this method - that is incorrect.
// CancelAsync will only set DoWorkEventArgs.Cancel property
// to true
private void BackgroundTask_HotelCalifornia (object sender, DoWorkEventArgs e)
{
    for ( ; ;)
    {
        // because we never inspect e.Cancel, we can never leave!
    }
}

private void App_FormClosing(object sender, FormClosingEventArgs e)     
{
    // [politely] request termination
    worker.CancelAsync();

    // [politely] wait until background task terminates
    while (worker.IsBusy);
}

这是默认情况下发生的情况。现在，也许您的任务不是无限循环，也许它只是一个长时间运行的任务。无论哪种方式，您的主线程都会阻塞 [实际上它正在旋转，但无论如何] 直到任务完成，或者不完成。

如果您亲自编写并可以修改任务，那么您有几个选择。

示例改进

例如，这是上面例子的一个更好的实现

private readonly BackgroundWorker worker = new BackgroundWorker ();

// this is used to signal our main Gui thread that background
// task has completed
private readonly AutoResetEvent isWorkerStopped = 
    new AutoResentEvent (false);

public void SomeFormEventForStartingBackgroundTask ()
{
    worker.DoWork += BackgroundTask_HotelCalifornia;
    worker.RunWorkerCompleted += BackgroundTask_Completed;
    worker.WorkerSupportsCancellation = true;
    worker.RunWorkerAsync ();
}

private void BackgroundTask_HotelCalifornia (object sender, DoWorkEventArgs e)
{
    // execute until canceled
    for ( ; !e.Cancel;)
    {
        // keep in mind, this task will *block* main
        // thread until cancel flag is checked again,
        // so if you are, say crunching SETI numbers 
        // here for instance, you could still be blocking
        // a long time. but long time is better than 
        // forever ;)
    }
}

private void BackgroundTask_Completed (
    object sender, 
    RunWorkerCompletedEventArgs e)
{
    // ok, our task has stopped, set signal to 'signaled' state
    // we are complete!
    isStopped.Set ();
}

private void App_FormClosing(object sender, FormClosingEventArgs e)     
{
    // [politely] request termination
    worker.CancelAsync();

    // [politely] wait until background task terminates
    isStopped.WaitOne ();
}

虽然这更好，但还没有达到预期的那么好。如果您可以 [合理地] 确信您的后台任务将结束，这可能“足够好”。

然而，我们[通常]想要的是这样的

private void App_FormClosing(object sender, FormClosingEventArgs e)     
{
    // [politely] request termination
    worker.CancelAsync();

    // [politely] wait until background task terminates
    TimeSpan gracePeriod = TimeSpan.FromMilliseconds(100);
    bool isStoppedGracefully = isStopped.WaitOne (gracePeriod);

    if (!isStoppedGracefully)
    {
        // KILL! KILL! KILL!
    }
}

唉，我们不能。 BackgroundWorker 不公开任何强制终止的方法。这是因为它是建立在一些隐藏的线程管理系统之上的抽象，如果它被强行终止，它可能会破坏应用程序的其他部分。

实现上述内容的唯一方法 [我至少看到] 是管理您自己的线程。

示例理想

比如说

private Thread worker = null;

// this time, 'Thread' provides all synchronization
// constructs required for main thread to synchronize
// with background task. however, in the interest of
// giving background task a chance to terminate gracefully
// we supply it with this cancel signal
private readonly AutoResetEvent isCanceled = new AutoResentEvent (false);

public void SomeFormEventForStartingBackgroundTask ()
{
    worker = new Thread (BackgroundTask_HotelCalifornia);
    worker.IsBackground = true;
    worker.Name = "Some Background Task"; // always handy to name things!
    worker.Start ();
}

private void BackgroundTask_HotelCalifornia ()
{
    // inspect cancel signal, no wait period
    // 
    // NOTE: so cheating here a bit, this is an instance variable
    // but could as easily be supplied via parameterized thread
    // start delegate
    for ( ; !isCanceled.WaitOne (0);)
    {
    }
}

private void App_FormClosing(object sender, FormClosingEventArgs e)     
{
    // [politely] request termination
    isCanceled.Set ();

    // [politely] wait until background task terminates
    TimeSpan gracePeriod = TimeSpan.FromMilliseconds(100);
    bool isStoppedGracefully = worker.Join (gracePeriod);

    if (!isStoppedGracefully)
    {
        // wipe them out, all of them.
        worker.Abort ();
    }
}

在那里，有一个关于线程管理的不错的介绍。

哪个最适合你？取决于您的应用程序。最好不要打破常规，修改您当前的实现以确保

1. 您的后台任务检查并遵守 Cancel 属性
2. 你的主线程等待完成，而不是轮询

比较和评估每种方法的优缺点非常重要。

如果您必须控制并保证终止其他人的任务，那么编写一个包含上述内容的线程管理系统可能是可行的方法。但是，您会失去开箱即用的功能，例如线程池、进度报告、跨线程数据编码 [worker 会那样做，不是吗？]，以及许多其他东西。更不用说，“自己动手”通常很容易出错。

无论如何，希望这对您有所帮助:)

关于c# - 取消后台任务，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2411360/