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

}

}

// 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 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 ScheduedService : IHostedService, IDisposable

{

private readonly Timer _timer;

private readonly TimeSpan _period;

protected readonly ILogger Logger;

protected ScheduedService(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;

}

}

public class RemoveOverduedReservtaionService : ScheduedService

{

public RemoveOverduedReservtaionService(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)));

});

}

}