What is Hangfire and How it Works?

Background jobs

There are several types of background jobs that you can perform using Hangfire:

Fire-and-forget

These are jobs that are executed once and then forgotten. They are used for tasks that need to be performed in the background, but the result doesn't need to be returned to the application immediately.

Delayed jobs

These are jobs that are scheduled to run at a specific time in the future. You can use them to schedule tasks that need to be performed at a specific time, such as sending a reminder email to a user.

Recurring jobs

These are jobs that are scheduled to run repeatedly at a specified interval. You can use them to automate tasks that need to be performed on a regular basis, such as generating reports or performing database cleanup.

Continuations

These are jobs that are executed after a previous job has been completed. You can use them to create a sequence of jobs that need to be performed in a specific order.

Batch jobs

These are jobs that are grouped together and executed as a single unit. You can use them to perform a set of related tasks that need to be executed together.

Executing jobs

1. Fire and Forget jobs

• Enqueueing a job means that you are adding it to a queue of jobs that are waiting to be processed. When a job is enqueued, it is not executed immediately but instead is stored in persistent storage (usually a database) until a worker process is available to process it.
• In order to test, you can create an endpoint:

          [HttpGet("FireAndForgetJob")]
          public ActionResult CreateFireAndForgetJob()
          {
              BackgroundJob.Enqueue(() => Console.WriteLine("hello testing hangfire FireAndForgetJob"));
              return Ok();
          }

2. Delayed jobs

• When you schedule a job using the Schedule method, you are specifying a delay or a specific date and time for the job to run. The job is added to persistent storage (usually a database) and is executed automatically when the specified time is reached.
• Let's create another endpoint:

         [HttpGet("DelayedJob")]
          public ActionResult DelayedJob()
          {
              BackgroundJob.Schedule(() => Console.WriteLine("hello testing hangfire DelayedJob"), TimeSpan.FromSeconds(60));
              return Ok();
          }

3. Continuation jobs

• In other words, when you create a continuation job, you're saying, "Once this other job is done, then run this one." This can be useful for creating complex workflows where certain jobs need to run in a specific order or where one job needs to finish before another can begin.
• To create a continuation job in Hangfire, you first need to create the parent job using one of the library's scheduling methods, such as Enqueue or Schedule. Then, you can use the Continuations API to create the dependent job that will run after the parent job is finished.
• Let's create another endpoint:

          [HttpGet("ContinuationJob")]
          public ActionResult ContinuationJob()
          {
              var jobId = BackgroundJob.Enqueue(() => Console.WriteLine("hello testing hangfire ContinuationJob"));
              BackgroundJob.ContinueJobWith(jobId,() => Console.WriteLine("Continuation!"));
              return Ok();
          }

4. Reccuring jobs

• A recurring job is a task that needs to be performed repeatedly on a schedule. For example, sending a weekly email newsletter or performing a daily database backup.
• Using Hangfire's AddOrUpdate method, you can define the schedule for a recurring job using a cron expression, which is a string that specifies the frequency and timing of the job.
• Here's how the AddOrUpdate method works: you first need to specify a unique identifier for the job, which will be used to identify it later. Then, you provide a lambda expression that defines the method to be executed as the job. Finally, you specify the cron expression that defines the job's schedule.

Let's create another endpoint:

        [HttpGet("RecurringJob")]
        public IActionResult recurringJob()
        {
            RecurringJob.AddOrUpdate("myrecurringjob", () => Console.WriteLine("hello testing hangfire RecurringJob"), Cron.Minutely());
            //sendmail();
            return Ok("recurring job is done");
        }

5. Batch jobs

• Batches allow you to create a bunch of background jobs atomically. This means that if there was an exception during the creation of background jobs, none of them will be processed.

          [HttpGet("BatchJob")]
          public IActionResult BatchJob()
          {
              var batchId = BatchJob.StartNew(x =>
              {
                  x.Enqueue(() => Console.WriteLine("BatchJob Job 1"));
                  x.Enqueue(() => Console.WriteLine("BatchJob Job 2"));
              });
              return Ok("BatchJob is done");
          }