Programmering

Hvordan planlegge jobber med Quartz.NET i ASP.NET Core

Når du jobber med webapplikasjoner, vil du ofte måtte utføre visse oppgaver i bakgrunnen. I noen tilfeller vil dette være oppgaver som skal utføres med forhåndsdefinerte tidsintervaller.

Quartz.NET er en åpen kildekode .NET-port til det populære Java-planleggingsrammen. Den har vært i bruk i lang tid og gir utmerket støtte for å jobbe med Cron-uttrykk. Du kan lære mer om Quartz.NET fra et tidligere innlegg her.

Denne artikkelen presenterer en diskusjon om hvordan vi kan jobbe med Quartz.NET i ASP.NET Core for å planlegge bakgrunnsjobber.

For å jobbe med kodeeksemplene som er gitt i denne artikkelen, bør du ha Visual Studio 2019 installert på systemet ditt. Hvis du ikke allerede har en kopi, kan du laste ned Visual Studio 2019 her.

Opprett et ASP.NET Core API-prosjekt

Først og fremst, la oss lage et ASP.NET Core-prosjekt i Visual Studio. Forutsatt at Visual Studio 2019 er installert i systemet ditt, følger du trinnene som er beskrevet nedenfor for å opprette et nytt ASP.NET Core-prosjekt i Visual Studio.

  1. Start Visual Studio IDE.
  2. Klikk på "Opprett nytt prosjekt."
  3. I vinduet "Opprett nytt prosjekt" velger du "ASP.NET Core Web Application" fra listen over maler som vises.
  4. Klikk på Neste.
  5. I vinduet “Konfigurer ditt nye prosjekt” som vises, angir du navnet og stedet for det nye prosjektet.
  6. Klikk på Opprett.
  7. I vinduet "Create New ASP.NET Core Web Application" velger du .NET Core som kjøretid og ASP.NET Core 2.2 (eller nyere) fra rullegardinlisten øverst. Jeg bruker ASP.NET Core 3.0 her.
  8. Velg “API” som prosjektmal for å opprette et nytt ASP.NET Core API-program.
  9. Forsikre deg om at avmerkingsboksene "Aktiver Docker-støtte" og "Konfigurer for HTTPS" ikke er merket av da vi ikke bruker disse funksjonene her.
  10. Forsikre deg om at autentisering er angitt som “ingen godkjenning”, da vi heller ikke bruker autentisering.
  11. Klikk på Opprett.

Dette vil opprette et nytt ASP.NET Core API-prosjekt i Visual Studio. Velg Controllers-løsningsmappen i Solution Explorer-vinduet, og klikk "Legg til -> Controller ..." for å opprette en ny kontroller som heter DefaultController.

Deretter, for å jobbe med Quartz, bør du installere Quartz-pakken fra NuGet. Du kan gjøre dette enten via NuGet pakkebehandling i Visual Studio 2019 IDE, eller ved å utføre følgende kommando på NuGet pakkebehandler-konsoll:

Installasjonspakke kvarts

Quartz.NET jobber, utløsere og planleggere

De tre hovedkonseptene i Quartz.NET er jobber, utløsere og planleggere. En jobb inneholder koden for å utføre en oppgave eller en jobb som skal utføres. En jobb representeres av en klasse som implementerer IJob-grensesnittet. En utløser brukes til å spesifisere tidsplanen og andre detaljer for en jobb. Du kan dra nytte av en utløser for å spesifisere hvordan jobben skal utføres. Planleggeren er komponenten som er ansvarlig for avstemning og utføring av jobber basert på forhåndsdefinerte tidsplaner.

Opprett en planlegger ved hjelp av Quartz.NET

Det bør bemerkes at du kan ha flere planleggere i et program. Vi bruker imidlertid bare en planlegger her for enkelhets skyld. Følgende kodebit illustrerer hvordan du kan opprette en planleggerforekomst.

var scheduler = StdSchedulerFactory.GetDefaultScheduler (). GetAwaiter (). GetResult ();

Når planleggeren er opprettet, kan du bruke følgende kode i ConfigureServices-metoden i Startup.cs-filen for å legge til planleggerforekomsten som en singleton-tjeneste.

tjenester.AddSingleton (planlegger);

Start og stopp en planlegger med Quartz.NET

For å starte og stoppe planleggeren vil vi dra nytte av en hostingtjeneste. For å gjøre dette må du opprette en klasse som implementerer IHostingService-grensesnittet som vist i kodebiten gitt nedenfor.

offentlig klasse CustomQuartzHostedService: IHostedService

{

privat readonly IScheduler _scheduler;

offentlig CustomQuartzHostedService (IScheduler planlegger)

        {

_scheduler = planlegger;

        }

offentlig asynk Oppgave StartAsync (CancellationToken cancellationToken)

        {

venter på _scheduler? .Start (cancellationToken);

        }

public async Task StopAsync (CancellationToken cancellationToken)

        {

venter på _scheduler?. Shutdown (cancellationToken);

        }

 }

Merk at du bør registrere den vertte tjenesten i tjenestesamlingen i ConfigureServices-metoden ved hjelp av kodebiten gitt nedenfor.

services.AddHostedService ();

Her er den oppdaterte ConfigureServices-metoden for din referanse:

offentlig ugyldighet ConfigureServices (IServiceCollection-tjenester)

{

tjenester.AddControllers ();

var planlegger =

StdSchedulerFactory.GetDefaultScheduler (). GetAwaiter (). GetResult ();

tjenester.AddSingleton (planlegger);

services.AddHostedService ();

}

Opprett en jobb ved hjelp av Quartz.NET

