Déploiement d'un service Windows .NET Core via Topshelf

Commencze par initialiser un projet de type worker .NET Core à partir d'un modèle standard.

Ouvrez ensuite le fichier Programme.cs pour y apporter des modifications.

namespace ServiceWorkerNetCore
{
    public class Programme
    {
        public static void Main(string[] arguments)
        {
            ConfigurerHote(arguments).Build().Run();
        }

        public static IHostBuilder ConfigurerHote(string[] arguments) =>
            Host.CreateDefaultBuilder(arguments)
                .ConfigureServices((contexteHote, services) =>
                {
                    services.AddHostedService<tacheworker>();
                });
    }
}
</tacheworker>

Installez ensuite le paquet NuGet Topshelf dans votre projet.

Réécrivez le fichier Programme.cs pour intégrer la configuraton Topshelf.

    public class Programme
    {
        public static void Main(string[] arguments)
        {
            HostFactory.Run(configurateur =>
            {
                configurateur.Service<IHost>(service =>
                {
                    service.ConstructUsing(() => ConfigurerHote(arguments).Build());
                    service.WhenStarted(hote =>
                    {
                        hote.Start();
                    });
                    service.WhenStopped(hote =>
                    {
                        hote.StopAsync();
                    });
                });

                configurateur.StartAutomatically();
                configurateur.RunAsLocalSystem();

                configurateur.SetServiceName("MonServiceWindows.NomService");
                configurateur.SetDisplayName("MonServiceWindows.NomAffichage");
                configurateur.SetDescription("MonServiceWindows.Description");
            });
        }

        public static IHostBuilder ConfigurerHote(string[] arguments) =>
            Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder(arguments)
                .ConfigureServices((contexteHote, services) =>
                {
                    services.AddHostedService<tacheworker>();
                });
    }
</tacheworker>

Cette approche s'appuie sur l'interface IHost du .NET Generic Host pour gérer le cycle de vie de l'application.

Voici une illustration alternative de la gestion de l'hôte :

public class ServiceHote
{
    private IHost _hote;

    public ServiceHote()
    {
        _hote = new HostBuilder()
            .Build();
    }

    public async Task DemarrerAsync()
    {
        _hote.StartAsync();
    }

    public async Task ArreterAsync()
    {
        using (_hote)
        {
            await _hote.StopAsync(TimeSpan.FromSeconds(5));
        }
    }
}

Procédures de déploiement

Installation du service

Naviguez vers le répertoire contenant l'exécutable et lancez la commande :

MonServiceWindows.exe install

Démarrage du service

MonServiceWindows.exe start

Désinstallation du service

MonServiceWindows.exe uninstall

Configuration avancée du .NET Generic Host

Paramétrage des configurations

Host.CreateDefaultBuilder(arguments)
    .ConfigureHostConfiguration(configHote =>
    {
        configHote.SetBasePath(Directory.GetCurrentDirectory());
        configHote.AddJsonFile("parametresHote.json", optional: true);
        configHote.AddEnvironmentVariables(prefix: "PREF_");
        configHote.AddCommandLine(arguments);
    });

Définition de l'environnement

Host.CreateDefaultBuilder(arguments)
    .UseEnvironment("Developpement")

Intégration du journalisation

    .ConfigureLogging((contexte, logger) =>
    {
        logger.AddConsole();
        logger.SetMinimumLevel(LogLevel.Information);
    })

Injection de dépendances

    public class TacheCalcul
    {
        public string HeureActuelle()
        {
            return DateTime.Now.ToString();
        }
    }

    // Dans Programme.cs
    .ConfigureServices((contexteHote, services) =>
    {
        services.AddScoped<TacheCalcul>();
        services.AddHostedService<TacheWorker>();
    });

Version finale du Programme.cs

using System.IO;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Topshelf;

namespace ServiceWorkerNetCore
{
    public class Programme
    {
        public static void Main(string[] arguments)
        {
            HostFactory.Run(configurateur =>
            {
                configurateur.Service<IHost>(service =>
                {
                    service.ConstructUsing(() => ConfigurerHote(arguments).Build());
                    service.WhenStarted(hote =>
                    {
                        hote.Start();
                    });
                    service.WhenStopped(hote =>
                    {
                        hote.StopAsync();
                    });
                });

                configurateur.StartAutomatically();
                configurateur.RunAsLocalSystem();

                configurateur.SetServiceName("MonServiceWindows.NomService");
                configurateur.SetDisplayName("MonServiceWindows.NomAffichage");
                configurateur.SetDescription("MonServiceWindows.Description");
            });
        }

        public static IHostBuilder ConfigurerHote(string[] arguments) =>
            Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder(arguments)
                .UseEnvironment(Environments.Development)
                .ConfigureHostConfiguration(configHote =>
                {
                    configHote.SetBasePath(Directory.GetCurrentDirectory());
                    configHote.AddJsonFile("parametresHote.json", optional: true);
                    configHote.AddEnvironmentVariables(prefix: "PREF_");
                    configHote.AddCommandLine(arguments);
                })
                .ConfigureLogging((contexte, logger) =>
                {
                    logger.AddConsole();
                    logger.SetMinimumLevel(LogLevel.Information);
                })
                .ConfigureServices((contexteHote, services) =>
                {
                    services.AddScoped<TacheCalcul>();
                    services.AddHostedService<TacheWorker>();
                });
    }
}