You can centralize the injection of common services like IValidator, ISecurity, and ILogger into your command/query handlers by using a "static service locator" with a delegate-based approach. This avoids modifying each handler's constructor.

Implementation:

public static class AppServices
{
    private static Func<IServiceProvider>? _providerAccessor;

    public static void Init(Func<IServiceProvider> providerAccessor)
    {
        _providerAccessor = providerAccessor ?? throw new ArgumentNullException(nameof(providerAccessor));
    }

    private static IServiceProvider CurrentProvider =>
        _providerAccessor?.Invoke() ?? throw new InvalidOperationException("ServiceLocator not initialized");

    public static IValidator Validator => CurrentProvider.GetRequiredService<IValidator>();
    public static ISecurity Security => CurrentProvider.GetRequiredService<ISecurity>();
    public static ILogger Logger => CurrentProvider.GetRequiredService<ILogger>();
}

Setup with IHttpContextAccessor:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpContextAccessor();
...

var app = builder.Build();

// Initialize the service locator once with a delegate
var accessor = app.Services.GetRequiredService<IHttpContextAccessor>();
AppServices.Init(() => accessor.HttpContext?.RequestServices ?? app.Services); 
// Note: fallback to root provider ensures it works in background services or outside an HTTP request

app.MapControllers();
app.Run();

You can use AppServices in a handler like this:

public class MyCommandHandler
{
    public void Handle(MyCommand command)
    {
        // Use services directly inline
        if (!AppServices.Validator.Validate(command.Input))
        {
            AppServices.Logger.Log("Validation failed");
            throw new InvalidOperationException("Invalid input");
        }

        var user = AppServices.Security.GetCurrentUser();
        AppServices.Logger.Log($"Executing command for user {user.Name}");

        // Command logic here...
    }
}

The above approach will work, but it is not considered best practice. It hides dependencies and makes testing harder.

The recommended approach is to use constructor injection for your services or use patterns like decorator/middleware to provide cross-cutting concerns, as some of the other answers suggest.

You cannot seamlessly inject new services into existing constructors without modifying them. However, you can work around this limitation using several established patterns, depending on how strict you want to be about avoiding boilerplate code.

Aggregate dependency (“CommonServices”): wrap IValidator, ISecurity, ILogger in a single service:

public class CommonServices
{
    public IValidator Validator { get; }
    public ISecurity Security { get; }
    public ILogger Logger { get; }

    public CommonServices(IValidator validator, ISecurity security, ILogger logger)
    {
        Validator = validator;
        Security = security;
        Logger = logger;
    }
}

You could use any of the following approaches the solve the problem:

Constructor Injection

Use a DI framework that supports marking the constructor that the IoC container should use with an attribute, and add said attribute to the source-generated constructor.

The generated constructor should also invoke the pre-existing constructor using the this keyword. If there are already multiple pre-existing constructors in your handlers, then you need to come up with some method to resolve the situation (e.g. always invoke the constructor with the largest number of parameters).

You would also need to make sure that none of your pre-existing constructors already contain the attribute that informs the DI framework which constructor to use.

Property Injection

Use a DI framework that supports property injection and source generate properties for all the shared services.

Service Locator

Define extension methods for your command/query handler interfaces and have those internally acquire the shared services using the service locator pattern.

I'm going to say this upfront. I don't like this pattern. IMHO you should just write the constructors.

But here's a way to inject known properties using a factory method. Use ActivatorUtilities.CreateInstance to do the usual parameter injection. Then manually assign the base properties;

public abstract class ServiceBase<T>
    where T:ServiceBase<T>
{
    public ILogger<T> Logger { get; set; }
}

public void Register<T>(IServiceCollection services)
    where T : ServiceBase<T>
{
    services.AddScoped<T>(sp =>
    {
        var instance = ActivatorUtilities.CreateInstance<T>(sp);
        instance.Logger = sp.GetRequiredService<ILogger<T>>();
        return instance;
    });
}