ASP.NET: CRON Service Employee – DEV Neighborhood 👩‍💻👨‍💻

En este artículo veremos como crear un servicio en segundo plano que se ejecutará según un programa de intervalos. Este será expresado como si fuera una tarea CRON de Linux, que son en esencia, tareas programadas.

Nota 💡: Aquí encuentras el código fuente

El formato cron se expresa de la siguiente manera:

                                       Allowed values    Allowed particular characters   Remark

┌───────────── second (elective)       0-59              * , - /                      
│ ┌───────────── minute                0-59              * , - /                      
│ │ ┌───────────── hour                0-23              * , - /                      
│ │ │ ┌───────────── day of month      1-31              * , - / L W ?                
│ │ │ │ ┌───────────── month           1-12 or JAN-DEC   * , - /                      
│ │ │ │ │ ┌───────────── day of week   0-6  or SUN-SAT   * , - / # L ?                Each 0 and seven means SUN
│ │ │ │ │ │
* * * * * *

Donde 5 o 6 caracteres representan el intervalo de tiempo en el que la tarea se ejecutará, ejemplo:

Nota 💡: Si quieres conocer más, puedes visitar este repositorio HangfireIO/Cronnos

Implementación en ASP.NET Core y Hosted Providers

Antes de seguir, realizar este tipo de background companies en asp.web core es cada vez más fácil, tan fácil que ya existen soluciones como HangFire y Azure Capabilities que realizan este tipo de tareas (también basadas en formato CRON). Pero si de igual forma, quisieras aprender hacer tu implementación (a veces es mejor hold it easy) te recomiendo seguir leyendo 🤓.

Para comenzar, crearemos un proyecto net vacío o de consola, da igual ya que no utilizaremos ningún endpoint HTTP, pero puedes mezclarlos sin problema.

dotnet new net -o BackgroundJob.Cron

Instalamos la librería Cronos para poder parsear expresiones CRON.

dotnet add package deal Cronos

CronBackgroundJob

Esta clase base y abstracta, será la que se encargará de ejecutar un proceso según un intervalo de tiempo, este intervalo será definido como ya lo hemos dicho, con una expresión CRON.

utilizing Cronos;

namespace BackgroundJob.Cron.Jobs;

public summary class CronBackgroundJob : BackgroundService
{

    non-public PeriodicTimer? _timer;

    non-public readonly CronExpression _cronExpression;

    non-public readonly TimeZoneInfo _timeZone;

    public CronBackgroundJob(string rawCronExpression, TimeZoneInfo timeZone)
    {
        _cronExpression = CronExpression.Parse(rawCronExpression);
        _timeZone = timeZone;
    }

    protected override async Process ExecuteAsync(CancellationToken stoppingToken)
    {
        DateTimeOffset? nextOcurrence = _cronExpression.GetNextOccurrence(DateTimeOffset.UtcNow, _timeZone);

        if (nextOcurrence.HasValue)
        {          

            var delay = nextOcurrence.Worth - DateTimeOffset.UtcNow;  
            _timer = new PeriodicTimer(delay);

            if (await _timer.WaitForNextTickAsync(stoppingToken))
            {            
                _timer.Dispose();
                _timer = null;

                await DoWork(stoppingToken);

                // Reagendamos
                await ExecuteAsync(stoppingToken);
            }
        }
    }

    protected summary Process DoWork(CancellationToken stoppingToken);
}

• PeriodicTimer: Es un nuevo Timer que nos permite “esperar” el siguiente “Tick” del timer. Es decir, si queremos que el timer se ejecute cada 60 segundos, el método WaitForNextTickAsync estará en modo await hasta que hayan transcurrido esos 60 segundos. Este método regresa true si el intervalo se cumplió y nadie canceló la tarea, regresará false si el stoppingToken canceló la ejecución.
  • Creamos el timer con la diferencia de tiempo (TimeSpan) entre la fecha y hora precise y la fecha y hora de la siguiente ocurrencia, es decir: Si estamos 27/10/2022 15:00 y la siguiente ocurrencia es el 27/10/2022 16:00, hay una diferencia de 1 hora (3600000 milisegundos), hasta que pase ese tiempo, el PeriodicTimer lanzará su Subsequent Tick.
