Hébergement ASP.NET de Base en tant que service Windows

Vous avez deux options ici - utilisation de Microsoft WebHostService classe, hériter WebHostService ou écrire votre propre. La raison de ce dernier étant qu'à l'aide de Microsoft de la mise en œuvre, on ne peut pas écrire une extension générique de la méthode avec un paramètre de type hériter WebHostService étant donné que cette classe ne contient pas de constructeur sans paramètre, nous ne pouvons pas accéder au service locator.

À L'Aide De WebHostService

Dans cet exemple, je vais créer une Application Console qui utilise Microsoft.DotNet.Web.les objectifs, les résultats d'une .exe et fonctionne comme une application MVC (Vues, Contrôleurs, etc). Je suppose que la création de l'Application de la Console, changer les cibles dans le .xproj et de modifier le projet.json pour avoir le bon d'options de publication et de copier les points de Vue, des Contrôleurs et des webroot de la norme .NET web de Base modèle d'application - est trivial.

Maintenant l'essentiel:

1. Obtenir cette paquet et assurez-vous que votre cadre d'un projet.fichier json est net451 (ou plus récent)

2. Assurez-vous que le contenu de la racine du point d'entrée est correctement configuré pour la publier le répertoire de l'application .exe fichier et que le RunAsService() extension de la méthode est appelée. E. g:

   public static void Main(string[] args)
   {
       var exePath= System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
       var directoryPath = Path.GetDirectoryName(exePath);
   
       var host = new WebHostBuilder()
           .UseKestrel()
           .UseContentRoot(directoryPath)
           .UseStartup<Startup>()
           .Build();
   
       if (Debugger.IsAttached || args.Contains("--debug"))
       {
           host.Run();
       }
       else
       {
           host.RunAsService();
       }
   }

L' .exe peut facilement être installé à l'aide de la commande suivante

    sc create MyService binPath = "Full\Path\To\The\Console\file.exe"

Une fois que le service est démarré, l'application web est hébergé et a trouvé et rend son point de Vue.

Hériter WebHostService

Un avantage majeur de cette approche est qu'il nous permet de remplacer la OnStopping, OnStarting et OnStarted méthodes.

Supposons que la suite est notre coutume de classe qui hérite WebHostService

internal class CustomWebHostService : WebHostService
{
    public CustomWebHostService(IWebHost host) : base(host)
    {
    }

    protected override void OnStarting(string[] args)
    {
        //Log
        base.OnStarting(args);
    }

    protected override void OnStarted()
    {
        //More log
        base.OnStarted();
    }

    protected override void OnStopping()
    {
        //Even more log
        base.OnStopping();
    }
}

Suivant les étapes ci-dessus, nous devons écrire notre propre méthode d'extension qui exécute l'hôte à l'aide de notre classe personnalisée:

public static class CustomWebHostWindowsServiceExtensions
{
    public static void RunAsCustomService(this IWebHost host)
    {
        var webHostService = new CustomWebHostService(host);
        ServiceBase.Run(webHostService);
    }
}

La seule ligne qui reste à être modifié à partir de l'exemple précédent du point d'entrée est le else à la fin, il a appeler la bonne méthode d'extension

host.RunAsCustomService();

Enfin, l'installation du service à l'aide de la même procédure que ci-dessus.

sc create MyService binPath = "Full\Path\To\The\Console\file.exe"

Vous avez besoin de faire référence à Microsoft.AspNetCore.Hosting et Microsoft.AspNetCore.Hosting.WindowsServices et utiliser ce code dans votre Démarrage de classe pour le rendre exécutable en tant que service windows:

public static void Main(string[] args)
{
    var host = new WebHostBuilder()
                .UseIISIntegration()
                .UseKestrel()
                .UseContentRoot(@"Path\To\Content\Root")
                .UseStartup<Startup>()
                .Build();

    if (Debugger.IsAttached || args.Contains("--debug"))
    {
        host.Run();
    }
    else
    {
        host.RunAsService();
    }
}

Ensuite, vous devez ajouter une méthode d'extension pour IWebHost.RunAsService pour envelopper votre propre WebHostService classe avec OnStopping et OnStarting des gestionnaires d'événement:

public static class MyWebHostServiceServiceExtensions
{
    public static void RunAsMyService(this IWebHost host)
    {
        var webHostService = new MyWebHostService(host);
        ServiceBase.Run(webHostService);
    }
}

internal class MyWebHostService : WebHostService
{
    public MyWebHostService(IWebHost host) : base(host)
    {
    }

    protected override void OnStarting(string[] args)
    {
        base.OnStarting(args);
    }

    protected override void OnStarted()
    {
        base.OnStarted();
    }

    protected override void OnStopping()
    {
        base.OnStopping();
    }
}

Ce post Comment héberger votre ASP.NET de Base dans un Service Windows et commentaires couvrent les détails.

Mise à JOUR (voir plus de détails dans Résumé rapide de ce qui est nouveau dans ASP.NET Core 2.0):

Dans ASP.NET Core 1.1 que nous avions quelque chose comme ceci:

public class Program
{
    public static void Main(string[] args)
    {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .Build();

        host.Run();
    }
}

Dans ASP.NET Core 2.0, il ressemble à ceci:

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();
}

Les Services Windows peuvent être facilement créés avec Visual Studio 2017. Vous aurez besoin de déplacer votre .NET code de Base d'une bibliothèque de classes qui cible NetStandard qui peut ensuite être référencé. Votre projet de Service Windows aura pour cible le plein .NET Framework, mais peut faire référence à votre bibliothèque partagée.

En mettant tout votre code dans la bibliothèque de classe, vous devrez la portabilité entre le Service Windows et non Windows apps.

Avec VS 2015, vous ne pouviez pas faire un projet de Service Windows et une référence .NET de Base xproj. Visual Studio 2017 résout qu'une fois que vous convertissez tous vos projets de csproj.

Ce blog promenades à travers cela plus en détail: Comment les Créer .NET de Base les Services Windows Avec Visual Studio 2017

Mis à jour pour ce que j'utilise .netcore 2.1, en utilisant autant de modèle de stock que possible, ce qui comprend la lecture de la configuration de la appsettings.json, commande args, hôte de filtrage, etc, tel que mis en œuvre à l'intérieur de l'aide des méthodes de l' .netcore de l'équipe. Beaucoup de ces paramètres sont donc contrôlés via des fichiers de configuration ou de commande args. vérifiez la documentation de microsoft sur ce qu'il modèle de stock et comment pour remplacer les paramètres.

Veuillez noter que j'ai vu le service ne pas démarrer si vous définissez un point de terminaison avec https et le défaut de certificat de développement. C'est peut-être simplement une question de la spécification d'un pfx via la configuration. Si quelqu'un veut l'améliorer sur ce point, n'hésitez pas à le faire.

de toute façon, ici, c'est le modèle de stock code que j'utilise dans le programme.cs

public class Program
{
    public static void Main(string[] args)
    {

        if (args.Contains("--service"))
        {
            var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            Directory.SetCurrentDirectory(path); //need this because WebHost.CreateDefaultBuilder queries current directory to look for config files and content root folder. service start up sets this to win32's folder.
            var host = CreateWebHostBuilder(args).Build();
            host.RunAsService();
        }
        else
        {
            CreateWebHostBuilder(args).Build().Run();
        }

    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>();
}