71  
dotnet
 
Search  
RU EN
Apr 29, 2024

Scheduling background jobs with Quartz.NET

Scheduling background jobs with Quartz.NET
Author:
Source:
Views:
4829
Scheduling background jobs with Quartz.NET favorites 0

Background tasks are crucial in many software applications, and scheduling them to run periodically or at specific times is a common requirement. In the .NET ecosystem, Quartz.NET provides a robust and flexible framework for scheduling such tasks. Let’s delve into what Quartz.NET is, why it is useful, and how we can effectively use it to schedule background jobs.

Introduction to Quartz.NET

Quartz.NET is a full-featured, open-source job scheduling system that can be integrated with, or used alongside, virtually any .NET application. It was ported from the popular Java library, Quartz, which has a long history in the Java community.

Quartz.NET allows developers to schedule jobs using a variety of methods, with jobs set to occur at specific times, intervals, or cron expressions. Additionally, Quartz.NET includes built-in support for job clustering and persistence.

Quartz.NET

Setting Up Quartz.NET

To use Quartz.NET, first install it via the NuGet package manager. In the package manager console, type:

Install-Package Quartz

Creating a Job

After installing Quartz.NET, the next step is to create a job. Jobs in Quartz.NET are simply classes that implement the IJob interface, which includes a single method, Execute.

Here’s an example of a simple job:

public class HelloWorldJob : IJob
{
    public Task Execute(IJobExecutionContext context)
    {
        Console.WriteLine("Hello, Quartz.NET!");
        return Task.CompletedTask;
    }
}

This job writes a greeting to the console.

Scheduling a Job

Scheduling a job in Quartz.NET involves a few steps. Here’s an example of how to schedule the HelloWorldJob to run every 5 seconds:

Scheduling a job in Quartz.NET involves a few steps. Here’s an example of how to schedule the HelloWorldJob to run every 5 seconds:

  • Create a StdSchedulerFactory and start it:

    ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
    IScheduler scheduler = await schedulerFactory.GetScheduler();
    await scheduler.Start();
     
  • Create a JobDetail instance:

    IJobDetail job = JobBuilder.Create<HelloWorldJob>()
                               .WithIdentity("HelloWorldJob", "Group1")
                               .Build();
     
  • Create a Trigger instance:

    ITrigger trigger = TriggerBuilder.Create()
                                     .WithIdentity("Trigger1", "Group1")
                                     .StartNow()
                                     .WithSimpleSchedule(x => x
                                         .WithIntervalInSeconds(5)
                                         .RepeatForever())
                                     .Build();
     
  • Schedule the job with the trigger:

    await scheduler.ScheduleJob(job, trigger);

Cron Schedules

While simple schedules are sufficient for many tasks, Quartz.NET also supports cron-like schedule expressions for complex schedules.

Here’s an example of a cron schedule that fires every weekday at 9:30 AM:

ITrigger trigger = TriggerBuilder.Create()
                                 .WithIdentity("Trigger2", "Group1")
                                 .WithCronSchedule("0 30 9 ? * MON-FRI")
                                 .Build();

Persisting Jobs

Quartz.NET allows jobs to be persisted, which means they survive application restarts. To configure a persisted job, you must configure Quartz.NET to use a job store. Here’s an example of how to use a JDBC job store:

NameValueCollection props = new NameValueCollection
{
    { "quartz.serializer.type", "binary" },
    { "quartz.jobStore.type", "Quartz.Impl.AdoJobStore.JobStoreTX" },
    { "quartz.jobStore.dataSource", "default" },
    { "quartz.jobStore.tablePrefix", "QRTZ_" },
    { "quartz.dataSource.default.connectionString", "{YourConnectionString}" },
    { "quartz.dataSource.default.provider", "SqlServer" }
};

ISchedulerFactory schedulerFactory = new StdSchedulerFactory(props);

Remember to replace {YourConnectionString} with your actual database connection string.

Conclusion

Quartz.NET is a powerful, flexible, and feature-rich library for managing and scheduling background jobs in .NET applications. Whether you need to run simple recurring tasks or complex schedules that adhere to cron-like expressions, Quartz.NET has got you covered. It is a robust solution for enterprises with heavy job loads and it also caters to the needs of smaller applications. Moreover, with its ability to persist jobs, it ensures that your scheduled tasks survive application restarts, providing you with reliable and consistent performance. As a .NET developer, mastering Quartz.NET can prove to be a significant enhancement to your toolset. Happy coding!

Similar
May 30, 2024
Author: Erik Pourali
Imagine crafting a library app where users effortlessly find books by title, author, or genre. Traditional search methods drown you in code. But fear not! Dynamic Querying in C# saves the day. In our tale, crafting separate search methods for...
Jun 10, 2024
Author: Dayanand Thombare
LINQ (Language Integrated Query) has revolutionized the way we interact with data in C#. It offers a consistent, readable, and concise way to manipulate collections, databases, XML, and more. However, the beauty and ease of LINQ can sometimes mask performance...
one month ago
Author: iamprovidence
As you know, when you cruise through websites, your browser sends HTTP requests. However, it is also possible, to send HTTP requests manually from one server to another, which in C# can be done with the help of HttpClient. This...
Jan 7, 2024
Author: Sebastian Stupak
Few days ago I stopped myself while writing code. I wrote my LINQ filtering wrong. items.Where(x => x > 0).Any(); (Obviously, it’s a pseudo code) I realized my mistake immediately, changed the code, and went on with my day. Then...
Send message
Type
Email
Your name
*Message