Aplicativo de console .NET como serviço do Windows

Eu tenho um aplicativo de console e gostaria de executá-lo como serviço do Windows. O VS2010 possui um modelo de projeto que permite anexar o projeto do console e criar o serviço do Windows. Gostaria de não adicionar um projeto de serviço separado e, se possível, integrar o código de serviço no aplicativo de console para manter o aplicativo de console como um projeto que poderia ser executado como aplicativo de console ou como serviço do Windows, se executado, por exemplo, na linha de comando usando comutadores.

Talvez alguém possa sugerir uma biblioteca de classes ou um trecho de código que possa transformar rápida e facilmente o aplicativo de console c # em serviço?

Normalmente, uso o seguinte techinque para executar o mesmo aplicativo que um aplicativo de console ou um serviço:

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.UserInteractivenormalmente é verdadeiro para o aplicativo de console e falso para um serviço. Tecnicamente, é possível executar um serviço no modo interativo do usuário, para que você possa verificar uma opção de linha de comando.

Eu tive um grande sucesso com o TopShelf .

O TopShelf é um pacote Nuget projetado para facilitar a criação de aplicativos .NET Windows que podem ser executados como aplicativos de console ou como Serviços do Windows. Você pode conectar rapidamente eventos como o serviço Iniciar e parar eventos, configurar usando o código, por exemplo, para definir a conta em que é executado, configurar dependências em outros serviços e configurar como ele se recupera de erros.

No console do gerenciador de pacotes (Nuget):

Prateleira superior do pacote de instalação

Consulte os exemplos de código para começar.

Exemplo:

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");                       
}); 

O TopShelf também cuida da instalação do serviço, o que pode economizar muito tempo e remove o código padrão da sua solução. Para instalar o .exe como um serviço, basta executar o seguinte no prompt de comando:

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

Você não precisa conectar um ServiceInstaller e tudo mais - o TopShelf faz tudo por você.

Então, aqui está o passo a passo completo:

1. Crie um novo projeto de aplicativo de console (por exemplo, MyService)
2. Adicione duas referências de biblioteca: System.ServiceProcess e System.Configuration.Install
3. Adicione os três arquivos impressos abaixo
4. Crie o projeto e execute "InstallUtil.exe c: \ path \ to \ MyService.exe"
5. Agora você deve ver o MyService na lista de serviços (execute services.msc)

* O InstallUtil.exe geralmente pode ser encontrado aqui: 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);
        }
    }
}

Eu ouço o seu argumento de querer que um assembly pare o código repetido, mas seria mais simples e reduziria a repetição de código e tornaria mais fácil reutilizar seu código de outras maneiras no futuro se ...... você o dividisse em 3 assemblies.

1. Um assembly de biblioteca que faz todo o trabalho. Então, tenha dois projetos muito muito pequenos / simples:
2. aquele que é a linha de comando
3. um que é o serviço windows.

Aqui está uma maneira mais recente de como transformar um aplicativo de console em um serviço do Windows como um serviço de trabalho com base no mais recente .Net Core 3.1 .

Se você criar um Serviço de Trabalho do Visual Studio 2019, ele fornecerá quase tudo o que você precisa para criar um Serviço do Windows pronto para o uso, que também é o que você precisa alterar para o aplicativo do console para convertê-lo em um Serviço do Windows.

Aqui estão as alterações que você precisa fazer:

Instale os seguintes pacotes NuGet

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

Altere Program.cs para ter uma implementação como abaixo:

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>();
                });
    }
}

e adicione Worker.cs onde você colocará o código que será executado pelas operações de serviço:

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);
        }
    }
}

Quando tudo estiver pronto e o aplicativo tiver sido construído com êxito, você poderá usar o sc.exe para instalar o aplicativo do console exe como um Serviço do Windows com o seguinte comando:

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

Você pode usar

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

E aparecerá na lista de serviços. Eu não sei, se isso funciona corretamente embora. Um serviço geralmente precisa ouvir vários eventos.

Existem vários wrappers de serviço que podem executar qualquer aplicativo como um serviço real. Por exemplo, Microsoft Microsofts SrvAny do Win2003 Resource Kit

Primeiramente, incorporei a solução de aplicativo de console à solução de serviço do Windows e a referencio.

Torno pública a classe de programa do aplicativo de console

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

Em seguida, crio duas funções no aplicativo de 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
    }

Então, dentro do próprio serviço do Windows, instancio o programa e chamo as funções Start e Stop adicionadas no OnStart e OnStop. Ver abaixo

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();
    }
}

Essa abordagem também pode ser usada para um aplicativo Windows / serviço híbrido do Windows

Talvez você deva definir o que precisa, tanto quanto eu sei, não pode executar seu aplicativo como Console ou Serviço com linha de comando ao mesmo tempo. Lembre-se de que o serviço está instalado e você deve iniciá-lo no Services Manager. Você pode criar um novo aplicativo que inicie o serviço ou inicie um novo processo executando o aplicativo do console. Mas como você escreveu

"mantenha o aplicativo do console como um projeto"

Uma vez, eu estava na sua posição, transformando um aplicativo de console em um serviço. Primeiro você precisa do modelo, caso esteja trabalhando com o VS Express Edition. Aqui está um link onde você pode dar seus primeiros passos: Serviço do Windows em C # , isso foi muito útil para mim. Em seguida, usando esse modelo, adicione seu código aos eventos desejados do serviço.

Para melhorar seu serviço, há outra coisa que você pode fazer, mas isso não é rápido e / ou fácil, é usar domínios de aplicativos e criar dlls para carregar / descarregar. Em um, você pode iniciar um novo processo com o aplicativo do console e, em outra DLL, basta colocar a funcionalidade que o serviço precisa fazer.

Boa sorte.

Você precisa separar a funcionalidade em uma classe ou classes e iniciá-la por meio de um dos dois stubs. O stub do console ou stub de serviço.

Como é óbvio, ao executar janelas, os inúmeros serviços que compõem a infraestrutura não apresentam (e não podem diretamente) apresentar janelas de console ao usuário. O serviço precisa se comunicar com o usuário de forma não gráfica: via SCM; no log de eventos, para algum arquivo de log etc. O serviço também precisará se comunicar com o Windows via SCM, caso contrário, será desativado.

Obviamente, seria aceitável ter algum aplicativo de console que possa se comunicar com o serviço, mas o serviço precisa ser executado independentemente, sem a necessidade de interação com a GUI.

O stub do console pode ser muito útil para o comportamento do serviço de depuração, mas não deve ser usado em um ambiente "produzido" que, afinal, é o objetivo de criar um serviço.

Eu não li completamente, mas este artigo parece estar na direção certa.

Eu uso uma classe de serviço que segue o padrão padrão prescrito por ServiceBase, e adiro os auxiliares para facilitar a depuração F5. Isso mantém os dados de serviço definidos dentro do serviço, facilitando a localização e o gerenciamento de suas vidas úteis.

Normalmente, crio um aplicativo do Windows com a estrutura abaixo. Eu não crio um aplicativo de console; Dessa forma, não recebo uma grande caixa preta aparecendo na minha cara toda vez que executo o aplicativo. Eu fico no depurador onde está toda a ação. Eu uso Debug.WriteLinepara que as mensagens vão para a janela de saída, que encaixa perfeitamente e permanece visível após o término do aplicativo.

Eu geralmente não me incomodo em adicionar código de depuração para parar; Eu apenas uso o depurador. Se eu precisar depurar a parada, torno o projeto um aplicativo de console, adiciono um Stopmétodo de encaminhador e o chamo após uma chamada para 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);
}