Travailler dur pour ne pas avoir à le faire

Explorons comment tirer parti du modèle Worker Service disponible avec .NET Core pour configurer et exécuter des processus de longue durée dans différents environnements.

.NET Core's Worker Service fournit un modèle plus récent pour du code commun autour des services avec le avantage supplémentaire d'être multiplateforme.

Worker Service ne doit pas être confondu avec Service Worker. Service Worker est un pseudo thread d'arrière-plan qui extrait des ressources lorsque votre page Web se charge et peut mettre en cache. Le premier est un exécutable côté serveur qui n'a pas d'interface utilisateur et peut s'exécuter en continu ou à intervalles réguliers.

Bien que la création de processus d'arrière-plan de longue durée fasse depuis longtemps partie de la programmation, ce modèle plus récent permet de créer et d'exécuter simplement le service à travers de nombreux systèmes d'exploitation différents.

Mise en route

Avec .NET Core, nous pouvons construire notre projet en mettant l'accent sur les préoccupations commerciales, mais l'environnement d'exécution cible prend le pas sur les fonctionnalités.

Mise en place de notre projet initial out est un jeu d'enfant avec Worker Service Template. Pour commencer, nous pouvons créer notre solution initiale avec la commande suivante:

 dotnet  new   worker   -  o BackgroundWorkerExample

Après avoir créé le projet, vous remarquerez qu’il n’existe que deux fichiers principaux: Program.cs et Worker.cs . Program.cs est le principal coureur de l'ouvrier. Toute la logique de configuration du worker est exécutée dans le fichier Program.cs .

Le Worker.cs est l'endroit où notre logique métier va vivre. Vous pouvez le configurer pour qu'il fonctionne en continu ou ajouter des retards au coureur. À l'intérieur d'ExecuteAsync se trouve l'entrée du code de travail.

Ecriture de votre code

Le nouveau modèle de création de services de travail facilite la création d'un worker multiplateforme qui peut être exécuté n'importe où. En raison du modèle et des bibliothèques, nous pouvons nous concentrer sur la logique métier avant d'avoir à nous soucier de l'environnement dans lequel il s'exécuterait.

Service Windows

Afin d'adopter ce service pour Windows, vous devrez télécharger le Package WindowsService NuGet.

 Microsoft .  Extensions .  Hébergement .  WindowsServices

Après avoir téléchargé le package, vous devrez aller dans le fichier Program.cs et ajouter une seule ligne de code:

. . . 
    . 
     ] public   static  IHostBuilder  CreateHostBuilder  ( string  []  args )   = > 
        Hôte .  CreateDefaultBuilder  ( args ) 
            .  UseWindowsService  ()  
            .  ConfigureServices  ([19659020] ( hostContext  services )   = > 
             {
                services .  AddHostedService  < Worker >   () ; 
            } ) ; [19659050]. . . 

Linux Systemd

Pour adopter ce service pour Linux, vous devrez télécharger le package NuGet Systemd.

 Microsoft.Extensions.Hosting.Systemd

Après avoir téléchargé le package, vous devrez aller dans le fichier Program.cs et ajouter une seule ligne de code:

. . . 
    . 
     ] public   static  IHostBuilder  CreateHostBuilder  ( string  []  args )   = > 
        Hôte .  CreateDefaultBuilder  ( args ) 
            .  UseSystemd  ()    
            .  ConfigureServices  ([19659020] ( hostContext  services )   = > 
             {
                services .  AddHostedService  < Worker >   () ; 
            } ) ; [19659050]. . . 

Pas encore sûr

Les deux UseWindowsService () et UseSystemd () sont sensibles au contexte et peuvent être appliqués à en même temps et ne sera utilisé que lorsque le contexte est approprié. Vous pouvez faire en sorte que la compatibilité de votre Worker Service soit exécutée dans un environnement Windows ou Linux sans avoir une seconde base de code.

Continuous or Intervals?

À ce stade, nous avons parlé de créer le projet et de l'acclimater à différents environnements où il peut être exécuté. La prochaine étape consisterait à décider de la manière dont il fera son travail. Par défaut, le service de travail fonctionnera en continu.

Avec un petit ajustement, nous pouvons changer le comportement par défaut d'un travailleur continu à un travailleur qui s'exécute à intervalle.

 protected   override   async  Tâche  ExecuteAsync  ( CancellationToken stoppingToken ) 
 {
     while   (!  stoppingToken .  IsCancested ]) 
     {
        . . . 
         wait  Task .  Delay  ( 1000  stoppingToken ) ; 
    } 
} 

En faisant ce changement, nous pouvons faire fonctionner le travailleur sur un retard programmatique qui répond aux annulations. De plus, nous pouvons ajouter des intervalles dynamiques pour les tentatives et autres logiques sans avoir à modifier manuellement le nœud de calcul lui-même.

 protected   override   async  Task  ExecuteAsync  ( CancellationToken stoppingToken ) 
 {
     while   (!  stoppingToken .  IsCancellationRequested ) 
     {
         int  delay  =   1000 ;  
         try   {
            . . . 
        }  
         catch  ( Exception )   {
            delay  =  delay  *   2 ; 
        }  
         await  Task .  Delay  ( delay  stopToken ) ; 
    } 
} 

Nous avons passé en revue les bases de la mise en route du service de travail de .NET Core, ainsi que la manière de l'adapter à de nombreux environnements d'exécution différents, ainsi que quelques ajustements pour que le collaborateur fonctionne mieux pour vous. C'est un autre outil que .NET Core met à disposition pour en faire un excellent choix pour répondre à vos besoins en matière de service de travail. Happy Coding!

Pour le code source, consultez le GitHub Repo .