How do I centralize shared logic in .NET CQRS handlers using MediatR to avoid code duplication?

I'm developing a .NET API that implements the CQRS pattern with MediatR and Entity Framework, and I'm running into duplication issues across handlers.

For example, to create a Customer, the handler looks like this:

CSHARPCopied
public class CreateCustomerHandler(DbContext context): IRequestHandler<CreateCustomerCommand, Customer>
{
    public async Task<Customer> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
    {
        var c = new Customer()
        {
            Name = request.Name
        };
        await context.Customer.AddAsync(c, cancellationToken);
        await context.SaveChangesAsync(cancellationToken);
        return c;
    }
}

Now, if we need to create a Customer with an associated User (and potentially add more Users later), the handler becomes:

CSHARPCopied
public class CreateCustomerHandler(DbContext context): IRequestHandler<CreateCustomerCommand, Customer>
{
    public async Task<Customer> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
    {
        var c = new Customer()
        {
            Name = request.Name
        };
        await context.Customer.AddAsync(c, cancellationToken);

        var u = new User()
        {
            CustomerId = c.Guid
        };
        await context.User.AddAsync(u, cancellationToken);

        await context.SaveChangesAsync(cancellationToken);
        return c;
    }
}

Additionally, adding a User to an existing Customer involves another handler:

CSHARPCopied
public class CreatUserHandler(DbContext context): IRequestHandler<CreateUserCommand, User>
{
    public async Task<User> Handle(CreateUserCommand request, CancellationToken cancellationToken)
    {
        var u = new User()
        {
            CustomerId = request.CustomerId
        };
        await context.User.AddAsync(u, cancellationToken);

        await context.SaveChangesAsync(cancellationToken);
        return u;
    }
}

The issue is that if the user creation logic changes, I have to update it in multiple places, which isn’t DRY.

I’ve tried several approaches:

1. Using MediatR Events
I published a CustomerCreatedNotification from within the CreateCustomerHandler:

CSHARPCopied
public class CreateCustomerHandler(DbContext context): IRequestHandler<CreateCustomerCommand, Customer>
{
    public async Task<Customer> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
    {
        var c = new Customer()
        {
            Name = request.Name
        };
        await context.Customer.AddAsync(c, cancellationToken);

        await _mediator.Publish(
            new CustomerCreatedNotification{ 
                Customer = c
            }
        );

        await context.SaveChangesAsync(cancellationToken);
        return c;
    }
}

This approach fails to ensure that creating both Customer and User is transactional.

2. Executing ICommands from inside other handlers
Here, the CreateCustomerHandler sends a CreateUserCommand:

CSHARPCopied
public class CreateCustomerHandler(DbContext context, IMediator mediator): IRequestHandler<CreateCustomerCommand, Customer>
{
    public async Task<Customer> Handle(CreateCustomerCommand request, CancellationToken cancellationToken)
    {
        var c = new Customer()
        {
            Name = request.Name
        };
        
        await context.Customer.AddAsync(c, cancellationToken);

        var createUserCommand = new CreateUserCommand()
        {
            AccountId = c.Guid
        };
        await mediator.Send(createUserCommand, cancellationToken);

        await context.SaveChangesAsync(cancellationToken);

        return c;
    }
}

This removes duplicate user creation code but is considered a code smell since commands are no longer self-contained.

3. Executing multiple ICommands in the controller action
This approach triggers both commands from the controller:

CSHARPCopied
    [HttpPost]
    public async Task<IActionResult> CreateCustomer(CreateCustomerRequest request, CancellationToken cancellationToken)
    {
        var command = request.Adapt<CreateCustomerCommand>();
        
        var customer = await mediator.Send(command, cancellationToken);
        
        var createUserCommand = new CreateUserCommand
        {
            AccountId = customer.Guid,
        };
        
        var user = await mediator.Send(createUserCommand, cancellationToken);

        var response = customer.Adapt<CreateCustomerResponse>();
        
        return Ok(response);
    }

This method mixes business logic into the controller and also lacks transactional integrity.

Is there a better approach to centralize shared logic and maintain transactional consistency across handlers, or is this duplication an inherent trade-off when using CQRS with MediatR?