Som jeg sa tidligere, er en jobb en klasse som implementerer IJob-grensesnittet og inneholder Execute () -metoden. Metoden Execute () godtar en forekomst av typen IJobExecutionContext.

Følgende kodebit illustrerer en jobbklasse som også inneholder en asynkron utfør () -metode. Denne metoden inneholder koden som tilsvarer oppgaven din jobb skal utføre.

[DisallowConcurrentExecution]

offentlig klasse NotificationJob: IJob

    {

privat readonly ILogger _logger;

public NotificationJob (ILogger logger)

        {

_logger = logger;

        }

public Task Execute (IJobExecutionContext context)

        {

_logger.LogInformation ("Hei verden!");

return Task.CompletedTask;

        }

    }

Opprett en jobbfabrikk ved hjelp av Quartz.NET

En jobbfabrikk er en klasse som arver IJobFactory-grensesnittet og implementerer NewJob () og ReturnJob () -metodene. Følgende kodebit kan brukes til å opprette en fabrikklasse som kan opprette og returnere en jobbforekomst.

offentlig klasse CustomQuartzJobFactory: IJobFactory

    {

privat readonly IServiceProvider _serviceProvider;

offentlig CustomQuartzJobFactory (IServiceProvider serviceProvider)

        {

_serviceProvider = serviceProvider;

        }

offentlig IJob NewJob (TriggerFiredBundle triggerFiredBundle,

IScheduler scheduler)

        {

var jobDetail = triggerFiredBundle.JobDetail;

returner (IJob) _serviceProvider.GetService (jobDetail.JobType);

        }

offentlig ugyldig ReturnJob (IJob-jobb) {}

    }

Vær oppmerksom på at denne implementeringen ikke benytter seg av samling av jobber. Hvis du vil bruke jobbpooling, bør du endre NewJob () -metoden og deretter implementere ReturnJob () -metoden.

Opprett en JobMetadata-klasse for å lagre jobbmetadataene dine

Vi bruker en tilpasset klasse til å lagre metadata relatert til en jobb, dvs. jobb-ID, navn osv. Følgende klasse representerer jobb-metadata-klassen.

offentlig klasse JobMetadata

    {

public Guid JobId {get; sett; }

offentlig Type JobType {get; }

offentlig streng JobName {get; }

offentlig streng CronExpression {get; }

offentlige JobMetadata (veilednings-ID, skriv jobType, streng jobbnavn,

streng cronExpression)

        {

JobId = Id;

JobType = jobType;

JobName = jobName;

CronExpression = cronExpression;

        }

    }

Opprett en vertstjeneste for å starte og stoppe Quartz.NET-planleggeren

Deretter må vi implementere en vertstjeneste. En vertstjeneste er en klasse som implementerer IHostedService-grensesnittet og starter Quartz scheduler. Følgende kodeliste illustrerer en tilpasset hostet serviceklasse.

offentlig klasse CustomQuartzHostedService: IHostedService

    {

privat readonly ISchedulerFactory schedulerFactory;

privat readonly IJobFactory jobFactory;

privat readonly JobMetadata jobMetadata;

offentlig CustomQuartzHostedService (ISchedulerFactory

planleggerFabrikk,

JobMetadata jobbMetadata,

IJobFactory jobbFabrikk)

        {

this.schedulerFactory = schedulerFactory;

this.jobMetadata = jobMetadata;

this.jobFactory = jobFactory;

        }

offentlig IScheduler Scheduler {get; sett; }

offentlig asynk Oppgave StartAsync (CancellationToken cancellationToken)

        {

Planlegger = avventer schedulerFactory.GetScheduler ();

Scheduler.JobFactory = jobFactory;

var jobb = CreateJob (jobMetadata);

var trigger = CreateTrigger (jobMetadata);

avventer Scheduler.ScheduleJob (jobb, utløser, cancellationToken);

avventer Scheduler.Start (cancellationToken);

        }

public async Task StopAsync (CancellationToken cancellationToken)

        {

avventer planlegger? .Lukking (cancellationToken);

        }

private ITrigger CreateTrigger (JobMetadata jobMetadata)

        {

returner TriggerBuilder.Create ()

.WithIdentity (jobMetadata.JobId.ToString ())

.WithCronSchedule (jobMetadata.CronExpression)

.WithDescription ($ "{jobMetadata.JobName}")

.Bygge();

        }

private IJobDetail CreateJob (JobMetadata jobMetadata)

        {

returner JobBuilder

.Create (jobMetadata.JobType)

.WithIdentity (jobMetadata.JobId.ToString ())

.WithDescription ($ "{jobMetadata.JobName}")

.Bygge();

        }

    }

Følgende kodebit viser den komplette koden til ConfigureServices-metoden i oppstartsklassen.

offentlig ugyldighet ConfigureServices (IServiceCollection-tjenester)

{

tjenester.AddControllers ();

tjenester.AddSingleton ();

tjenester.AddSingleton ();

tjenester.AddSingleton ();

services.AddSingleton (nye JobMetadata (Guid.NewGuid (), typeof (NotificationJob), "Notification Job", "0/10 * * * *?"));

services.AddHostedService ();

}

Og det er alt du trenger å gjøre! Når du kjører applikasjonen, vil du observere at metoden Execute () i NotificationJob-klassen kjører hvert 10. sekund.

Quartz.NET er et godt valg for å implementere planleggere i applikasjonene dine. Du kan dra nytte av utholdenhetsfunksjonen i Quartz.NET for å lagre jobbene dine i en database som SQL Server, PostgreSQL eller SQLite også.