What is the equivalent of Autofac's aggregate services in Microsoft's dependency injection framework

Question

There is a C# asp.net core project that I'm seeing the number of injected interfaces in some constructors keeps growing. It's expected it may exceed 30 or 40 interfaces in some cases.

A bit of googling got me to Autofac's Aggregate Services. My question is that whether there's an equivalent in asp.net core's DI framework to avoid passing many interfaces to constructors?

Answer 1

As Evk mentioned in the comments, the dependency injection container at Microsoft.Extensions.DependencyInjection is deliberately a very simple one. If you are in need of more powerful features, you should consider switching to a full fletched DI container instead. ASP.NET Core is built to allow swapping out the DI container, and it’s actually not too difficult to do so. Autofac has a guide on how to do it.

That being said, Autofac’s aggregate services are not that much magic. Sure, you could build something like Autofac did and use Castle DynamicProxy to automatically implement the aggregate service. But you could also simply create such an aggregate service by hand:

public class MyAggregateService
{
    public IFirstService FirstService { get; }
    public ISecondService SecondService { get; }
    public IThirdService ThirdService { get; }
    public IFourthService FourthService { get; }

    public MyAggregateService (IFirstService first, ISecondService second, IThirdService third, IFourthService fourth)
    {
        FirstService = first;
        SecondService = second;
        ThirdService = third;
        FourthService = fourth;
    }
}

// then register that in the container
services.AddTransient<MyAggregateService>();

// and depend on it in the controller
public MyController (MyAggregateService aggregateService)
{ … }

Sure, you have to write a bit more, but it’s actually not that much more. And if you can do without those advanced features that Autofac offers, this is actually pretty simple and quickly done.