BackgroundWorkers n'arrête jamais d'être occupé

Votre boucle est à l'origine de l'impasse, l'BGWs ne peut pas terminer. Le problème est le RunWorkerCompleted cas, il est relevé sur le thread d'INTERFACE utilisateur. Que peu de BGW magie nécessite le thread d'INTERFACE utilisateur pour être libre, il doit être le pompage de la boucle de message. Problème, c'est le thread de l'INTERFACE utilisateur n'est pas inactif et il n'est pas de pompage des messages, il est coincé dans la boucle for. Ainsi, le gestionnaire d'événement ne peut pas s'exécuter et IsBusy reste fidèle.

Vous aurez besoin pour ce faire différemment. Tirer parti de la RunWorkerCompleted événement pour exécuter le code que vous auriez normalement à courir après cette boucle for. Résister à toute tentation d'Application d'appel.DoEvents() à l'intérieur de la boucle.

J'ai eu ce même problème lors de l'utilisation de tâches en arrière-plan et est venu à la conclusion que si vous utilisez la fonction sleep() dans une boucle, alors il sera coincé. Vous pouvez soit utiliser le RunWorkerCompleted de l'événement et de définir un indicateur booléen pour indiquer lors de chaque travailleur est fini.

Ou si vous voulez interrompre le fil que vous pouviez regarder à l'aide de threads au lieu de tâches en arrière-plan. Cependant, alors vous perdez la facilité d'utilisation en ce qui concerne les événements qui l'arrière-plan travailleur fournit.

J'ai eu un problème similaire, et ce que j'ai fait pour le résoudre était de joindre la fonction main avec un try... catch... and finally... déclaration.

Le problème est que, quoi que vous fassiez dans worker.RunWorkerAsync() n'est jamais fini. Peut-être qu'il est certaines boucle sans fin ou quelque chose comme ça définis dans votre DoWork événement.

Voici un exemple de travail, qui sélectionne la prochaine travailleur libre:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
private static List<MyWorker> _Workers;
static void Main(string[] args)
{
_Workers = new List<MyWorker>();
for (int i = 0; i < 5; i++)
{
_Workers.Add(CreateDefaultWorker(i));
}
StartJobs(20000);
Console.ReadKey();
}
private static void StartJobs(int runtime)
{
Random rand = new Random();
DateTime startTime = DateTime.Now;
while (DateTime.Now - startTime < TimeSpan.FromMilliseconds(runtime))
{
var freeWorker = GetFreeWorker();
if (freeWorker != null)
{
freeWorker.Worker.RunWorkerAsync(new Action(() => DoSomething(freeWorker.Index, rand.Next(500, 2000))));
}
else
{
Console.WriteLine("No free worker available!");
Console.WriteLine("Waiting for free one...");
WaitForFreeOne();
}
}
}
private static MyWorker GetFreeWorker()
{
foreach (var worker in _Workers)
{
if (!worker.Worker.IsBusy)
return worker;
}
return null;
}
private static void WaitForFreeOne()
{
while (true)
{
foreach (var worker in _Workers)
{
if (!worker.Worker.IsBusy)
return;
}
Thread.Sleep(1);
}
}
private static MyWorker CreateDefaultWorker(int index)
{
var worker = new MyWorker(index);
worker.Worker.DoWork += (sender, e) => ((Action)e.Argument).Invoke();
worker.Worker.RunWorkerCompleted += (sender, e) => Console.WriteLine("Job finished in worker " + worker.Index);
return worker;
}
static void DoSomething(int index, int timeout)
{
Console.WriteLine("Worker {1} starts to work for {0} ms", timeout, index);
Thread.Sleep(timeout);
}
}
public class MyWorker
{
public int Index { get; private set; }
public BackgroundWorker Worker { get; private set; }
public MyWorker(int index)
{
Index = index;
Worker = new BackgroundWorker();
}
}
}