Как полностью убить фонового рабочего?

Вы можете использовать что-то вроде этого (для получения дополнительной информации о прерывании управляемых потоков и об исключении ThreadAbortException см. "Анализ глубины исключения ThreadAbortException с помощью ротора "Криса Селлса):

public class AbortableBackgroundWorker : BackgroundWorker
{

    private Thread workerThread;

    protected override void OnDoWork(DoWorkEventArgs e)
    {
        workerThread = Thread.CurrentThread;
        try
        {
            base.OnDoWork(e);
        }
        catch (ThreadAbortException)
        {
            e.Cancel = true; //We must set Cancel property to true!
            Thread.ResetAbort(); //Prevents ThreadAbortException propagation
        }
    }


    public void Abort()
    {
        if (workerThread != null)
        {
            workerThread.Abort();
            workerThread = null;
        }
    }
}

Использование:

backgroundWorker1 = new AbortableBackgroundWorker();
//...
backgroundWorker1.RunWorkerAsync();

if (backgroundWorker1.IsBusy == true)
{
    backgroundWorker1.Abort();
    backgroundWorker1.Dispose();
}

Я считаю, что потоки должны нести ответственность за свои собственные ресурсы, насколько это возможно, включая свое время жизни.

Как правило, убивать потоки за пределами их области - плохая идея. Приложения, которые спроектированы для передачи сообщения потоку для самого выключения, как правило, имеют гораздо меньше проблем, связанных с многопоточным поведением.

Поток должен своевременно отслеживать указанное сообщение, которое может быть таким простым, как логическое значение, установленное другим потоком и прочитанное этим потоком мониторинга, и закрывать себя чисто как можно скорее.

Это означает, что если он должен искать сообщение:

• в основном цикле, если таковой имеется.
• периодически в любых долгоиграющих петлях.

Поток, завершающий его с сообщением, должен подождать (но, конечно, не останавливайте графический интерфейс).

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

Но все же обычно проще просто спроектировать свое приложение так, чтобы он оставил мастера потоков своей собственной судьбе.

У меня была та же проблема, я не уверен, поможет ли это, но я предполагаю, что у вашего фонового рабочего есть цикл внутри, или он выйдет. Что вам нужно сделать, так это поместить свой цикл внутрь.

Поместите внутрь своего фонового рабочего:

while (backgroundworker1.CancellationPending == false)
{
    //Put your code in here
}

Чтобы убить этого фонового работника, вы можете вставить свою кнопку:

BackgroundWorker1.CancelAsync()

Надеюсь, это поможет.

Я собрал один, который (я думаю) выполняет свою работу. Пожалуйста, дайте мне знать, если я отключился. Вот простой пример того, как это работает.

var backgroundWorker = new BackgroundWorker(){WorkerSupportsCancellation = true};

backgroundWorker.DoWork += (sender, args) =>
         {                 
                 var thisWorker = sender as BackgroundWorker;
                 var _child = new Thread(() =>
                                               {
                                                   //..Do Some Code

                                               });
                 _child .Start();
                 while (_child.IsAlive)
                 {
                     if (thisWorker.CancellationPending)
                     {
                         _child.Abort();
                         args.Cancel = true;
                     }
                     Thread.SpinWait(1);
                 }                 
         };

 backgroundWorker.RunWorkerAsync(parameter);
 //..Do Something...
backgroundWorker.CancelAsync();

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

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

я просто использую «возврат», чтобы перейти к концу потока:

private void myWorker_DoWork(object sender, DoWorkEventArgs e)
{
   // some variables 

   while(true)
   {
      // do something ...
      if(need_cancel) return;
      else doSomeThingElse();
   }

   // may be more code here (ignored if 'return' is executed) ...
   // .........
   // .........
}

public class abortableBackgroundworker: BackgroundWorker
{
    public bool Kill = false;

    protected override void OnDoWork(DoWorkEventArgs e)
    {


        var _child = new Thread(() =>
        {
            while (!Kill)
            {

            }
            e.Cancel = true;//..Do Some Code

        });
        _child.Start();
        base.OnDoWork(e);

    }



}

вы устанавливаете kill в true, чтобы убить поток и не прерывать проблему :)