Quartz.NET – gerenciamento de jobs/tasks com asp.net

Em nosso último post, falamos aqui do Hangfire, que é utilizado para gerenciamento de jobs/tasks, assim como o Quartz.NET, que vamos mostrar hoje. Eles tem algumas coisas em comum, e claro, suas diferenças, mas ambos funcionam muito bem e cumprem bem o papel que se propõem.

Diferente do Hangfire, o Quartz.NET não possui versão paga, tendo apenas uma versão gratuita e open-source. Outra diferença é a ausência de um dashboard. Um ponto em comum entre ambos, é que existem extensões que podem ser usadas, como por exemplo um dashboard, existem alguns disponíveis, sendo que o que mais me agradou foi o CrystalQuartz, que mostrarei aqui em breve.

Para controlar a execição dos jobs, o Quartz pode trabalhar de duas maneiras:

• utilizando um banco de dados relacional, como o MS Sql Server, Oracle, MySql, Firebird, etc. A lista completa você encontra na documentação do Quartz clicando aqui. Dessa forma o controle de jobs é persistido, e caso a aplicação seja reiniciada as execuções continuam de onde pararam.
• utilizando a memória RAM, o que é mais rápido que usar um bando de dados, mas tem como desvantagem o fato de não ser feita nenhuma persistência, e caso a aplicação seja reiniciada, a execução dos jobs começará do início novamente. Isso é um problema para algumas aplicações, mas para outras, é um comportamento excelente. Essa opção é a padrão do Quartz.

O Quartz trabalha com o conceito de Triggers e Jobs, sendo que as classes e interfaces principais da API do Quartz são:

• IScheduler: a API principal do Quartz, utilizada para interação com o gerenciador (scheduler);
• IJob: uma interface para ser implementada por classes que representarão os Jobs, sendo elas que serão executadas pelo scheduler do Quartz;
• IJobDetail: usado para definir instâncias dos Jobs;
• ITrigger: define como o Job será executado, como por exemplo o intervalo de execução;
• JobBuilder: usado para criar uma instância de JobDetail;
• TriggerBuilder: usado para criar instâncias de Trigger;

Agora que já vimos como é a estrutura do Quartz, vamos ao código. Abra o Visual Studio 2017, e crie uma aplicação do tipo ASP.NET Core Web Application (.NET Core) com o nome WebDemoQuartz e na tela seguinte selecione o template Web API. Após criar o projeto, vamos adicionar o Quartz ao nosso projeto, para isso abra o console do Nuget e digite:

Install-Package Quartz -Pre

A última versão estável do Quartz é a 2.6, porém ela não é compatível com o .net core, por isso nesse exemplo optei por utilizar a versão 3.0, que ainda está em fase de desenvolvimento e não deve ser usada em produção.

Agora vamos criar um Job, para isso crie um nova classe com o nome DemoJob com o conteúdo abaixo:

using Quartz;
using System;
using System.Diagnostics;
using System.Threading.Tasks;

namespace WebDemoQuartz
{
    public class DemoJob : IJob
    {
        public Task Execute(IJobExecutionContext context)
        {
            Debug.WriteLine($"DemoJob: {DateTime.Now}");
            Debug.WriteLine($"JobKey: {context.JobDetail.Key}");
            return Task.CompletedTask;
        }
    }
}

Agora vamos criar nosso gerenciador (scheduler), para isso vamos criar um método chamado StartScheduler na classe Startup:

private void StartScheduler()
{
	StdSchedulerFactory factory = new StdSchedulerFactory();
	IScheduler scheduler = factory.GetScheduler().Result;
	scheduler.Start().Wait();
	ScheduleJobs(scheduler);
}

O que fizemos aqui foi criar um SchedulerFactory, e a partir dele, criamos um Scheduler, como não passamos nenhum parâmetro, ele será criado com as configurações padrão, que é para gerenciar os jobs em memória. Depois iniciamos o scheduler, e chamamos o método ScheduleJobs, que vamos criar agora:

private void ScheduleJobs(IScheduler scheduler)
{
	IJobDetail job = JobBuilder.Create<DemoJob>().WithIdentity("demoJob", "demoGroup").Build();
	// Trigger para que o job seja executado imediatamente, e repetidamente a cada 15 segundos
	ITrigger trigger = TriggerBuilder.Create()
	  .WithIdentity("demoTrigger", "demoGroup")
	  .StartNow()
	  .WithSimpleSchedule(x => x
		  .WithIntervalInSeconds(15)
		  .RepeatForever())
	  .Build();
	scheduler.ScheduleJob(job, trigger).Wait();
}

Aqui o que fizemos foi primeiro criar um JobDetail, para nossa classe DemoJob, depois criamos uma Trigger, de início imediato, e que se repete eternamente a cada 15 segundos. E por fim, nós informamos ao scheduler (gerenciador) o nosso Job e nossa Trigger.

E por fim, vamos alterar o método Configure, adicionando uma chamada ao método StartScheduler que criamos, dessa forma o método Configure ficará assim:

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
	StartScheduler();

	loggerFactory.AddConsole(Configuration.GetSection("Logging"));
	loggerFactory.AddDebug();

	app.UseMvc();
}

Pronto, já podemos rodar nossa aplicação e ver o resultado sendo impresso no console.

O Quartz vai muito mais além do que o que vimos nesse post, e em breve falaremos mais dele. Enquanto isso, se quiser saber mais, acesse o site oficial do Quartz clicando aqui, ou então o seu GitHub clicando aqui.

E como de costume, nossa aplicação de exemplo está disponível no GitHub em: https://github.com/desenvolvedorninja/quartznet-primeiros-passos.