using System;

using System.Linq;

using System.Threading;

using System.Threading.Tasks;

using Microsoft.Extensions.Hosting;

using Microsoft.Extensions.DependencyInjection;

using Microsoft.EntityFrameworkCore;

​

public enum BackgroundJobTypes

{

    Computing

}

​

public enum BackgroundJobStates

{

    Pending

}

​

public class BackgroundJob

{

    public long Id {get;set;}

    public BackgroundJobStates State {get;set;} 

    public BackgroundJobTypes Type {get;set;}

    public void DoWork()

    {

    }

    public void MarkForRetry(Exception ex)

    {

    }

}

​

public class DBContext : DbContext

{

    public DbSet<BackgroundJob> BackgroundJobs { get; set; }

}

​

public class BackgroundProcessWorker : BackgroundService

{

    private readonly IServiceScopeFactory _serviceScopeFactory;

    public BackgroundProcessWorker(IServiceScopeFactory scopeFactory)

    {

         _serviceScopeFactory = scopeFactory;

    }

    /* Continously run and fetch available "background jobs" from the DB that are in the state "Pending" and of type "Computing" and process them.

    * If the call to a background job fails we mark it to be retried and continue processing the loop. */

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)

    {

        //Create scope since service runs as singleton

        using var scope = _serviceScopeFactory.CreateScope();

        //Resolve the DB context

        var dbContext = scope.ServiceProvider.GetRequiredService<DBContext>();

        //Enter run loop

        while (!stoppingToken.IsCancellationRequested)

        {

            //Get the Id and Type of pending jobs

            var pendingJobs = dbContext.BackgroundJobs

                .ToList()

                .Where(e => e.State == BackgroundJobStates.Pending)

                .Select(e => new { e.Id, e.Type });

            //Process the jobs in parallel

            await Parallel.ForEachAsync(pendingJobs, async (pendingJob, stoppingToken) =>

            {

                //We only want to process the background jobs of type "Computing" so just return for other jobs

                if (pendingJob.Type != BackgroundJobTypes.Computing)

                {

                    return;

                }

                //Fetch the background job

                var backgroundJob = await dbContext.BackgroundJobs

                       .Where(e => e.Id == pendingJob.Id)

                       .SingleAsync(stoppingToken);

                try

                {

                    //Execute the job

                    backgroundJob.DoWork();

                    //Save the changes

                    await dbContext.SaveChangesAsync();

                }

                catch(Exception e)

                {

                    //Continue processing rest of batch

                    backgroundJob.MarkForRetry(e);

                    throw new ArgumentException("Processing failed", e);

                }

            });

            //Wait a second before running next loop

            await Task.Delay(1000);

        }

    }

}