Dependency Injection of Multiple Objects Same Interface using StructureMap

I have been reading Mark Seemann's excellent book on Dependency Injection & applying what I have been learning to StructureMap.

Often times I have multiple objects that implement the same interface. In the past I may have used an abstract factory to create the instance I needed at a given time based on some sort of key or identifier like so:

	public class ScheduledEmailFactory
	{
	public static IScheduledEmail Create(ScheduledEmailType scheduledEmailType)
	{
	switch (scheduledEmailType)
	{
	case ScheduledEmailType.WholesaleFirstLargeOrder:
	return new WholesaleFirstLargeOrderScheduledEmail();
	case ScheduledEmailType.WholesaleNoOrdersAfterLargeOrder:
	return new WholesaleNoOrdersAfterLargeOrderScheduledEmail();
	}
	return null;
	}
	}

view raw gistfile1.cs hosted with ❤ by GitHub

However I was interested in using an IOC container like StructureMap to get rid of the ugly switch statement with the factory object. I did so by registering each object in my container and giving it a name with the .Named() method like so:

	//IOC Configuration
	x.For<IScheduledEmail>().HttpContextScoped().Use<WholesaleFirstLargeOrderScheduledEmail>().Named(string.Concat(ScheduledEmailTypeBase.Value, "1"));
	x.For<IScheduledEmail>().HttpContextScoped().Use<WholesaleNoOrdersAfterLargeOrderScheduledEmail>().Named(string.Concat(ScheduledEmailTypeBase.Value, "2"));
	//Factory Class
	public class ScheduledEmailFactory : IScheduledEmailFactory
	{
	private readonly IContainer _container;
	public ScheduledEmailFactory(IContainer container)
	{
	_container = container;
	}
	public IScheduledEmail Create(int scheduledEmailType)
	{
	var key = string.Concat(ScheduledEmailTypeBase.Value, scheduledEmailType.ToString());
	var scheduledEmail = _container.GetInstance<IScheduledEmail>(key);
	return scheduledEmail;
	}
	}

view raw gistfile1.cs hosted with ❤ by GitHub

If you would like to see more please check out a simple example project over at my GitHub called MultipleObjectDemo.

Fun With Strongly Typed Enums!

Nobody likes using plain old boring Enums in C# these days! So why not try using a cool strongly typed Enum instead.

	namespace Models
	{
	public class Alignment
	{
	public static readonly Alignment Good = new Alignment("Good");
	public static readonly Alignment Neutral = new Alignment("Neutral");
	public static readonly Alignment Evil = new Alignment("Evil");
	private readonly string _value;
	private Alignment(string value)
	{
	_value = value;
	}
	public override string ToString()
	{
	return _value;
	}
	}
	}
	namespace Models
	{
	public interface IPerson
	{
	string Name { get; set; }
	Alignment Alignment { get; }
	string Gloat();
	}
	}

view raw gistfile1.cs hosted with ❤ by GitHub