Application console .NET en tant que service Windows

J'ai une application console et je souhaite l'exécuter en tant que service Windows. VS2010 a un modèle de projet qui permet d'attacher un projet de console et de créer un service Windows. Je voudrais ne pas ajouter de projet de service séparé et si possible intégrer le code de service dans l'application console pour conserver l'application console en tant que projet unique qui pourrait fonctionner en tant qu'application console ou en tant que service Windows si elle est exécutée par exemple à partir de la ligne de commande à l'aide de commutateurs.

Peut-être que quelqu'un pourrait suggérer une bibliothèque de classes ou un extrait de code qui pourrait rapidement et facilement transformer une application console c # en service?

J'utilise généralement la technologie suivante pour exécuter la même application en tant qu'application console ou en tant que service:

public static class Program
{
    #region Nested classes to support running as service
    public const string ServiceName = "MyService";

    public class Service : ServiceBase
    {
        public Service()
        {
            ServiceName = Program.ServiceName;
        }

        protected override void OnStart(string[] args)
        {
            Program.Start(args);
        }

        protected override void OnStop()
        {
            Program.Stop();
        }
    }
    #endregion

    static void Main(string[] args)
    {
        if (!Environment.UserInteractive)
            // running as service
            using (var service = new Service())
                ServiceBase.Run(service);
        else
        {
            // running as console app
            Start(args);

            Console.WriteLine("Press any key to stop...");
            Console.ReadKey(true);

            Stop();
        }
    }

    private static void Start(string[] args)
    {
        // onstart code here
    }

    private static void Stop()
    {
        // onstop code here
    }
}

Environment.UserInteractiveest normalement vrai pour l'application console et faux pour un service. Techniquement, il est possible d'exécuter un service en mode interactif avec l'utilisateur, vous pouvez donc vérifier un commutateur de ligne de commande à la place.

J'ai eu beaucoup de succès avec TopShelf .

TopShelf est un package Nuget conçu pour faciliter la création d'applications Windows .NET pouvant s'exécuter en tant qu'applications console ou services Windows. Vous pouvez connecter rapidement des événements tels que les événements de démarrage et d'arrêt de votre service, configurer à l'aide du code, par exemple pour définir le compte sous lequel il s'exécute, configurer les dépendances sur d'autres services et configurer la manière dont il récupère les erreurs.

Depuis la console du gestionnaire de packages (Nuget):

Install-Package Topshelf

Reportez-vous aux exemples de code pour commencer.

Exemple:

HostFactory.Run(x =>                                 
{
    x.Service<TownCrier>(s =>                        
    {
       s.ConstructUsing(name=> new TownCrier());     
       s.WhenStarted(tc => tc.Start());              
       s.WhenStopped(tc => tc.Stop());               
    });
    x.RunAsLocalSystem();                            

    x.SetDescription("Sample Topshelf Host");        
    x.SetDisplayName("Stuff");                       
    x.SetServiceName("stuff");                       
}); 

TopShelf s'occupe également de l'installation du service, ce qui peut gagner beaucoup de temps et supprime le code standard de votre solution. Pour installer votre .exe en tant que service, exécutez simplement ce qui suit à partir de l'invite de commande:

myservice.exe install -servicename "MyService" -displayname "My Service" -description "This is my service."

Vous n'avez pas besoin de connecter un ServiceInstaller et tout cela - TopShelf fait tout pour vous.

Voici donc la procédure pas à pas complète:

1. Créer un nouveau projet d'application console (par exemple MyService)
2. Ajoutez deux références de bibliothèque: System.ServiceProcess et System.Configuration.Install
3. Ajoutez les trois fichiers imprimés ci-dessous
4. Générez le projet et exécutez "InstallUtil.exe c: \ path \ to \ MyService.exe"
5. Vous devriez maintenant voir MyService dans la liste des services (exécutez services.msc)

* InstallUtil.exe se trouve généralement ici: C: \ windows \ Microsoft.NET \ Framework \ v4.0.30319 \ InstallUtil.ex‌ e

Program.cs

using System;
using System.IO;
using System.ServiceProcess;

namespace MyService
{
    class Program
    {
        public const string ServiceName = "MyService";

        static void Main(string[] args)
        {
            if (Environment.UserInteractive)
            {
                // running as console app
                Start(args);

                Console.WriteLine("Press any key to stop...");
                Console.ReadKey(true);

                Stop();
            }
            else
            {
                // running as service
                using (var service = new Service())
                {
                    ServiceBase.Run(service);
                }
            }
        }

