ServiceStack IOC Autowiring by Convention

A situation came up where we wanted to implement a convention to auto-wire many of our classes using ServiceStack IOC. Basically we wanted to eliminate the need to hard-code mappings over and over for every class in a bootstrap file.

For example we wanted to avoid this:

container.RegisterAutoWiredAs<MyType1,IMyType1>();
container.RegisterAutoWiredAs<MyType2,IMyType2>();
container.RegisterAutoWiredAs<MyType3,IMyType3>();
container.RegisterAutoWiredAs<MyType4,IMyType4>();
...

To achieve this we can use .net reflection to scan our assemblies and look for a special interface that represents classes we want to automatically inject. Then we can utilize the ServiceStack IOC method RegisterAutoWiredType to register the types during runtime.

Here's an example where IInjectable is the interface we use to identify which classes will be injected:

	//This class cannot be injected
	public class DummyManager
	{
	public void DoSomething(int id)
	{
	}
	}

view raw DummyManager.cs hosted with ❤ by GitHub

	public interface IInjectable
	{
	}

view raw IInjectable.cs hosted with ❤ by GitHub

	private static void RegisterCustomTypes(Container container)
	{
	//Get the Assembly Where the injectable classes are located.
	var assembly = Assembly.GetAssembly(typeof(IInjectable));
	//Get the injectable classes
	var types =assembly.GetTypes()
	.Where(m => m.IsClass && m.GetInterface("IInjectable") != null);
	//loop through the injectable classes
	foreach (var theType in types)
	{
	//set up the naming convention
	var className = theType.Name;
	var interfaceName = string.Concat("I", className);
	//create the interface based on the naming convention
	var theInterface = theType.GetInterface(interfaceName);
	//register the type with the convention
	container.RegisterAutoWiredType(theType, theInterface);
	}
	}

view raw Ioc.cs hosted with ❤ by GitHub

	//This class can be injected
	public interface ITestManager : IInjectable
	{
	void Execute(int id);
	}
	public class TestManager : ITestManager
	{
	public void Execute(int id)
	{
	throw new System.NotImplementedException();
	}
	}

view raw TestManager.cs hosted with ❤ by GitHub

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

CSS Font Shortcuts

Using multiple weights and styles

In CSS, you can specify font-weights other than normal and bold by using numeric font-weight values. Here is a list of which numeric values most frequently correspond to which weights:

• 100 = thin
• 200 = extra-light
• 300 = light
• 400 = normal, book
• 500 = medium
• 600 = demi-bold
• 700 = bold
• 800 = heavy
• 900 = black