Simple Injector dynamic context-based injection at runtime between two registrations

Question

I have a Mediator application using Simple Injector for command handler registration, and injection and handlers is all setup and working perfectly.

class DoWashingCommandHandler : IRequestHandler<DoWashingCommand,object>
{
    IBus bus;

    public DoWashingCommandHandler(IBus bus) { this.bus = bus; }

    Task<object> Handle(DoWashingCommand command)
    {
        this.bus.Send(new OtheCommand());
    }
}

I have a need for 2 registrations of a IBus implementations.

The first can be of any lifetime, the second has a background thread so i initially thought it would need to be a singleton but on review i believe it could also be of any lifetime and just have a static worker thread class within it (this would be important for scope):

// register as non-singleton to allow scope usage
// keep static worker thread as if it were Singleton
class DispatchOnBackgroundThread : IBus
{
    static Worker = new Worker();

    public Task<object> Send(object command)
    {
         Worker.Post(command);
    }

    public void Start(Container container, CancelationToken stoppingToken)
    {
         Worker.Start(container,stoppingToken);
    }

    class Worker
    {
         public void Post(object command) { /* snip */ }

         public void Start(Container container, CancelationToken stoppingToken)
         { /* snip */ }

         public void Thread()
         {
             /* loop */
             var item = ReadFromQueue();

             // get command handler type
             // get command handler instance from container
             // if instantiated instance has IBus dependency in this
             // section then it must have used DispatchInThread as the
             // concrete implementation for IBus (including if the handler
             // calls container.GetInstance<IBus>()

             handler.Handle(item.Request, cancellationToken);
         }

         // anything outside this Thread should use
         // DispatchOnBackgroundThread for IBus
    }
}

Then the registrations would be as follows (not sure how to avoid the double registration issue of IBus):

// i need to be able to register two types
container.Register<IBus,DispatchOnBackgroundThread>();
container.Register<IBus,DispatchInThread>();

// this would return any IBus references with DispatchOnBackgroundThread
var handler = this.container.GetInstance(requestHandlerType);

using(SomeSope.BeingScope(container))
{
    // this would return any IBus references with DispatchInThread
    var handler = this.container.GetInstance(requestHandlerType);
    // and if handler or other code referenced container and called
    // GetInstance, and IBus dependencies would be returned as 
    // DispatchInThread whilst in this scope
}

// this would return any IBus references with DispatchOnBackgroundThread
var other = this.container.GetInstance(requestHandlerType);

I think and in summary, this is a mix of Context-based injection and custom scope.

How can I achieve the above or is this a terrible code smell?

To give further context if required I need the above switchable resolved types in order to implement the solution of another question https://stackoverflow.com/a/61782405/915839

DI code is removed in above link, but i am very much using SimpleInjector in the actual implementation

why not have DispatchInThread as a decorator of DispatchOnBackgroundThread? — qujck
If using a decorator would need to find a way to redirect between the two implementations. The DispatchOnBackgroundThread registration would need to be singleton. Unless it were a class with a static worker class within it. So we have all implementations and decorator as scoped lifetime. I get the IBus (decorator) and cast it to known additional interface that allows setting of a property to route between the two implementations. Since it's scoped, all calls beneath would get same instance (IBus decorator). Ideas are bubbling now thanks, do you see issues with above? — morleyc
Possibly setting which dispatcher implementation to use using CallContext.LogicalSetData so the decorator can decide... would need to look into this more (was digging into how Simpleinjector knows the scope context of an async call) — morleyc
My view is you should have full control of this behaviour, rather than deferring to the library you are using. You could also have a DispatchRouter : IBus that references both dispatcher implementations and makes the decision as to which one to call. Lots of options. — qujck

Steven Steven · Accepted Answer · 2020-05-14T07:36:45

I'm not sure I fully understand your use case, and what it is that leads to this, but what you can do is create a wrapper IBus implementation that forwards the call to the correct bus, while changing the forwarded bus implementation while running on a background thread.

This wrapper might look as follows:

class SwitchableBus : IBus
{
    private readonly DispatchInCallingThread defaultBus;
    private readonly DispatchOnBackgroundThread backgroundBus;

    public SwitchableBus(
        DispatchInCallingThread defaultBus, DispatchOnBackgroundThread backgroundBus)
    {
        this.defaultBus = defaultBus;
        this.backgroundBus = backgroundBus;
        this.Bus = defaultBus;
    }

    public IBus Bus { get; private set; }

    public void SwitchToBackgroundBus() => this.Bus = this.backgroundBus;

    public Task<object> Send(object command) => this.Bus.Send(command);
}

With this wrapper, you can use the following registrations:

container.Register<IBus, SwitchableBus>(Lifestyle.Scoped);
container.Register<SwitchableBus>(Lifestyle.Scoped);
container.Register<DispatchInCallingThread>(Lifestyle.Scoped);
container.Register<DispatchOnBackgroundThread>(Lifestyle.Scoped);

This allows you to have DispatchInCallingThread used in the graph as follows:

using(SomeSope.BeingScope(container))
{
    var handler = this.container.GetInstance(requestHandlerType);
    handler.Handle(request);
}

In other words, by default the DispatchInCallingThread is used.

And DispatchOnBackgroundThread can be used by the graph as follows:

using(SomeSope.BeingScope(container))
{
    container.GetInstance<SwitchableBus>().SwitchToBackgroundBus();

    var handler = this.container.GetInstance(requestHandlerType);
    handler.Handle(request);
}

Concequence of this is, however, that you should always resolve within an active Scope. But that would be a good idea anyway, because it is likely there will be Scoped dependencies in a graph anyway. Simple Injector does not allow resolving a graph with Scoped dependencies outside the context of an active scope.

Simple Injector dynamic context-based injection at runtime between two registrations

1 Answers