Dependency Injection Support?

Has any thought been given to DI support in Obvs?

It tends to be very hard to go back and bake in support for DI into frameworks later. Is it worth introducing low level support for dependency resolution now while it’s early goings to avoid the pain later? You could either introduce a proprietary IDependencyResolver interface as part of Obvs core or have Obvs take a dependency on the Microsoft.Framework.DependencyInjection package which would come with the added benefit of everyone implementing direct support for that for all the popular containers (e.g. AutoFac, Ninject, Unity, etc.) since it’s a building block of all the new frameworks in .NET vNext. The downside of taking the dependency on that is that it’s still beta and that would mean the version of Obvs that takes that dependency would need to be a beta version itself until that dependency RTMd.

[megakid]

I think @MovGP0’s final post sums up perfectly the accepted approach to Obvs + DI. Closing this.

[MovGP0]

it is actually quite easy. just create a factory method that sets up the service bus using the fluid interface. then you can inject the factory method. Create additional factory methods for alternative configurations and mocks as needed.

Dependency Injection

Factory Method:

public static class MyFactory
{
    public static IServiceBus CreateServiceBus() 
    {
        return ServiceBus.Configure()
            .WithActiveMQEndpoints<ITestMessage>()
            .Named("Obvs.TestService")
            .UsingQueueFor<ICommand>()
            .ConnectToBroker("tcp://localhost:61616")
            .SerializedAsJson()
            .AsClientAndServer()
            .Create();
    }
}

using DryIoc:

var container = new Container();
container.Register<IServiceBus>(made: Made.Of(() => MyFactory.CreateServiceBus()), Reuse.Transient);
container.RegisterDelegate<Action<IServiceBus>>(r => () => r.Resolve<IServiceBus>(), Reuse.Transient);

Mocking

using Moq:

public static class MyMockFactory
{
    public static IServiceBus CreateServiceBus()
    {
        var mock = new Mock<IServiceBus>();
        mock.Setup(...);
        // mock.Verify(...);
        return mock.Object;
    }
}

using DryIoc:

var container = new Container();
container.Register<IServiceBus>(made: Made.Of(() => MyMockFactory.CreateServiceBus()), Reuse.Transient);
container.RegisterDelegate<Action<IServiceBus>>(r => () => r.Resolve<IServiceBus>(), Reuse.Transient);

Usage

Injecting bus:

public sealed class MyClass
{
    private IServiceBus ServiceBus { get; }

    public MyClass(IServiceBus> serviceBus)
    {
        ServiceBus  = serviceBus;
    }

    public void UseServiceBus()
    {
        var serviceBus = ServiceBus;
        // ...
    }

    // TODO: Dispose everything
}

Creating bus when needed:

public sealed class MyClass
{
    private Action<IServiceBus> ServiceBusFactory { get; }

    public MyClass(Action<IServiceBus> serviceBusFactory)
    {
        ServiceBusFactory  = serviceBusFactory;
    }

    public void UseServiceBus()
    {
        var serviceBus = ServiceBusFactory();
        // ...
    }

    // TODO: Dispose everything
}