.Net Core 2.0 Windows-service

Antwoord 3, autoriteit 46%

Ik zal enkele opties samenvatten:

1. Verplaats uw code naar een .NET Standard-bibliotheek en host deze in een .NET Framework-app, zodat u ServiceBasekunt gebruiken. Hiervoor moet natuurlijk het .NET Framework op de doelcomputer zijn geïnstalleerd
2. Gebruik NSSM(de Non-Sucking Service Manager) om een ​​.NET Core console-app te beheren (deze heeft een publiek domein licentie)
3. Gebruik Windows API-aanroepen om verbinding te maken met Windows-servicemethoden. Dit is de benadering van DotNetCore.WindowsServiceen dotnet-win32-service(beide hebben een MIT-licentie)

Ik denk dat de opmerking van @JeroenMostert een beetje hard is – ik zie de aantrekkingskracht van het niet afhankelijk zijn van een bepaalde .NET Framework-versie die beschikbaar is op de doelmachines. Veel anderen voelen duidelijk hetzelfde, aangezien de 2 repo’s waarnaar ik heb gelinkt nogal populair zijn.

Antwoord 4, autoriteit 32%

In .NET Core 2.1 kunt u de Host en HostBuilder gebruiken om een ​​consoletoepassing te krijgen die als een service wordt uitgevoerd. Als u uw consoletoepassing in een container plaatst, kunt u de container overal implementeren en het is net hetzelfde als draaien als een service. U kunt de Host en HostBuilder gebruiken om DI, Logging, Graceful Shutdown, enz. in uw console-app te beheren. Kijk eens naar:

Hostingservices in .NET Core-consoletoepassing

Antwoord 5, autoriteit 14%

Een gemakkelijke manier om een ​​.NET Core Windows-service te maken is door Peter Kottas’ DotNetCore.WindowsService-bibliotheek te gebruiken .

Het NuGet-pakket is PeterKottas.DotNetCore.WindowsService. Om het te installeren met behulp van de Visual Studio Package Manager Console, voert u gewoon

Install-Package PeterKottas.DotNetCore.WindowsService

Er zijn goede opmerkingen over hoe u aan de slag kunt gaan, ook.

Antwoord 6, autoriteit 11%

We hebben alleen het System.ServiceProcess.ServiceController NuGet-pakket nodig om een ​​.NET Core-toepassing als Windows-service uit te voeren.

Hierna volgt het .csproj-bestand,

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFramework>netcoreapp2.1</TargetFramework>
  <RuntimeIdentifier>win7-x64</RuntimeIdentifier>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="System.ServiceProcess.ServiceController" 
 Version="4.5.0" />
</ItemGroup>
</Project>

Program.cs-bestand,

using System.ServiceProcess;
namespace WindowsService101
{
class Program
{
    static void Main(string[] args)
    {
        using (var service = new HelloWorldService())
        {
            ServiceBase.Run(service);
        }
    }
}
}
public class HelloWorldService : ServiceBase
{
    protected override void OnStart(string[] args)
    {
       // Code Here
    }
    protected override void OnStop()
    {
        // Code Here
    }
}

Bouw en publiceer de oplossing.

1. Open Cmd Prompt in Admin mode vanuit de .exe map
   Voorbeeld: \WindowsService101\bin\Debug\netcoreapp2.1\publish

2. sc create binPath=””

3. sc start

Antwoord 7, autoriteit 11%

ASP.NET Core in een Windows-service voor .NET Core 2.2. Breng de volgende wijzigingen aan in een bestaand ASP.NET Core-project om de app als een service uit te voeren:

Vereist: PowerShell 6.2 or later

Kaderafhankelijke implementatie (FDD):

Framework-dependent deployment (FDD) is afhankelijk van de aanwezigheid van een gedeelde systeembrede versie van .NET Core op het doelsysteem. Wanneer het FDD-scenario wordt gebruikt met een ASP.NET Core Windows Service-app, produceert de SDK een uitvoerbaar bestand (*.exe), een framework-afhankelijk uitvoerbaar bestand genoemd.

Voeg een Windows Runtime Identifier (RID)toe aan de <PropertyGroup>die het doelframework bevat. In het volgende voorbeeld is de RID ingesteld op win7-x64. Voeg de eigenschap <SelfContained>toe die is ingesteld op false. Deze eigenschappen instrueren de SDK om een ​​uitvoerbaar (.exe) bestand voor Windows te genereren.

Een web.config-bestand, dat normaal gesproken wordt geproduceerd bij het publiceren van een ASP.NET Core-app, is niet nodig voor een Windows Services-app. Om het maken van het web.config-bestand uit te schakelen, voegt u de eigenschap <IsTransformWebConfigDisabled>toe die is ingesteld op true.

<PropertyGroup>
  <TargetFramework>netcoreapp2.2</TargetFramework>
  <RuntimeIdentifier>win7-x64</RuntimeIdentifier>
  <SelfContained>false</SelfContained>
  <IsTransformWebConfigDisabled>true</IsTransformWebConfigDisabled>
</PropertyGroup>

Zelfstandige implementatie (SCD):

Zelfstandige implementatie (SCD) is niet afhankelijk van de aanwezigheid van gedeelde componenten op het doelsysteem. De runtime en de afhankelijkheden van de app worden samen met de app geïmplementeerd op het hostingsysteem.

Bevestig de aanwezigheid van een Windows Runtime Identifier (RID)of voeg een RID toe aan de <PropertyGroup>die het doelframework bevat. Schakel het maken van een web.config-bestand uit door de eigenschap <IsTransformWebConfigDisabled>toe te voegen die is ingesteld op true.

