Windsor Installer in Castle Windsor

A friend of mine was going through the asp.net mvc storefront starter kit project by Rob Conery. It’s really a nice little MVC project which guides you on how to build a real life project and the step-by-step 24 series webcasts on how to build it great.

The project implements StructureMap as the IoC container and my friend asked me if CastleWindsor has anything equivalent of the registry class.

No way this post is about which IoC container is better than the other in fact I think all are quite good and I like CastleWindsor as I am more familiar with it and it has some really good extensibility point. In the Storefront Starter Kit project the IoC registration happens through the Bootstrapper class which has the following code.

namespace Commerce.MVC.Web {

    public static class Bootstrapper {

        public static void ConfigureStructureMap() {

            StructureMapConfiguration.AddRegistry(new DBServiceRegistry());

            StructureMapConfiguration.AddRegistry(new StorefrontRegistry());

        }

    }

and the StorefrontRegistry class looks like

   public class StorefrontRegistry : Registry {

        protected override void configure() {

           
            ForRequestedType<IOrderService>()

                .TheDefaultIsConcreteType<OrderService>();

           
            ForRequestedType<ICatalogService>()

                .TheDefaultIsConcreteType<CatalogService>();

            ForRequestedType<IOrderRepository>()

                .TheDefaultIsConcreteType<SqlOrderRepository>();

       //rest of the implementation..

       }

  }

and the equivalent registry class in CastleWindsor is the IWindsorInstaller interface and this is the implementation of the interface it :-

 public class StorefrontInstaller : IWindsorInstaller

    {

      public void Install(IWindsorContainer container, IConfigurationStore store)

      {

          container.Register(

                Component.For<IOrderService>().ImplementedBy<OrderService>(),

                Component.For<ICatalogService>().ImplementedBy<CatalogService>(),

                Component.For<IOrderRepository>().ImplementedBy<SqlOrderRepository>()

                // Rest of the implementation …

            );

      }

   }

And this is how the bootstrapper method will look like with the windsor container.

   public static class Bootstrapper {

       public static void ConfigureWindsorCastle(IWindsorContainer container)

       {

          container.Install(new StorefrontInstaller());

            // Other Installer for the system…

       }

   }

 

As you can see most of the concept are quite similar in most of the IoC container and it’s not which is better than which one but it’s the design principle and how you see best fit for your design.Just don’t use IoC if you just want to do something like for an interface IMyClass you have a class MyClass and you want to inject it like

 

container.Register(Component.For<IMyClass>().ImplementedBy<MyClass>());

 

Use the SOLID design principle to design these interfaces, apply the Single Responsibility principle and DRY(Don’t repeat yourself) to design these interfaces,classes and then use the IoC container to inject the dependencies.

I thing it is a good pattern to get your component registered with your IoC container and also gives modularity on injecting these dependencies

Advertisement