# Friday, 17 December 2010

As I have stated in previous posts I am huge supporter of TDD and you can’t get too far doing true TDD before you are forced to introduce an IoC Container, also known as a Dependency Injection Container.  You can find out more about Inversion of Control and Dependency Injection here.  When I first started looking into using the concept of Inversion Of Control in my code, my first stop was StructureMap.  Why…I can’t really remember but it was the first IoC framework I tried and it is the one I currently prefer to use.  But, being a consultant I pride myself in knowing my options and being able to work with or recommend the tool that is best suited for the situation…hence this blog post and example code.  I decided to put together this post and code showing how, if you plan accordingly, you can swap out any of the *major* IoC Frameworks without impacting the code. 

I set out with the goal of creating a swappable solution that would allow me work with the following IoC Frameworks.

Side Note:  Using NuGet really makes pulling down tools/packages very easy.  Check It Out!

So, let’s get started!  The basic principals of setting up and using an IoC container in code are the same no matter what Container you are using.  From the 30,000 foot view you need to:

  1. Map what concrete class implementations to use for what abstract (interface, abstract class) implementations.
  2. Have some way of resolving to a concrete implementation when passed an abstract implementation.

To get the juices flowing here is how you tackle this in StructureMap.

  1. Create a class that will be called on when our app spins up that will take care of our abstract –> concrete mappings.  Typically this class is called a Bootstrapper.  As you can see this class contains when method called Bootstrap that performs the mapping.  In this example there is one mapping that says (see line 18) whenever you need a concrete instance of IMyBusinessClass use the MyBusinessClass class.
    StructureMapBootsrapper
    1. using ChoosingAnIoC.Business;
    2. using ChoosingAnIoC.Core.Interfaces.Business;
    3. using StructureMap;
    4.  
    5. namespace ChoosingAnIoC.App.Bootsrappers {
    6.  
    7.     /// <summary>
    8.     /// Maps Abstract to Concrete Implementations Using StructureMap
    9.     /// </summary>
    10.     public class StructureMapBootstrapper : IBootstrapper {
    11.  
    12.         #region IBootstrapper Members
    13.  
    14.         /// <summary>
    15.         /// Setup of mappings
    16.         /// </summary>
    17.         public void Bootstrap() {
    18.             ObjectFactory.Initialize(x => x.For<IMyBusinessClass>().Use<MyBusinessClass>());
    19.         }
    20.  
    21.         #endregion
    22.     }
    23. }

 

  1. Create a class that can use the IoC containers mappings to hand you a concrete instance of class on demand.  I call this class a Resolver.
    StructureMapDependencyResolver
    1. using ChoosingAnIoC.Core.Interfaces;
    2. using StructureMap;
    3.  
    4. namespace ChoosingAnIoC.Core.DependencyResolvers
    5. {
    6.     /// <summary>
    7.     /// Class for resolving dependency's using StructureMap
    8.     /// </summary>
    9.     public class StructureMapDependencyResolver : IDependencyResolver
    10.     {
    11.         /// <summary>
    12.         /// Returns a concrete instance of the
    13.         /// supplied Interface
    14.         /// </summary>
    15.         /// <typeparam name="T">Interface of concrete instance to return</typeparam>
    16.         /// <returns>Concrete instance of the supplied interface</returns>
    17.         public T GetConcreteInstanceOf<T>() {
    18.             return ObjectFactory.GetInstance<T>();
    19.         }
    20.     }
    21. }

If  we add enough level of abstraction at these two points we can swap out any of the current IoC containers and hopefully be able to handle any that come along in the future.  As you probably noticed in the two code examples above…both of these classes implement an interface.  Below is the code for the two interfaces.

      IBootsrapper
      1. namespace ChoosingAnIoC.App.Bootsrappers {
      2.  
      3.     /// <summary>
      4.     /// Bootsrapper Interface
      5.     /// </summary>
      6.     public interface IBootstrapper {
      7.  
      8.         /// <summary>
      9.         /// Bootstrap and perform mappings
      10.         /// </summary>
      11.         void Bootstrap();
      12.     }
      13. }
      IDependencyResolver
      1. namespace ChoosingAnIoC.Core.Interfaces {
      2.  
      3.     /// <summary>
      4.     /// Interface for implementations of Dependency Resolver
      5.     /// <remarks>
      6.     /// This interface adds a layer of abstraction when we
      7.     /// resolve dependencies.  It will allow us to swap out
      8.     /// out IoC framework with minimal impact on our code.
      9.     /// </remarks>
      10.     /// </summary>
      11.     public interface IDependencyResolver {
      12.         
      13.         /// <summary>
      14.         /// Returns a concrete instance of the
      15.         /// supplied Interface
      16.         /// </summary>
      17.         /// <typeparam name="T">Interface of concrete instance to return</typeparam>
      18.         /// <returns>Concrete instance of the supplied interface</returns>
      19.         T GetConcreteInstanceOf<T>();
      20.  
      21.     }
      22. }

                                    Use this code a couple of factory classes to return whatever Bootstrapper and DependencyResolver our application is configured to use we can swap out IoC containers without affecting our code.

                                    The complete code including implementations of all the IoC containers noted above can be found here!

                                    Monday, 07 March 2011 01:32:43 (Central Standard Time, UTC-06:00)
                                    Thank you for this, I kind of like reading this here, keep updating on the latest..
                                    Health Beauty products sale
                                    Chris Harris
                                    Wednesday, 06 July 2011 21:37:31 (Central Daylight Time, UTC-05:00)
                                    We all know that not only the skechers shape ups are physiological footwear but also skechers fitness shoes could improve posture and gait, activate the whole body, and the shape up shoes also is good for health.As the new one is opening .More and more products is in great demand, and also all the skechers shape ups shoes are under sale promotion ,choose any one you like with free shipping.mens skechers resistance runner addresses all these needs. I don’t know if you’ve ever worn this particular brand, but their sizes are consistent, so once you know what size you wear in skechers shoes, you can order them sight-unseen and know that they’ll fit and that you won’t have to “break them in.” You put them on and go.shape ups shoes are specially designed to give you a leg up on things like weight loss, improving muscle tone,Skechers Resistance Runner and improving posture. Fantastic! I did a lot of reading and thinking. Even though I have a Skechers Womens Shoes closet, it only holds so many shape ups 2011, and I knew I’d have to give up a pair to make room for a new pair of cheap skechers shape ups.If you want to choose one pair fit your feet reebok easytone,why not consider easytone shoes.Here I want to introduce this style of shoes.cheap easytone shoes comes in a great range of varisou styles.
                                    Sunday, 20 January 2013 21:54:43 (Central Standard Time, UTC-06:00)
                                    I just wanted to comment on your blog and say I really enjoyed reading your blog here. It was very informative and I also digg the way you write! Keep it up and I'll be back soon to find out more mate.
                                    Name
                                    E-mail
                                    (will show your gravatar icon)
                                    Home page

                                    Comment (Some html is allowed: a@href@title, strike) where the @ means "attribute." For example, you can use <a href="" title=""> or <blockquote cite="Scott">.  

                                    Enter the code shown (prevents robots):

                                    Live Comment Preview