Background tasks in .NET application

Paweł Majewski — Sat, 15 Feb 2025 19:41:26 +0000

Have you ever thought about doing something in the background to make your request shorter, but kept getting exceptions saying that the DbContext is disposed?

Here is the solution

https://www.hangfire.io/

Hangfire is an open-source framework for .NET that offers a straightforward approach to execute background tasks within your application. It enables the asynchronous execution of jobs and the ability to schedule them to run either at a designated time or on a recurring basis.

Firstly, install the following nuget packages

Hangfire

Hangfire.Core

Hangfire.SqlServer

Microsoft.Data.SqlClient

Then configuration, I assume you are at least junior .NET devleoper and know basic configuration in Program.cs

public interface IFakeEmailSenderBackgroundJob
{
    Task Send(string message, string title, string destinationEmail);
}

public class FakeEmailSenderBackgroundJob : IFakeEmailSenderBackgroundJob
{
    public async Task Send(string message, string title, string destinationEmail)
    {
        await File.WriteAllTextAsync($"mails.txt", $"{title}\t{message}\t{destinationEmail}\n");
    }
}

I’ve created simple fake email sender which is saving to file sent mails.

Create SQL Server database named “Hangfire-db”, and then add the following configuration

builder.Services.AddHangfire(x =>
            x.UseSqlServerStorage("Data Source=localhost;Initial Catalog=Hangfire-db;Integrated Security=true;TrustServerCertificate=true;"));
builder.Services.AddHangfireServer();
builder.Services.AddScoped();

in the app section

app.UseHangfireDashboard();

It’s web api project, so let’s create sample endpoint which will be using our FakeEmailSenderBackgroundJob

app.MapPost("/send-mail", (string message, string title, string destinationEmail) =>
{
    return BackgroundJob.Schedule(x =>
            x.Send(message, title, destinationEmail),
            DateTimeOffset.Now.AddMinutes(1)
        );
})
.WithName("SendMail")
.WithOpenApi();

As you can understand from this code, the endpoint will schedule the sending of the email to occur one minute after the endpoint is executed.

You can go to the /hangfire url in your application and then you should see Hangfire dashboard.

Send two requests and see what happens.

We can see that our job is scheduled correctly

Here are the details regarding our enqueued job.

Wait for a one minute.

The enqueued job has been executed, and as we can see, the result is correct. You can perform any desired operations inside your job class. As mentioned earlier regarding the disposed DbContext, you can inject your DbContext or repository directly into the job class.

How about failed tasks?

Let’s change the implementation of the FakeEmailSenderBackgroundJob to the following

public class FakeEmailSenderBackgroundJob : IFakeEmailSenderBackgroundJob
{
    public async Task Send(string message, string title, string destinationEmail)
    {
        throw new Exception();
        await File.WriteAllTextAsync($"mails.txt", $"{title}\t{message}\t{destinationEmail}\n");
    }
}

Let’s check our dashboard now.

Let’s wait a minute and check again.

Here’s an interesting observation: the Hangfire job failed to complete successfully and raised an exception, resulting in the job being requeued. Hangfire attempted to execute the job again, with the default behavior allowing for 10 attempts.

We can read number of attempts from information container with blue background

Scheduled Retry attempt 5 of 10: Exception of type 'System.Exception' was thrown.

As you can see, Hangfire attempted to execute its job 10 times before marking it as Failed.

Below you can see failed jobs tab

What else Hangfire can do?

Fire-and-Forget Jobs – This job is executed immediately after we execute our method associated with it. Background jobs are useful when you have a large task that consumes a lot of time, and it’s better to perform it asynchronously in the background.

Recurring Jobs – We can set up a cron expression to determine when tasks will be triggered. This is useful, for example, in a SaaS application where we need to check daily if a user has a valid subscription, and if not, suspend it. Similarly, in an application for lawyers, we might want to display court dates with deadlines 10 days in advance. In this case, it’s beneficial to have a background job executed daily that marks important cases. These are just a few examples; there are many other situations where a recurring job would be useful.

Delayed Jobs – We used it in our example. You can set a DateTimeOffset with a delay after which the task will be processed.

Continuations – We can execute a job when its parent job finishes. This is useful when we want to create a pipeline of task execution, especially when certain data needs to be created or prepared beforehand.

Hangfire has more paid options, but I don’t think they are necessary for standard purposes

The post Background tasks in .NET application first appeared on Software Developer's Tour.

How to test email sending service?

Paweł Majewski — Thu, 16 Jan 2025 06:30:00 +0000

Testing email templates, whether for existing features or new features, is a common task performed by testers during the testing process. There are many ways to manage sending emails on different environments:

– Development
– Testing
– Staging
– Production

You have to consider how your application should behave in all of these environments.

How companies deal with this problem?

First, and in my opinion, the worst case scenario occurs when the development team decides to add special logic to their EmailService, redirecting all emails to a specific email address, or when we allow sending emails to workers within our organization.

It shouldn’t pass code review.

This is the worst possible option for resolving this problem. This code cannot be tested to ensure that the application works correctly at the current time.

In this code, we have separated the logic for each environment, so there is no need for conditional statements (‘if’ statements) in the implementation types.

However, this version is also not as good as it could be.

Emails used for testing purposes should not be sent outside of the organization’s infrastructure.

So let’s go further.

What should we do to make this code look nice?

First of all, in the perfect case we have no ‘if’ statements in our code. It’s possible to do with several ways. I’ll talk here about 2 different ways to achieve this goal but without code.

What should it look like?

We should only change credentials stored in .NET web applications’ appsettings.json files. Different environment credentials should be stored in different files. In the best-case scenario, only the developer’s credentials should be stored directly, while all other credentials should be stored in either dotnet secrets or Azure Key Vault

1. Create Fake SMTP Server

It’s a good option when we want to keep everything within our private infrastructure, which is very important for large organizations.

For development purposes, we have credentials for a Fake SMTP Server, and the code itself does not change.

How should work Fake SMTP Server?

The Fake SMTP Server should receive the same data as a real SMTP Server as input, but instead of sending it, it should save the data to a database. Additionally, it should provide a public interface (for example, a web frontend) to search for emails.

2. Use Fake SMTP Server as a Service

INFORMATION

I would like to emphasize that I don't have a partnership with any company and the indication of a specific service is only because I had the opportunity to use it in commercial project.

Mailtrap is an easy-to-use platform for sending real and test emails from our applications. I’ve only tested the Email Testing feature, so I’ll mainly focus on it.

Mailtrap offers a clear web interface to read all sent emails.

What makes this product stand out?

Testers can view all emails sent from the application. When they analyze test cases that have been tested by others, they can also verify emails.

The post How to test email sending service? first appeared on Software Developer's Tour.

Tips & Tricks - Software Developer's Tour