CODEWITHSUNDEEP
c#inversion-of-controlsimple-injector
Kerry Thomas
Kerry Thomas

Reputation: 133

How can I cause Simple Injector to use different concrete classes for the same interface, but with different classes

I can do this with StructureMap using Constructor Injection. However I cannot find a way to do this with Simple Injector. Here is some code that illustrates this (sorry for the length)

I've looked at the lambda in the Register method, but can't seem to understand how to call a single application wide instance of the container to get the one instance I need.

These are the object graphs I wish to construct:

var bannerTalker =
    new LoudMouth(
        new ConsoleShouter(), // Implements IConsoleVoicer
        new ObnoxiousBannerGenerator());

var plainTalker = 
    new TimidSpeaker(
        new ConsoleWhisperer());  // Implements IConsoleVoicer

Here's the code:

``` c#
public interface IConsoleVoicer
{
    void SaySomething(string whatToSay);
}

public class ConsoleWhisperer : IConsoleVoicer
{
    public void SaySomething(string whatToSay)
    {
        Console.WriteLine(whatToSay?.ToLower());
    }
}

public class ConsoleShouter : IConsoleVoicer
{
    public void SaySomething(string whatToSay)
    {
        Console.WriteLine(whatToSay?.ToUpper());
    }
}

public interface IBannerGenerator
{
    string GetBanner();
}

public class ObnoxiousBannerGenerator : IBannerGenerator
{
    public string GetBanner()
    {
        return "OBNOXIOUS";
    }
}

public interface IBannerTalker
{
    void SayWithBanner(string somethingToSay);
}

public class LoudMouth : IBannerTalker
{
    private IConsoleVoicer Voicer { get; set; }
    private IBannerGenerator BannerGenerator { get; set; }

    public LoudMouth(
        IConsoleVoicer concoleVoicer, IBannerGenerator bannerGenerator)
    {
        Voicer = concoleVoicer;
        BannerGenerator = bannerGenerator;
    }

    public void SayWithBanner(string somethingToSay)
    {
        Voicer.SaySomething(string.Format("{0}:{1}",
            BannerGenerator.GetBanner(), somethingToSay));
    }
}

public interface IPlainTalker
{
    void SayIt(string somethingToSay);
}

public class TimidSpeaker : IPlainTalker
{
    private IConsoleVoicer Voicer { get; set; }

    public TimidSpeaker(IConsoleVoicer concoleVoicer)
    {
        Voicer = concoleVoicer;
    }

    public void SayIt(string somethingToSay)
    {
        Voicer.SaySomething(somethingToSay);
    }
}

And this is what I've tried:

static void Main(string[] args)
{
    var container = new Container();
    container.Register<IBannerGenerator, ObnoxiousBannerGenerator>();

    container.Register<IPlainTalker, TimidSpeaker>();
    container.Register<IBannerTalker, LoudMouth>();

    //HERE IS THE DILEMMA! How do I assign
    // to IBannerTalker a A LoudMouth contructed with a ConsoleShouter,
    // and to IPlainTalkerTalker a A TimidSpeaker contructed with a ConsoleWhisperer 

    //container.Register<IConsoleVoicer, ConsoleShouter>();
    container.Register<IConsoleVoicer, ConsoleWhisperer>();

    var bannerTalker = container.GetInstance<IBannerTalker>();
    var plainTalker = container.GetInstance<IPlainTalker>();

    bannerTalker.SayWithBanner("i am a jerk");
    plainTalker.SayIt("people like me");
}

Upvotes: 0

Views: 114

Answers (1)

Steven
Steven

Reputation: 172646

Ric .Net is right in pointing you at the RegisterConditional methods. The following registrations complete your quest:

container.Register<IBannerGenerator, ObnoxiousBannerGenerator>();

container.Register<IPlainTalker, TimidSpeaker>();
container.Register<IBannerTalker, LoudMouth>();

container.RegisterConditional<IConsoleVoicer, ConsoleShouter>(
    c => c.Consumer.ImplementationType == typeof(LoudMouth));
container.RegisterConditional<IConsoleVoicer, ConsoleWhisperer>(
    c => c.Consumer.ImplementationType == typeof(TimidSpeaker));

Upvotes: 1

Related Questions