Multithread service, BackgroundWorker vs pool de threads?

La valeur dans BackgroundWorker est qu'il peut élever son ProgressChanged et RunworkerCompleted événement sur le thread qui a créé son instance. Ce qui le rend très pratique dans les programmes qui ne peuvent pas soutenir sans filetage.

Pour que cela fonctionne correctement, il est cependant nécessaire que le SynchronizationContext.Current propriété fait référence à une non-synchronisation par défaut du fournisseur. Un fournisseur qui est responsable pour le marshaling des appels à partir d'un thread à l'autre. L' .NET framework a deux fournisseurs qui sont facilement disponibles: System.Windows.Forms.WindowsFormsSynchronizationContext et System.Windows.Threading.DispatcherSynchronizationContext. Ces fournisseurs de gérer la synchronisation pour, respectivement, Winforms et WPF.

Il y a un lien, Winforms et WPF sont à la fois des bibliothèques de classes qui ont un filetage problème. À la fois de mettre en œuvre des Interfaces graphiques basés sur Windows et les interfaces utilisateur graphiques sont fondamentalement thread-dangereux. Windows windows peut uniquement être mis à jour à partir du thread qui l'a créé. En d'autres termes, les fournisseurs de synchronisation existent parce qu'il y a un besoin urgent pour eux. Également remarquable, c'est qu'ils travaillent en profitant de la manière de l'INTERFACE utilisateur de threads de travail. Un thread d'INTERFACE utilisateur exécute le code dans un événement piloté par le moyen, le pompage d'une boucle de message pour recevoir des notifications. Le fournisseur de synchronisation peut injecter des appels à des gestionnaires d'événement à l'aide de ce mécanisme. Ce n'est pas un accident.

De retour sur le sujet, un service Windows n'a pas un tel établissement. Il ne dispose pas d'une interface graphique et ne pas installer un custom fournisseur de synchronisation. En tant que tel, BackgroundWorker fournit aucune fonctionnalité est utile dans un service. Sans la synchronisation personnalisée fournisseur, le fournisseur par défaut fonctionne tout simplement événements sur un pool de threads thread. Ce qui n'est pas utile, vous pouvez ainsi déclencher l'événement à partir de votre thread de travail. Récupérer les évènements à exécuter sur un autre thread spécifique est très difficile à réaliser, sauf si vous recréer le message mécanisme de boucle ou crochet dans les Winforms de plomberie et de créer une simulation de thread de l'INTERFACE utilisateur à l'aide d'une fenêtre invisible. Qui n'est pas rare btw.

J'ai écrit un assez exhaustive, les différentes implémentations de l'asynchrone tâches en arrière-plan sur mon blog. Le résumé est: préférez Task; le second choix serait BackgroundWorker; et de n'utiliser Thread ou ThreadPool.QueueUserWorkItem si vous avez vraiment besoin à.

Raisons: il est plus facile de détecter et de corriger les erreurs, et il est plus facile de synchroniser retour à une INTERFACE utilisateur.

Pour répondre à vos questions:

BackgroundWorker fonctionne dans n'importe quel hôte, y compris les WinForms et WPF (et même ASP.NET!), parce que il est basé sur SynchronizationContext. Les services de Windows n'ont pas de SynchronizationContext, mais vous pouvez utiliser ActionThread de la Nito.Async bibliothèque, qui est livré avec un SynchronizationContext.

Si j'ai lu votre question correctement, vous avez actuellement Threads et envisagent ThreadPool et BackgroundWorker. De ces choix, je recommande BackgroundWorker, mais si vous avez de la chance, l'utilisation de la nouvelle Task classe .NET 4.0 (si vous installez Microsoft Rx, vous pouvez également utiliser Task dans .NET 3.5).

Je pense que votre troisième choix est le meilleur. J'ai fait des choses similaires avec les services Windows en .Net 3.5 et a constaté que la création de mon propre fils était un bon chemin à parcourir, notamment avec des fils qui ont été interfaçage avec des services web.

- Je créer une instance de travail et de lui donner un rappel que les signaux du service lorsque c'est fait. Je magasin de prêt-à-exécuter les threads dans un Queue et les peler en fonction du nombre maximum de threads simultanés que je veux. Si tout ce qui vous intéresse est le nombre de services en cours d'exécution, vous pouvez garder une trace d'eux avec un simple compteur. Je préfère stocker chaque travail en cours d'instance dans un Dictionary gérés par le thread ManagedThreadId de sorte que je peux facilement le signal de chaque exemple, si je veux l'arrêter proprement. Il est également pratique pour l'interrogation des instances en cours pour vérifier l'état.