IOC with multiple databases that use same interface (StructureMap or any other DI Framework)

We've been experimenting with StructureMap, and I'm having trouble grasping how to handle situations where a single interface has multiple implementations. The code below shows an example where we have two databases that are both accessible from a single service.

public class SomeController : Controller
{
    private ISomeService _service;
    private IClientRepository _repository;
    protected IContext _masterContext;
    protected IContext _clientContext;

    public SomeController(ISomeService service, ISomeRepository repository
        , IContext masterCon, IContext clientCon)
    {
        _service = service;
        _repository = repository;
        _masterContext = masterCon;
        _clientContext = clientCon;
    }
}

public class SomeService : ISomeService
{
    private IContext _masterContext;
    private IContext _clientContext;

    public SomeService(IContext masterContext, IContext clientContext)
    {
        masterContext = _masterContext;
        clientContext = _clientContext;
    }
}

public class ClientRepository : IClientRepository
{
    private IContext _clientContext;

    public ClientRepository(IContext clientContext)
    {
        _clientContext = clientContext;
    }
}

public class MasterContext : IContext
{
    public MasterContext(String connString)
    //<snip, snip> implement 3rd party data context
}

public class ClientContext : IContext
{
    public ClientContext(String connString)
    //<snip, snip> implement 3rd party data context
}

StructureMap worked GREAT when we had a single context (database), but how do I tell it how to resolve the 2nd? Note: in most situations we wouldn't have a service handling 2 databases (but may have a controller handling 2 connec开发者_如何学运维tions, i.e. 2 repositories accessing 2 different databases), but it still doesn't seem to make it easier.

I'm half ready to just give up on using an IoC framework and go back to poor man's DI.

Is it not possible to have an IClientContext and an IMasterContext, possibly inheriting from IContext. My feeling is that the code would be doing one of two very different things depending on whether you were talking to the 'Master' or 'Client' database.

In Unity you can have named registrations, allowing you to effectively register more than a class for a given interface. So you could do (typing by heart, check the actual Unity documentation if interested):

container.RegisterType<IContext, MasterContext>("Master");
container.RegisterType<IContext, ClientContext>("Client");

and then the constructor for SomeService would be:

public SomeService(
    [Dependency("Master")]IContext masterContext, 
    [Dependency("Client")]IContext clientContext)
{
    //...
}

The drawback is that in this way your service class is no longer independent of the DI framework used, but depending on the project that may be ok.

This can be a little difficult if you're relying on StructureMap to resolve the dependencies automatically. The first solution (and what I'd err towards) is to make use of marker interfaces like Richard mentions in his answer then just register them. You can then explicitly specify whether you want your client or master context there.

The second way is to make use of named registrations, then specify the constructor params explicitly.

ForRequestedType<IContext>().AddInstances(
    i => {
        i.OfConcreteType<ClientContext>().WithName("Client");
        i.OfConcreteType<MasterContext>().WithName("Master");
    });
ForRequestedType<SomeController>().TheDefault.Is.ConstructedBy(
    i => new SomeController(i.GetInstance<ISomeService>(), 
        i.GetInstance<IClientRepository>(), 
        i.GetInstance<IContext>("Master"), 
        i.GetInstance<IContext>("Client")));

Not particularly nice but it does the job and ultimately if it's only in one or two places it might be OK.

If you want to resolve differently on namespace / assembly you could try something like this:-

ForRequestedType<IContext>().AddInstances(
    i => {
         i.OfConcreteType<ClientContext>().WithName("Client");
         i.OfConcreteType<MasterContext>().WithName("Master");
     }).TheDefault.Is.Conditional(c => {
         c.If(con => con.ParentType.Namespace.EndsWith("Client"))
          .ThenIt.Is.TheInstanceNamed("Client");
         c.If(con => con.ParentType.Namespace.EndsWith("Master"))
          .ThenIt.Is.TheInstanceNamed("Master");
         c.TheDefault.Is.OfConcreteType<ClientContext>();
     });

