Is it a good practice to create middleware for making every HTTP request transactional in ASP.NET Core?

I’m considering implementing a middleware in my ASP.NET Core application that will wrap every HTTP request in a database transaction. The idea is to ensure that all operations within a request are atomic.

Is it a good practice in real world applications?

Here is my implementation:

public class TransactionMiddleware
{
    private readonly RequestDelegate _next;

    public TransactionMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context, DbContext dbContext)
    {
        // Start a new transaction
        using (var transaction = await dbContext.Database.BeginTransactionAsync())
        {
            try
            {
                // Call the next middleware in the pipeline
                await _next(context);

                // Commit the transaction if no exception occurs
                await transaction.CommitAsync();
            }
            catch
            {
                // Rollback the transaction if an exception occurs
                await transaction.RollbackAsync();
                throw;
            }
        }
    }
}

and program.cs part:

    // Use the transaction middleware
    app.UseMiddleware<TransactionMiddleware>();