.NET Core基于IHostedService实现定时任务

（给DotNet加星标，提升.Net技能）

转自：WeihanLi

cnblogs.com/weihanli/p/implement

介绍

从 .NET Core 2.0 开始，开始引入 IHostedService，可以通过 IHostedService 来实现后台任务，但是只能在 WebHost 的基础上使用。

从.NET Core 2.1 开始微软引入通用主机(Generic Host)，使得我们可以在不使用 Web 的情况下，也可以使用 IHostedService 来实现 定时任务/Windows服务/后台任务，并且引入了一个 BackgroundService 抽象类来更方便的创建后台任务。

namespace Microsoft.Extensions.Hosting
{
    //
    // Summary:
    //Defines methods for objects that are managed by the host.
    public interface IHostedService
    {
        //
        // Summary:
        // Triggered when the application host is ready to start the service.
        Task StartAsync(CancellationToken cancellationToken);
        //
        // Summary:
        // Triggered when the application host is performing a graceful shutdown.
        Task StopAsync(CancellationToken cancellationToken);
    }
}

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

public abstract class ScheduledService : IHostedService, IDisposable
{
    private readonly Timer _timer;
    private readonly TimeSpan _period;
    protected readonly ILogger Logger;
    protected ScheduledService(TimeSpan period, ILogger logger)
    {
        Logger = logger;
        _period = period;
        _timer = new Timer(Execute, null, Timeout.Infinite, 0);
    }
    public void Execute(object state = null)
    {
        try
        {
            Logger.LogInformation("Begin execute service");
            ExecuteAsync().Wait();
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "Execute exception");
        }
        finally
        {
            Logger.LogInformation("Execute finished");
        }
    }
    protected abstract Task ExecuteAsync();
    public virtual void Dispose()
    {
        _timer?.Dispose();
    }
    public Task StartAsync(CancellationToken cancellationToken)
    {
        Logger.LogInformation("Service is starting."); _timer.Change(TimeSpan.FromSeconds(SecurityHelper.Random.Next(10)), _period);
        return Task.CompletedTask;
    }
    public Task StopAsync(CancellationToken cancellationToken)
    {
        Logger.LogInformation("Service is stopping.");
        _timer?.Change(Timeout.Infinite, 0);
        return Task.CompletedTask;
    }
}

基于上面这个基于Timer实现的后台定时任务类实现一个定时任务：

public class RemoveOverdueReservationService : ScheduledService
{
    public RemoveOverdueReservationService(ILogger<RemoveOverduedReservtaionService> logger) : base(TimeSpan.FromDays(1), logger)
    { }
    protected override Task ExecuteAsync()
    {
        return DependencyResolver.Current.TryInvokeServiceAsync<IEFRepository<ReservationDbContext, Reservation>>(reservationRepo =>
        {
            return reservationRepo.DeleteAsync(reservation => reservation.ReservationStatus == 0 && (reservation.ReservationForDate < DateTime.Today.AddDays(-3)));
        });
    }
}

这个类实现的是每天执行一次，删除三天前状态为待审核的预约，完整实现代码：https://github.com/WeihanLi/ActivityReservation/blob/dev/ActivityReservation.Helper/Services/RemoveOverduedReservtaionService.cs

在程序启动的时候注册服务：

services.AddHostedService<RemoveOverduedReservtaionService>();

执行日志：

通过日志可以看到我们的定时任务确实是每天执行一次，这样我们的定时任务就算是简单的完成了。 

推荐阅读  点击标题可跳转

看完本文有收获？请转发分享给更多人

关注「DotNet」加星标，提升.Net技能 

好文章，我在看❤️