        public static void Start(string[] args)
        {
            File.AppendAllText(@"c:\temp\MyService.txt", String.Format("{0} started{1}", DateTime.Now, Environment.NewLine));
        }

        public static void Stop()
        {
            File.AppendAllText(@"c:\temp\MyService.txt", String.Format("{0} stopped{1}", DateTime.Now, Environment.NewLine));
        }
    }
}

MyService.cs

using System.ServiceProcess;

namespace MyService
{
    class Service : ServiceBase
    {
        public Service()
        {
            ServiceName = Program.ServiceName;
        }

        protected override void OnStart(string[] args)
        {
            Program.Start(args);
        }

        protected override void OnStop()
        {
            Program.Stop();
        }
    }
}

MyServiceInstaller.cs

using System.ComponentModel;
using System.Configuration.Install;
using System.ServiceProcess;

namespace MyService
{
    [RunInstaller(true)]
    public class MyServiceInstaller : Installer
    {
        public MyServiceInstaller()
        {
            var spi = new ServiceProcessInstaller();
            var si = new ServiceInstaller();

            spi.Account = ServiceAccount.LocalSystem;
            spi.Username = null;
            spi.Password = null;

            si.DisplayName = Program.ServiceName;
            si.ServiceName = Program.ServiceName;
            si.StartType = ServiceStartMode.Automatic;

            Installers.Add(spi);
            Installers.Add(si);
        }
    }
}

J'entends votre point de vouloir qu'un assemblage arrête le code répété, mais ce serait plus simple et réduire la répétition du code et faciliter la réutilisation de votre code d'une autre manière à l'avenir si ...... vous le divisez en 3 assemblys.

1. Un assemblage de bibliothèque qui fait tout le travail. Alors ayez deux projets très très minces / simples:
2. celui qui est la ligne de commande
3. celui qui est le service Windows.

Voici une nouvelle façon de transformer une application console en service Windows en tant que service de travail basé sur le dernier .Net Core 3.1 .

Si vous créez un service de travail à partir de Visual Studio 2019, il vous donnera presque tout ce dont vous avez besoin pour créer un service Windows prêt à l'emploi, ce qui est également ce que vous devez modifier dans l'application console afin de le convertir en service Windows.

Voici les changements que vous devez faire:

Installez les packages NuGet suivants

Install-Package Microsoft.Extensions.Hosting.WindowsServices -Version 3.1.0
Install-Package Microsoft.Extensions.Configuration.Abstractions -Version 3.1.0

Changez Program.cs pour avoir une implémentation comme ci-dessous:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace ConsoleApp
{
    class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).UseWindowsService().Build().Run();
        }

        private static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddHostedService<Worker>();
                });
    }
}

et ajoutez Worker.cs où vous mettrez le code qui sera exécuté par les opérations de service:

using Microsoft.Extensions.Hosting;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp
{
    public class Worker : BackgroundService
    {
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            //do some operation
        }

        public override Task StartAsync(CancellationToken cancellationToken)
        {
            return base.StartAsync(cancellationToken);
        }

        public override Task StopAsync(CancellationToken cancellationToken)
        {
            return base.StopAsync(cancellationToken);
        }
    }
}

Lorsque tout est prêt et que l'application a été créée avec succès, vous pouvez utiliser sc.exe pour installer votre exe d'application console en tant que service Windows avec la commande suivante:

sc.exe create DemoService binpath= "path/to/your/file.exe"

Vous pouvez utiliser

reg add HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run /v ServiceName /d "c:\path\to\service\file\exe"

Et il apparaîtra dans la liste des services. Je ne sais pas si cela fonctionne correctement. Un service doit généralement écouter plusieurs événements.

Il existe cependant plusieurs wrapper de service qui peuvent exécuter n'importe quelle application en tant que service réel. Par exemple Microsofts SrvAny du Kit de ressources Win2003

Tout d'abord, j'intègre la solution d'application console dans la solution de service Windows et je la référence.

Ensuite, je rends la classe de programme de l'application console publique

/// <summary>
/// Hybrid service/console application
/// </summary>
public class Program
{
}

Je crée ensuite deux fonctions au sein de l'application console

    /// <summary>
    /// Used to start as a service
    /// </summary>
    public void Start()
    {
        Main();
    }

    /// <summary>
    /// Used to stop the service
    /// </summary>
    public void Stop()
    {
       if (Application.MessageLoop)
            Application.Exit();   //windows app
        else
            Environment.Exit(1);  //console app
    }

