BackgroundWorker vs Thread d'arrière-plan

quelques-unes de mes pensées...

1. Utiliser BackgroundWorker si vous avez une seule tâche qui s'exécute en arrière-plan et besoin d'interagir avec l'INTERFACE utilisateur. La tâche de regrouper les appels de données et de méthodes dans le thread de L'interface utilisateur est gérée automatiquement par le biais de son modèle basé sur les événements. Eviter le BackgroundWorker si...
   • votre assemblée n'ont pas ou n'interagit pas directement avec l'INTERFACE utilisateur,
   • vous avez besoin le fil doit être un fil à l'avant-plan, ou
   • vous devez manipuler la priorité du fil.
2. Utiliser un pool de threads fil lorsque l'efficacité est souhaitée. Le ThreadPool permet d'éviter les frais généraux associés à la création, au démarrage et à l'arrêt des threads. Évitez D'utiliser le ThreadPool si...
   • la tâche s'exécute pour la durée de vie de votre application,
   • vous avez besoin de la thread un thread de premier plan,
   • vous devez manipuler la priorité du fil, ou
   • vous avez besoin du fil pour avoir une identité fixe (avorter, suspendre, découvrir).
3. utilisez la classe Thread pour les tâches de longue durée et lorsque vous avez besoin de fonctionnalités offertes par un modèle de filetage formel, par exemple, le choix entre les fils de premier plan et de fond, le réglage de la priorité du filetage, contrôle fin sur l'exécution du fil, etc.

à peu près ce que Matt Davis a dit, avec les points supplémentaires suivants:

pour moi, le principal différenciateur avec BackgroundWorker est la formation automatique de l'événement complété via le SynchronizationContext . Dans un contexte D'interface utilisateur, cela signifie que l'événement terminé s'allume sur le thread D'interface utilisateur, et peut donc être utilisé pour mettre à jour L'interface utilisateur. Il s'agit d'un différenciateur majeur si vous utilisez le BackgroundWorker dans un contexte D'UI.

les tâches exécutées via le ThreadPool ne peuvent pas être facilement annulé (Cela inclut ThreadPool . QueueUserWorkItem et les délégués exécutent de manière asynchrone). Ainsi, alors qu'il évite la tête de fil de spinup, si vous avez besoin d'annulation soit utiliser un BackgroundWorker ou (plus probablement en dehors de L'UI) de spin up un fil et garder une référence à elle de sorte que vous pouvez appeler Abort() .

vous aussi vous attachez un fil threadpool pour la vie de l'ouvrier de fond, qui peut être de préoccupation car il n'y a qu'un nombre fini d'entre eux. Je dirais que si vous ne créez le thread qu'une seule fois pour votre application (et n'utilisez aucune des fonctionnalités de background worker), alors utilisez un thread, plutôt qu'un backgroundworker/threadpool thread.

vous savez, parfois, il est juste plus facile de travailler avec un travailleur de fond peu importe si vous utilisez des formulaires Windows, WPF ou n'importe quelle technologie. La partie soignée à propos de ces gars est que vous obtenez filetage sans avoir à se soucier trop de l'endroit où vous êtes fil est l'exécution, ce qui est idéal pour les tâches simples.

avant d'utiliser un BackgroundWorker considérer d'abord si vous souhaitez annuler un thread (fermeture de l'application, annulation de l'utilisateur), alors vous devez décider si votre thread devrait vérifiez pour les annulations ou si elle doit être poussée à l'exécution elle-même.

BackgroundWorker.CancelAsync() réglera CancellationPending à true mais ne fera plus rien, il est alors de la responsabilité des threads de vérifier en permanence cela, gardez à l'esprit également que vous pourriez finir avec une condition de course dans cette approche où votre Utilisateur a annulé, mais le thread terminé avant les tests pour CancellationPending .

Thread.Abort() d'autre part lancera un exception dans l'exécution thread qui impose l'annulation de ce thread, vous devez faire attention à ce qui pourrait être dangereux si cette exception était soudainement soulevée dans l'exécution cependant.

programmation parallèle dans le cadre. net Géré Filetage Meilleures Pratiques