• CronExpression: Nos ayuda a entender una expresión cron, en este caso tenemos que darle una fecha y un uso horario (este opcional) para que se pueda determinar cuándo será la siguiente ocurrencia (o sea, la siguiente fecha y hora en que se debe de correr la tarea)
  • GetNextOcurrence: Regresa un DateTimeOffset con la fecha a futuro en donde toca ya correr la tarea.
• WaitForNextTickAsync: Este método genera un Process que se espera hasta que ocurra el siguiente Tick del Timer.
  • Cada ejecución liberamos el timer para que en el siguiente ciclo volverlo a crear con la siguiente ocurrencia del Cron, ya que esto no necesariamente será una espera estática o igual en cada Tick.
  • Un ejemplo es si pongo que corra de lunes a viernes a las 9PM, la ejecución de jueves a viernes esperará 24 horas, pero de viernes a lunes esperará 72 horas.
• DoWork: Este método abstracto será el que se ejecutará en cada ocurrencia, es abstracto porque cada Employee que hagamos, hará una tarea diferente.

Al terminar de correr el DoWork de forma recursiva, mandamos a llamar nuevamente la tarea para agendar la siguiente ejecución, esto durará por siempre o hasta que el stoppingToken diga lo contrario.

CronSettings

Para poder correr el employee/job anterior, debemos de poder tener una expresión cron y aparte el uso horario que se quiera considerar.

namespace BackgroundJob.Cron.Jobs;

public class CronSettings<T>
{
    public string CronExpression { get; set; } = default!;
    public TimeZoneInfo TimeZone { get; set; } = default!;
}

CronBackgroundJobExtensions

Para hacer fácil esta integración entre los choices y cada background job, es mejor crear este método de extensión que nos ayudará a registrar cada dependencia de cada job.

namespace BackgroundJob.Cron.Jobs;

public static class CronBackgroundJobExtensions
{
    public static IServiceCollection AddCronJob<T>(this IServiceCollection companies, Motion<CronSettings<T>> choices)
        the place T: CronBackgroundJob
    {
        if (choices == null)
        {
            throw new ArgumentNullException(nameof(choices));
        }

        var config = new CronSettings<T>();
        choices.Invoke(config);

        if (string.IsNullOrWhiteSpace(config.CronExpression))
        {
            throw new ArgumentNullException(nameof(CronSettings<T>.CronExpression));
        }

        companies.AddSingleton<CronSettings<T>>(config);
        companies.AddHostedService<T>();

        return companies;
    }
}

Usamos el Choices Sample muy común en ASP.NET para registrar cada background job que necesitemos.

Es obligatorio que se indique una configuración por medio de CronSettings<T> y también es obligatorio tener una expresión cron.

MySchedulerJob

Este será el background job de ejemplo:

namespace BackgroundJob.Cron.Jobs;

public class MySchedulerJob : CronBackgroundJob
{
    non-public readonly ILogger<MySchedulerJob> _log;

    public MySchedulerJob(CronSettings<MySchedulerJob> settings, ILogger<MySchedulerJob> log)
        :base(settings.CronExpression, settings.TimeZone)
    {
        _log = log;
    }

    protected override Process DoWork(CancellationToken stoppingToken)
    {
        _log.LogInformation("Working... at {0}", DateTime.UtcNow);

        return Process.CompletedTask;
    }
}

Realmente lo único que hace es escribir en los logs la fecha en la que se ejecutó y así poder comprobar que todo funciona.

Program

Para finalizar, registramos las dependencias con la extensión que escribimos y vualá, ya podemos correr.

utilizing BackgroundJob.Cron.Jobs;

var builder = WebApplication.CreateBuilder(args);

builder.Providers.AddCronJob<MySchedulerJob>(choices => 
{
    // Corre cada minuto
    choices.CronExpression = "* * * * *";
    choices.TimeZone = TimeZoneInfo.Native;
});

var app = builder.Construct();

app.Run();

Y el resultado:

A pesar de que ya existen soluciones que nos ayuda implementar este tipo de tareas, mantener las cosas simples a veces es la opción que necesitas por que la tarea es easy.

Si necesitas algo que escale, que sea resiliente, versatile a un costo de tiempo bajo, definitivamente te recomiendo irte por Azure Capabilities. Si no estás en Azure, puedes irte por Hangfire.

Pero si lo que necesitas son tareas programadas y no depender de Azure, los Hosted Providers es una buena opción.