Structuremap configuration for choosing particular type by varying different constructor type

Question

I am trying to choose different logger for different type of services. In my following class scenario, i want to use DbAppender for a service which need to log to db and FileAppender for a service which need to log to file.

Here is the class design i have:

public interface ILogger
{

}
public class Logger : ILogger
{
    private readonly IAppender _appender;

    public Logger(IAppender appender)
    {
        _appender = appender;
    }
}
public interface IAppender
{

}

public interface IRepository
{

}
public class DbAppender : IAppender
{
    private IRepository _repository;

    public DbAppender(IRepository repository)
    {
        _repository = repository;
    }
}

public class FileAppender : IAppender
{

}

public interface IHelloDbService
{

}
public class HelloServiceWithDbLog : IHelloDbService
{
    private readonly ILogger _logger;
    public HelloServiceWithDbLog(ILogger logger)
    {
        _logger = logger;
    }
}

public interface IHelloFileService
{

}
public class HelloServiceWithFileLog : IHelloFileService
{
    private readonly ILogger _logger;
    public HelloServiceWithFileLog(ILogger logger)
    {
        _logger = logger;
    }
}

Now i have to configure structureMap dependency injection accordingly so that for DbService it has to choose logger with db capability and for FileService, it has to choose logger with file capability.

    // this has to configure to choose Logger with FileAppender.
    x.For<IHelloFileService>().Use<HelloServiceWithFileLog>();
                .Ctor<ILogger>().Is<Logger>();

    // this has to configure to choose logger passing DbAppender.
             x.For<IHelloDbService>().Use<HelloServiceWithDbLog>();
                .Ctor<ILogger>().Is<Logger>();

score 0 · Answer 1 · edited May 23 '17 at 12:27

I'm no structure map expert, and there may be a way to use named instances in structure map but I think you could just create subclasses for the type of logging that you want to do and inject those subclasses into the constructors:

public class DbLogger : Logger
{
    public DbLogger (DbAppender appender) : base(appender)
    {        
    }
}


x.For<IHelloDbService>().Use<HelloServiceWithDbLog>();
                .Ctor<ILogger>().Is<DbLogger>();

after some research it seems that structure map might provide what you want, see this question and the docs and you could also achieve what you want by injecting an abstract factory to create the loggers rather than the loggers themselves.

Structuremap configuration for choosing particular type by varying different constructor type

1 Answers1