Ensuite, dans le service Windows lui-même, j'instancie le programme et j'appelle les fonctions de démarrage et d'arrêt ajoutées dans OnStart et OnStop. Voir ci-dessous

class WinService : ServiceBase
{
    readonly Program _application = new Program();

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    static void Main()
    {
        ServiceBase[] servicesToRun = { new WinService() };
        Run(servicesToRun);
    }

    /// <summary>
    /// Set things in motion so your service can do its work.
    /// </summary>
    protected override void OnStart(string[] args)
    {
        Thread thread = new Thread(() => _application.Start());
        thread.Start();
    }

    /// <summary>
    /// Stop this service.
    /// </summary>
    protected override void OnStop()
    {
        Thread thread = new Thread(() => _application.Stop());
        thread.Start();
    }
}

Cette approche peut également être utilisée pour un hybride application Windows / service Windows

Vous devriez peut-être définir ce dont vous avez besoin, pour autant que je sache, vous ne pouvez pas exécuter votre application en tant que console ou service avec ligne de commande, en même temps. N'oubliez pas que le service est installé et que vous devez le démarrer dans le Gestionnaire de services, vous pouvez créer une nouvelle application qui démarre le service ou démarre un nouveau processus exécutant votre application console. Mais comme tu l'écris

"conserver l'application console comme un seul projet"

Une fois, j'étais à votre place, transformant une application console en service. Vous avez d'abord besoin du modèle, au cas où vous travaillez avec VS Express Edition. Voici un lien où vous pouvez avoir vos premiers pas: Service C # Windows , cela m'a été très utile. Ensuite, à l'aide de ce modèle, ajoutez votre code aux événements souhaités du service.

Pour améliorer votre service, il y a une autre chose que vous pouvez faire, mais ce n'est pas rapide et / ou facile, consiste à utiliser des domaines d'application et à créer des dll pour charger / décharger. Dans l'un, vous pouvez démarrer un nouveau processus avec l'application console, et dans un autre dll, vous pouvez simplement mettre la fonctionnalité que le service doit faire.

Bonne chance.

Vous devez séparer la fonctionnalité en une ou plusieurs classes et la lancer via l'un des deux stubs. Le stub de console ou le stub de service.

Comme il est évident, lors de l'exécution de Windows, la myriade de services qui composent l'infrastructure ne présente pas (et ne peut pas directement) présenter les fenêtres de console à l'utilisateur. Le service doit communiquer avec l'utilisateur de manière non graphique: via le SCM; dans le journal des événements, vers un fichier journal, etc. Le service devra également communiquer avec Windows via le SCM, sinon il sera arrêté.

Il serait évidemment acceptable d'avoir une application console capable de communiquer avec le service, mais le service doit fonctionner indépendamment sans nécessiter d'interaction GUI.

Le stub de la console peut être très utile pour déboguer le comportement du service, mais ne doit pas être utilisé dans un environnement "production" qui, après tout, est le but de la création d'un service.

Je ne l'ai pas lu complètement mais cet article semble aller dans la bonne direction.

J'utilise une classe de service qui suit le modèle standard prescrit par ServiceBase , et j'utilise des helpers pour faciliter le débogage F5. Cela permet de garder les données de service définies dans le service, ce qui les rend faciles à trouver et leur durée de vie facile à gérer.

Je crée normalement une application Windows avec la structure ci-dessous. Je ne crée pas d'application console; de cette façon, je n'ai pas une grosse boîte noire qui me saute au visage chaque fois que je lance l'application. Je reste dans le débogueur où se trouve toute l'action. j'utiliseDebug.WriteLine pour que les messages soient dirigés vers la fenêtre de sortie, qui s'ancre bien et reste visible après la fin de l'application.

Je ne prends généralement pas la peine d'ajouter du code de débogage pour m'arrêter; J'utilise simplement le débogueur à la place. Si j'ai besoin de déboguer l'arrêt, je fais du projet une application console, j'ajoute une Stopméthode de transfert et je l'appelle après un appel à Console.ReadKey.

public class Service : ServiceBase
{
    protected override void OnStart(string[] args)
    {
        // Start logic here.
    }

    protected override void OnStop()
    {
        // Stop logic here.
    }

    static void Main(string[] args)
    {
        using (var service = new Service()) {
            if (Environment.UserInteractive) {
                service.Start();
                Thread.Sleep(Timeout.Infinite);
            } else
                Run(service);
        }
    }
    public void Start() => OnStart(null);
}