How to decorate objects created by a custom factory using .NET Core DI?

Question

Given I have a factory class responsible for constructing instances of a certain service that has constructor parameters that can only be resolved at runtime, is there a way to leverage container-driven decoration?

Consider the following class which relies on a parameter that is only defined at runtime:

interface IFooService
{
    void DoServicyStuff();
}

class MyFooService : IFooService
{
    public MyFooService(string somePeskyRuntimeArgument)
    {
        this.peskyValue = somePeskyRuntimeArgument;
    }

    public void DoServicyStuff()
    {
        // do some stuff here with the peskyValue...
    }
}

Since the value can only be provided at runtime, we need to move away from the constructor injection and into a method-level parameter passing. This is commonly achieved using a factory implementation like this:

interface IFooServiceFactory
{
    IFooService CreateService(string heyItsNowAMethodLevelPeskyParameter);
}

class FooServiceFactory : IFooServiceFactory
{
    public IFooService CreateService(string heyItsNowAMethodLevelPeskyParameter)
    {
        return new MyFooService(heyItsNowAMethodLevelPeskyParameter);
    }
}

While this works fine if the intent is to just abstract away the construction of the service, it poses a challenge to decorate the IFooService instance.

For scenarios where no runtime parameter is involved, this can be easily achieved by tapping into the container to provide our service for us. The example below uses the Scrutor library to decorate the interface with a logging decorator implementation:

class FooServiceFactory : IFooServiceFactory
{
    private readonly IServiceProvider serviceProvider;

    public FooServiceFactory(IServiceProvider serviceProvider)
    {
        this.serviceProvider = serviceProvider
    }

    public IFooService CreateService(string heyItsNowAMethodLevelPeskyParameter)
    {
        return this.serviceProvider.GetRequiredInstance<IFooService>();
    }
}

...

services
    .AddTransient<IFooService, MyFooService>()
    .AddTransient<IFooServiceFactory, FooServiceFactory>()
    .Decorate<IFooService, LoggingFooService>();

But since MyFooService takes a primitive value as an argument, we cannot rely on GetRequiredService<T> to obtain the instance, as it will fail to find "a registration for string" when building the concrete class.

Similarly, changing the factory to rely on ActivatorUtilities's .CreateInstance or .CreateFactory methods will end up creating the objects while completely ignoring the container registrations, thus leaving us without any decorator.

I know I have at least 2 options to decorate the objects manually, namely:

1. Using the factory itself to manually create the decorator:

    public IFooService CreateService(string heyItsNowAMethodLevelPeskyParameter)
    {
        return new LoggingService(
             new MyFooService(heyItsNowAMethodLevelPeskyParameter));
    }

2. Using a factory decorator to inject a decorator after the instance is created:

abstract class FooServiceFactoryDecorator : IFooServiceFactory
{
    private readonly IFooServiceFactory fooServiceFactory;

    protected FooServiceFactory(IFooServiceFactory fooServiceFactory)
    {
        this.fooServiceFactory = fooServiceFactory;
    }

    public virtual IFooService CreateService(string heyItsNowAMethodLevelPeskyParameter)
    {
        return this.fooServiceFactory.CreateService(heyItsNowAMethodLevelPeskyParameter);
    }
}

class LoggingFooServiceFactory : FooServiceFactoryDecorator
{
    private readonly IFooServiceFactory fooServiceFactory;

    public FooServiceFactory(IFooServiceFactory fooServiceFactory)
    {
        this.fooServiceFactory = fooServiceFactory;
    }

    public override IFooService CreateService(string heyItsNowAMethodLevelPeskyParameter)
    {
        return new LoggingFooService(
            this.fooServiceFactory.CreateService(heyItsNowAMethodLevelPeskyParameter));
    }
}

...

services
    .AddTransient<IFooServiceFactory, FooServiceFactory>()
    .Decorate<IFooServiceFactory, LoggingFooServiceFactory>()

Neither of these allows me to directly use .Decorate on top of the service interface. The first option works but is heavily coupled (meaning I'd have to keep changing it if I want to add other decorators into the mix), while the second version is less coupled, but still forces me to writing one factory decorator per service decorator and thus leads into a much more complex solution.

Another pain point is dependencies on the decorators themselves (for example, ILogger<T> on the LoggingFooService), which I could potentially solve by leveraging ActivatorUtilities to create the decorators instead of newing them up manually.

I could also potentially generalize the "factory decorator" so that the decoration function is parameterized and thus the class can be reused, but it is still very convoluted and hard to maintain, while also not providing as good a syntax for consumers to add new decorators.

class DecoratedFooServiceFactory<TDecorator> : FooServiceFactoryDecorator
    where TDecorator : IFooService
{
    private readonly IFooServiceFactory fooServiceFactory;
    private readonly IServiceProvider serviceProvider;

    public FooServiceFactory(
        IFooServiceFactory fooServiceFactory, 
        IServiceProvider serviceProvider)
    {
        this.fooServiceFactory = fooServiceFactory;
        this.serviceProvider = serviceProvider;
    }

    public override IFooService CreateService(string heyItsNowAMethodLevelPeskyParameter)
    {
        return ActivatorUtilities.CreateInstance<TDecorator>(
            this.serviceProvider,
            this.fooServiceFactory.CreateService(heyItsNowAMethodLevelPeskyParameter));
    }
}

...

services
    .AddTransient<IFooServiceFactory, FooServiceFactory>()
    .Decorate<IFooServiceFactory, DecoratedFooServiceFactory<LoggingFooService>>()

And finally, if I ever want to move away from using a factory and want to change to using the service directly, this will cause a significant setup change where I'd then have to configure all the decorators again in the container directly instead of just removing the factory registration as one normally would do.

How can I use a factory like this, while still keeping the capability of configuring decorators at the container level using the simple Scrutor syntax?

Answer 1

Ok, a couple of disclaimers first:

1. I agree with Steven here in that this looks like an anti-pattern and you will probably be better off redesigning your code to not require run-time values on service construction.
2. I additionally want to caution against using scrutor-like Decorate. While much less confident in this than in the first point, I believe hiding logging in decorators is much less convenient in the long run than it seems at first. Or at least that's what I saw after about a year of trying them out.

That said, let's see what can be done.

First, let's put some constraints on where the value is coming from. Specifically, let's say we can have a service providing that value, that looks like this:

public interface IValueProvider
{
    string Get();
}

This actually allows us to have quite a bit of range. Implementation of that interface can:

• Get value from external API - once or periodically in the background. It can even call it every time Get is called, but this is a very bad idea, as it will make construction asynchronous.
• Get value that is stored in memory and allow some other service to update it. Say, expose a 'configuration' endpoint where a user can set a new value every once in a while.
• Calculate the value based on some algorithm of your choice.

Once you have this service, you can register it like this:

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IValueProvider, AwesomeValueProvider>();
    services.AddSingleton<IFooServiceFactory, FooServiceFactory>(); 
    services.AddTransient<IFooService>(sp => 
    {
        var factory = sp.GetRequiredService<IFooServiceFactory>();
        var valueProvider = sp.GetRequiredService<IValueProvider>();
        return factory.Create(valueProvider.Get());
    });
}

Hope this helps