How does Nservicebus handle nested containers on structuremap?

Question

TL;DR; some property is not being injected into a service when it should. How does Nservicebus handle nested containers on structuremap?

Hey guys new here. I'm currently upgrading our project to NSB6. I have a couple of question on dependency injection with Structuremap.

We have some services that use to use ISendOnlyBus, which we call from inside a handler. For test purposes(I just want to get the handler working) I changed those to IMessageHandlerContext, and at the beginning of the handler I'm injecting the context to the container. It works as expected, IMessageHandlerContext is resolved on these services and I'm able to use it.

public class MyMessageHandler : IHandleMessage<IMyMessage>
{
    private IContainer _container;
    private ISomeService _someService;
    public MyMessageHandler (IContainer container, ISomeService someService)
    {
        _container = container;
        _someService = someService;
    }

    public async Task Handle(IMyMessage message, IMessageHandlerContext context)
    {
        _container.Inject(typeof(IMessageHandlerContext), context);
        _someService.DoSomething();
    }
}

public class SomeService : ISomeService
{
    private IMessageHandlerContext _context;
    public SomeService(IMessageHandlerContext context)
    {
        _context = context;
    }
    public void DoSomething()
    {
        _context.Send<ISomeMessage>(x => {
            //... init message
        });
    }
}

Now the issue is we have an Nhibernate custom IPostUpdateEventListener over an entity that sends nservicebus messages. On version 5 it had an ISendOnlyEndpoint that it used for sending, same as the other services, but this time the context is not being resolved by Structuremap. I'm wondering how's and if nservicebus manages nested containers inside message handlers. I cannot seem to find any documentation for it.

Answer 1

I'm guessing the suggested refactor of this would be

public class MyMessageHandler : IHandleMessage<IMyMessage>
{

    public async Task Handle(IMyMessage message, IMessageHandlerContext context)
    {
        context.Resolve<ISomeService>().DoSomething(context);
    }
}

public class SomeService : ISomeService
{
    public void DoSomething(IMessageHandlerContext context)
    {
        context.Send<ISomeMessage>(x => {
            //... init message
        });
    }
}

context.Resolve would be be an extension you write to access the container instance in the context instance.

However if you wanted to just send messages from outside a message handler you can inject IEndpointInstance or IMessageSession which is returned when you start the bus. I think they suggest to only send messages from message handlers using the context - but sometimes that just doesn't work.

Answer 2

Child containers within StructureMap do not support some of the features required by NServiceBus containers. Policies are used to configure the injection, and policies are not supported in child containers.

Policies are only applied to root container in StructureMap

Here is an issue in the NServiceBus.StructureMap repo to track it.