如何在MVC核心应用程序中无HTTP请求启动HostedService

使用Visual Studio运行时,很可能会使用IIS Express,在发出第一个请求之前,它不会运行ASP.NET核心项目(这实际上只是默认情况下IIS的工作方式)。这适用于使用ASP.NET Core 2.2新的进程内宿主模型时,我希望您必须使用该模型才能看到此问题。看看这个 GitHub issue 更多。

您可以通过从.csproj文件中删除aspnetcorehostingmodel xml元素来证明此理论,该文件正用于宿主ASP.NET核心应用程序(它将切换回outofprocess模式)。看起来在vs2017的项目属性对话框中的“debug”下有一个“hosting model”选项,如果不想直接编辑.csproj,可以改为“out of process”。

例如,如果您希望仅生产站点的宿主模型不在处理过程中,则可以使用web.config转换。如果您希望它在开发和生产过程中都不在进程中,只要更改上面调用的属性就足够了,因为它会自动转换为web.config属性。如果您希望使用进程内模型,那么在IIS应用程序中启用预加载是一个很好的选择(已描述 here )

托管服务 做 主机启动时启动。通过WebHost,托管服务 will be started right after the application has started . 这意味着,如果实现正确,托管服务将在不需要请求进入的情况下运行。

当我在一个新的ASP.NET核心应用程序上尝试您的示例托管服务时,它工作得很好,所以如果它不适合您,那么显然您的 实际的 实施 KontolerTimer 是不对的。

如果要让服务执行后台任务(类似于旧的Windows服务),我建议您使用: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-host?view=aspnetcore-2.2 而不是网络主机。

webhost添加了很多你可能不需要的东西,因为这看起来是一个简单的后台工作(假设你在读代码)。

后台服务在应用程序启动时启动,然后由您来与之同步。

您可以使用 BackgroundService 命名空间中的类 Microsoft.Extensions.Hosting ( Microsoft.Extensions.Hosting.Abstractions 组装):

首先声明服务的接口(在本例中,它是空的,不是好的,而是干净的):

public interface IMyService : IHostedService
{
}

然后,宣布你的服务。下面的代码片段声明了一个服务,该服务在启动腰部运行5秒钟,然后每隔2分钟半执行一个任务:

internal sealed class MyService : BackgroundService, IMyService
{
    private const int InitialDelay = 5 * 1000;  //5 seconds;
    private const int Delay = (5 * 60 * 1000) / 2; // 2.5 minutes

    private readonly ILogger<MyService> m_Logger;

    public MyService(ILogger<MyService> logger, IServiceProvider serviceProvider)
    {
        if (logger == null)
            throw new ArgumentNullException(nameof(logger));
        if (serviceProvider == null)
            throw new ArgumentNullException(nameof(serviceProvider));

        this.m_Logger = logger;
        this.m_ServiceProvider = serviceProvider;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            m_Logger.LogDebug($"MyService is starting.");

            stoppingToken.Register(() => m_Logger.LogDebug($"MyService background task is stopping because cancelled."));

            if (!stoppingToken.IsCancellationRequested)
            {
                m_Logger.LogDebug($"MyService is waiting to be scheduled.");
                await Task.Delay(InitialDelay, stoppingToken);
            }

            m_Logger.LogDebug($"MyService is working.");

            while (!stoppingToken.IsCancellationRequested)
            {
                await DoSomethingAsync();

                await Task.Delay(Delay);
            }

            m_Logger.LogDebug($"MyService background task is stopping.");
        }
        catch (Exception ex)
        {
            m_Logger.LogDebug("MyService encountered a fatal error while w task is stopping: {Exception}.", ex.ToString());
        }
    }

    private async Task DoSomrthingAsync()
    {
         // do something here
         await Task.Delay(1000);
    }

}

如你所见,后台服务是否“活跃”取决于你。最后,您必须在 Startup.cs 在你的最后 ConfigureServices 方法:

services.AddSingleton<Microsoft.Extensions.Hosting.IHostedService, MyService>();

这足以启动服务。请记住,如果托管在IIS中,您的应用程序可以在稍后实际启动:每次回收程序集时,您的应用程序都会重新启动。相反,使用kestrel,提供了一个不会被回收的单实例应用程序。

对于那些使用.NET Core 2.1或更低版本的用户,后台类不可用,但您可以从GitHub获取定义(我将过去使用的内容发布为GitHub存储库可以移动):

//borrowed from .NET Core 2.1 (we are currently targeting 2.0.3)
// Copyright (c) .NET Foundation. Licensed under the Apache License, Version 2.0.
/// <summary>
/// Base class for implementing a long running <see cref="IHostedService"/>.
/// </summary>
public abstract class BackgroundService : IHostedService, IDisposable
{
    private Task _executingTask;

    private readonly CancellationTokenSource _stoppingCts =
                                                   new CancellationTokenSource();

    protected abstract Task ExecuteAsync(CancellationToken cancellationToken);

    public virtual Task StartAsync(CancellationToken cancellationToken)
    {
        // Store the task we're executing
        _executingTask = ExecuteAsync(_stoppingCts.Token);

        // If the task is completed then return it,
        // this will bubble cancellation and failure to the caller
        if (_executingTask.IsCompleted)
        {
            return _executingTask;
        }

        // Otherwise it's running
        return Task.CompletedTask;
    }

    public virtual async Task StopAsync(CancellationToken cancellationToken)
    {
        // Stop called without start
        if (_executingTask == null)
        {
            return;
        }

        try
        {
            // Signal cancellation to the executing method
            _stoppingCts.Cancel();
        }
        finally
        {
            // Wait until the task completes or the stop token triggers
            await Task.WhenAny(_executingTask, Task.Delay(Timeout.Infinite,
                                                          cancellationToken));
        }
    }

    public virtual void Dispose()
    {
        _stoppingCts.Cancel();
    }
}