j'ai su utiliser les threads avant de savoir.net, donc il a fallu que je m'habitue quand j'ai commencé à utiliser BackgroundWorkers. Matt Davis a résumé la différence avec beaucoup d'excellence, mais j'ajouterais qu'il est plus difficile de comprendre exactement ce que le code fait, et cela peut rendre le débogage plus difficile. Il est plus facile de penser à créer et fermer des fils, IMO, que de penser à donner du travail à un pool de fils.

Je ne peux toujours pas faire de commentaire poteaux d'autres personnes, ainsi pardonnez mes lamentations momentanées en employant une réponse pour s'adresser aux jetées7

N'utilisez pas de fil.Abort (); au lieu de cela, signalez un événement et concevez votre thread pour qu'il se termine avec élégance lorsqu'il est signalé. Fil.Abort() soulève une ThreadAbortException à un point arbitraire dans l'exécution du thread, qui peut faire toutes sortes de choses malheureuses comme les moniteurs orphelins, l'état partagé corrompu, et ainsi de suite. http://msdn.microsoft.com/en-us/library/system.threading.thread.abort.aspx

si elle n'est pas cassée, réparez - la jusqu'à ce qu'elle le soit...c'est juste une blague :)

mais sérieusement BackgroundWorker est probablement très similaire à ce que vous avez déjà, si vous aviez commencé avec elle dès le début peut - être que vous auriez gagné un peu de temps-mais à ce point je ne vois pas le besoin. Sauf si quelque chose ne fonctionne pas, ou si vous pensez que votre code actuel est difficile à comprendre, alors je m'en tiendrais à ce que vous avez.

la différence fondamentale est, comme vous l'avez dit, de générer des événements GUI à partir du BackgroundWorker . Si le thread n'a pas besoin de mettre à jour l'affichage ou de générer des événements pour le thread GUI principal, alors il peut s'agir d'un thread simple.

un travailleur d'arrière-plan est une classe qui fonctionne dans un thread séparé, mais il fournit des fonctionnalités supplémentaires que vous ne recevez pas avec un simple Thread (comme la gestion des rapports d'avancement des tâches).

si vous n'avez pas besoin des caractéristiques supplémentaires données par un travailleur d'arrière - plan - et il semble que vous n'en avez pas besoin-alors un fil serait plus approprié.

je tiens à souligner un comportement de la classe des travailleurs de fond qui n'a pas encore été mentionné. Vous pouvez créer un Thread normal à exécuter en arrière-plan en définissant le Thread.IsBackground de la propriété.

les fils D'arrière-plan sont identiques aux fils d'avant-plan, sauf que les fils d'arrière-plan n'empêchent pas un processus de se terminer. [ 1 ]

vous pouvez tester ce behavoir en appelant la méthode suivante dans le constructeur de votre fenêtre de formulaire.

void TestBackgroundThread()
{
    var thread = new Thread((ThreadStart)delegate()
    {
        long count = 0;
        while (true)
        {
            count++;
            Debug.WriteLine("Thread loop count: " + count);
        }
    });

    // Choose one option:
    thread.IsBackground = false; // <--- This will make the thread run in background
    thread.IsBackground = true; // <--- This will delay program termination

    thread.Start();
}

lorsque la propriété IsBackground est définie à true et que vous fermez la fenêtre, alors votre application se terminera normalement.

mais quand la propriété IsBackground est définie à false (par défaut) et que vous fermez la fenêtre, alors juste la fenêtre se désactivera mais le processus continuera à fonctionner.

la classe BackgroundWorker utilise un Thread qui tourne à l'arrière-plan.

ce qui me rend perplexe, c'est que le concepteur de studio visuel ne vous permet d'utiliser que des travailleurs de fond et des minuteries qui ne fonctionnent pas réellement avec le projet de service.

il vous donne des commandes Drag et drop soignées sur votre service mais... n'essayez même pas de le déployer. Ne fonctionne pas.

Services: Utilisez seulement le système.Minuterie.Minuterie Système.Windows.Forme.Le minuteur ne fonctionnera pas même s'il est disponible dans la boîte à outils

Service: BackgroundWorkers ne fonctionnera pas quand il fonctionne comme un service L'Utilisation Du Système.Le filetage.ThreadPools au lieu ou d'appels Asynchrones