Les travailleurs de fond ne cesseraient jamais d'être occupé

J'ai eu ce même problème tout en utilisant des travailleurs de fond et je suis devenu la conclusion que si vous utilisez le sommeil () dans une boucle, il restera bloqué. Vous pouvez utiliser l'événement d'exécution pondilé et définir un drapeau booléen pour indiquer lorsque chaque travailleur est terminé.

ou si vous voulez abandonner le fil, que vous puissiez regarder à l'aide de threads au lieu des travailleurs de fond. Cependant, vous perdez la facilité d'utilisation en ce qui concerne les événements que le travailleur de fond fournit.

Votre boucle cause une impasse, le BGWS ne peut pas terminer. Le problème est l'événement déroulantPomptez-vous, il est soulevé sur le fil de l'interface utilisateur. Ce bit de BGW Magic nécessite que le fil de l'interface utilisateur soit inactif, il doit s'agenouiller de sa boucle de message. Le problème est que le thread de l'interface utilisateur n'est pas inactif et ce n'est pas pompant des messages, il est bloqué dans la boucle. Ainsi, le gestionnaire d'événements ne peut pas courir et Isbusy reste vrai.

Vous aurez besoin de le faire différemment. Tirez parti de l'événement RunworkerComplet pour exécuter le code que vous exécuteriez normalement après cela pour la boucle. Résistez à toute la tentation d'appeler Application.Deevents () à l'intérieur de la boucle.

Votre fil principal doit pomper les messages Windows (appeler l'application. Doevents dans votre boucle tandis que dans votre boucle ou mieux en utilisant un système.windows.forms.ticer au lieu d'une boucle).

Si vous ne pumpez pas les messages Windows, les notifications «complétées» de votre travailleur de référence ne seront pas traitées, le statut restera occupé.

Le problème est que tout ce que vous faites dans travailleur.runworkerasync () code> ne finit jamais. Peut-être qu'il y a une boucle sans fin ou quelque chose du genre défini dans votre événement dowork code>.

Voici un exemple de travail, qui sélectionne le prochain ouvrier libre: P>

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();
        }
    }
}

J'ai eu un problème similaire et ce que j'ai fait pour résoudre le problème était de mettre la fonction principale avec un essayer ... et enfin ... Déclaration.