<PropertyGroup>
  <TargetFramework>netcoreapp2.2</TargetFramework>
  <RuntimeIdentifier>win7-x64</RuntimeIdentifier>
  <IsTransformWebConfigDisabled>true</IsTransformWebConfigDisabled>
</PropertyGroup>

Programmahoofd

public class Program
{
    public static void Main(string[] args)
    {
        var isService = !(Debugger.IsAttached || args.Contains("--console"));
        if (isService)
        {
            var pathToExe = Process.GetCurrentProcess().MainModule.FileName;
            var pathToContentRoot = Path.GetDirectoryName(pathToExe);
            Directory.SetCurrentDirectory(pathToContentRoot);
        }
        var builder = CreateWebHostBuilder(
            args.Where(arg => arg != "--console").ToArray());
        var host = builder.Build();
        if (isService)
        {
            // To run the app without the CustomWebHostService change the
            // next line to host.RunAsService();
            host.RunAsCustomService();
        }
        else
        {
            host.Run();
        }
    }
    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .ConfigureLogging((hostingContext, logging) =>
            {
                logging.AddEventLog();
            })
            .ConfigureAppConfiguration((context, config) =>
            {
                // Configure the app here.
            })
            .UseStartup<Startup>();
}

Een framework-afhankelijke implementatie (FDD) publiceren:

dotnet publish --configuration Release --output c:\svc

Een op zichzelf staande implementatie (SCD) publiceren

De RID moet worden opgegeven in de eigenschap <RuntimeIdenfifier>(of <RuntimeIdentifiers>) van het projectbestand. Lever de runtime aan de -r|–runtimeoptie van het dotnet publishcommando.

dotnet publish --configuration Release --runtime win7-x64 --output c:\svc

Verleen schrijf-/lees-/uitvoertoegang tot de map van de app met behulp van de icacls-opdracht via een administratieve PowerShell 6-opdrachtshell.

icacls "{PATH}" /grant "{USER ACCOUNT}:(OI)(CI){PERMISSION FLAGS}" /t

• {PATH} – Pad naar de map van de app.
• {USER ACCOUNT} – Het gebruikersaccount (SID).
• (OI) – De vlag Object Inherit propageert machtigingen naar ondergeschikte
  bestanden.
• (CI) – De container Inherit-vlag verspreidt machtigingen naar:
  onderliggende mappen.
• {PERMISSION FLAGS} – Stelt de toegangsrechten van de app in.
  • Schrijf (W)
  • Lees (R)
  • Uitvoeren (X)
  • Vol (F)
  • Aanpassen (M)
• /t – Recursief toepassen op bestaande onderliggende mappen en bestanden.

Opdracht:

icacls "c:\svc" /grant "ServiceUser:(OI)(CI)WRX" /t

Gebruik de RegisterService .ps1PowerShell-script om de service te registreren. Voer vanuit een administratieve PowerShell 6-opdrachtshell het script uit met de volgende opdracht:

.\RegisterService.ps1 
    -Name MyService 
    -DisplayName "My Cool Service" 
    -Description "This is the Sample App service." 
    -Exe "c:\svc\SampleApp.exe" 
    -User Desktop-PC\ServiceUser

Start de service met de Start-Service -Name {NAME}PowerShell 6-opdracht.

Start-Service -Name MyService

Gebeurtenissen starten en stoppen

internal class CustomWebHostService : WebHostService
{
    private ILogger _logger;
    public CustomWebHostService(IWebHost host) : base(host)
    {
        _logger = host.Services
            .GetRequiredService<ILogger<CustomWebHostService>>();
    }
    protected override void OnStarting(string[] args)
    {
        _logger.LogInformation("OnStarting method called.");
        base.OnStarting(args);
    }
    protected override void OnStarted()
    {
        _logger.LogInformation("OnStarted method called.");
        base.OnStarted();
    }
    protected override void OnStopping()
    {
        _logger.LogInformation("OnStopping method called.");
        base.OnStopping();
    }
}

Uitbreidingsmethode:

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

Program.Main:

host.RunAsCustomService();

Stel het hoofdpad van de inhoud in op de map van de app:

Program.Main:

var pathToExe = Process.GetCurrentProcess().MainModule.FileName;
var pathToContentRoot = Path.GetDirectoryName(pathToExe);
Directory.SetCurrentDirectory(pathToContentRoot);
CreateWebHostBuilder(args)
    .Build()
    .RunAsService();

Bron:

https:// github.com/aspnet/AspNetCore.Docs/tree/master/aspnetcore/host-and-deploy/windows-service/

https ://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/windows-service?view=aspnetcore-2.2

Antwoord 8, autoriteit 7%

Misschien is dit een complete cop-out, maar vergeet niet dat met een grotere docker-ondersteuning, kunt u mogelijk een service bouwen die loopt in een container. Op dat moment zou het nog steeds .NET-kern (2.0) zijn, maar op uw Windows-doos. Bovendien kunt u in de toekomst zo ongeveer overal inzetten.

Als DotNet Core Matures, I Dit is een betere en betere oplossing, ervan uitgaande dat uw service geen middelen nodig heeft voor de host.

9, Autoriteit 4%

Voor degenen die deze vraag vinden, maar een Windows-service willen implementeren met .NET CORE 3.X

https://csharp.christiannagel.com/2019/10/15/ WindowsService /

Een combinatie van de generieke host plus de achtergronddienst plus de Commandline Tool SC en u hebt een Windows-service.