Отмена фоновых задач

Кевин Гейл правильно заявляет, что обработчик DoWork вашего BackgroundWorker должен опрашивать для CancellationPending и вернитесь, если запрошена отмена.

При этом, если это происходит, когда ваше приложение закрывается, вы также можете просто игнорировать это безопасно. BackgroundWorker использует поток ThreadPool, который по определению является фоновым потоком. Оставление этого запущенного не помешает вашему приложению завершить работу, и поток будет автоматически прерван при завершении работы вашего приложения.

Некоторые довольно хорошие предложения, но я не верю, что они решают основную проблему: отмена фоновой задачи.

К сожалению, при использовании 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. ваш основной поток ждет завершения, в отличие от опроса

Очень важно сравнивать и оценивать плюсы и минусы каждого подхода.

Если вы должны контролировать и гарантировать завершение чьих-либо задач, то создание системы управления потоками, включающей вышеупомянутое, может оказаться правильным решением. Однако вы бы потеряли готовые функции, такие как пул потоков, отчеты о ходе выполнения, межпотоковый маршаллинг данных [это делает работник, нет?] И множество других вещей. Не говоря уже о том, что «катание самостоятельно» часто чревато ошибками.

В любом случае, надеюсь, это поможет :)

В фоновом рабочем потоке вам нужно проверить флаг BackgroundWorker.CancellationPending и выйти, если он истинен.

CancelAsync () просто устанавливает этот флаг.

Или, другими словами. CancelAsync () на самом деле ничего не отменяет. Это не прервет поток или не вызовет его выход. Если рабочий поток находится в цикле и периодически проверяет флаг CancellationPending, он может поймать запрос отмены и выйти.

В MSDN есть пример здесь, хотя он не использует цикл в рабочий распорядок.

Этот код гарантированно зайдет в тупик, когда BGW все еще работает. BGW не может завершиться, пока не завершится его событие RunWorkerCompleted. RunWorkerCompleted не может работать, пока поток пользовательского интерфейса не перейдет в режим ожидания и не запустит цикл сообщений. Но поток пользовательского интерфейса не простаивает, он застрял в цикле while.

Если вы хотите, чтобы поток BGW завершился без ошибок, вы должны поддерживать свою форму. Просмотрите эту ветку, чтобы узнать, как это сделать.

Пытаться:

if (this.backgroundWorker1.IsBusy) this.backgroundWorker1.CancelAsync();