Where the predicate on ParentType can refer to Assembly (or whatever you want really)

In case someone stumble in this problem, you can achieve it using factory pattern.

Service extension

public static class ServiceFactoryExtensions
{
    public static void RegisterSqlFactory(this IServiceCollection serviceCollection)
    {
        serviceCollection.Configure<MsSqlOption>(option => option.ConnectionString = "Mssql connection string");
        serviceCollection.Configure<MySqlOption>(option => option.ConnectionString = "Mysql connection string");
        serviceCollection.Configure<PostgreOption>(option => option.ConnectionString = "Postgrel connection string");

        serviceCollection.AddSingleton<ISqlDatabase, MsSql>();
        serviceCollection.AddSingleton<ISqlDatabase, Postgre>();
        serviceCollection.AddSingleton<ISqlDatabase, MySql>();
        serviceCollection.AddSingleton<Func<IEnumerable<ISqlDatabase>>>(serviceProvider => () => serviceProvider.GetService<IEnumerable<ISqlDatabase>>());
        serviceCollection.AddSingleton<ISqlDatabaseFactory, SqlDatabaseFactory>();
    }
}

Factory class

public class SqlDatabaseFactory : ISqlDatabaseFactory
{
    private readonly Func<IEnumerable<ISqlDatabase>> _factory;

    public SqlDatabaseFactory(Func<IEnumerable<ISqlDatabase>> factory)
    {
        _factory = factory;
    }

    public ISqlDatabase CreateSql(SqlType sqlType)
    {
        var databases = _factory();
        var sqlDatabase = databases.FirstOrDefault(x => x.DatabaseName == sqlType);

        if (sqlDatabase == null)
            throw new NotImplementedException($"Sql type {nameof(sqlType)} is not implemented");

        return sqlDatabase;
    }
}

Sql classes

public class MsSql : ISqlDatabase
{
    public SqlType DatabaseName => SqlType.MsSql;

    public string Connecionstring { get; private set; }

    public MsSql(IOptions<MsSqlOption> option)
    {
        Connecionstring = option.Value.ConnectionString;
    }
}

public class Postgre : ISqlDatabase
{
    public SqlType DatabaseName => SqlType.Postgre;

    public string Connecionstring { get; private set; }

    public Postgre(IOptions<PostgreOption> option)
    {
        Connecionstring = option.Value.ConnectionString;
    }        
}

public class MySql : ISqlDatabase
{
    public SqlType DatabaseName => SqlType.MySql;

    public string Connecionstring { get; private set; }

    public MySql(IOptions<MySqlOption> option)
    {
        Connecionstring = option.Value.ConnectionString;
    }
}

public interface ISqlDatabase
{
    string Connecionstring { get; }

    SqlType DatabaseName { get; }
}

public enum SqlType
{
    MsSql,
    Postgre,
    MySql
}

Usage

internal class Program
{
    static void Main(string[] args)
    {
        var serviceCollection = new ServiceCollection();
        serviceCollection.RegisterSqlFactory();

        var provider = serviceCollection.BuildServiceProvider();

        var sqlFactory = provider.GetService<ISqlDatabaseFactory>();

        var mySql = sqlFactory.CreateSql(SqlType.MySql);
        var msSql = sqlFactory.CreateSql(SqlType.MsSql);
        var postgre = sqlFactory.CreateSql(SqlType.Postgre);

        Console.WriteLine($"Database Type : {mySql.DatabaseName}, Connectionstring: {mySql.Connecionstring}");
        Console.WriteLine($"Database Type : {msSql.DatabaseName}, Connectionstring: {msSql.Connecionstring}");
        Console.WriteLine($"Database Type : {postgre.DatabaseName}, Connectionstring: {postgre.Connecionstring}");

        Console.ReadKey();
    }
}

Output

Dependencies:

• .Net Core 3.1
• Microsoft.Extensions.DependencyInjection;
• Microsoft.Extensions.Options;
• System
• System.Collections.Generic
• System.Linq;