Changes to Dependency Injection in Sitecore 8.1

If you are reading this, chances are you have used some form of DI in your Sitecore Solution. If you’ve used some of the standard IoC containers in an MVC application, you’ve also most likely used a custom dependency resolver. Using Simpleinjector, you can make a pretty simple custom dependency resolver for Sitecore – see here. In pre Sitecore 8.1, you would also need to make a custom controller factory, so that you can resolve using your own container. There are number of posts that shows you how to build a cool custom controller factory:

• Nathaniel Mann custom controller factory using Castle.Windsor
• John West’s Controller Injection Post
• Chaining DI by BrainJocks

What’s new in Sitecore 8.1?

Pre Sitecore 8.1, you had to make a custom controller factory because Sitecore by default did not use the DependencyResolver to create a controller instance. It was something like this:

 if (TypeHelper.LooksLikeTypeName(controllerName))
      {
        Type type = TypeHelper.GetType(controllerName);
        if (type != (Type) null)
          return TypeHelper.CreateObject(type);
      }
      return this.InnerFactory.CreateController(requestContext, controllerName);

In Sitecore 8.1, it uses the current DependencyResolver (as set by your application in App_Start) to create the controller instance – if it fails (i.e. didn’t find the concrete type in your container), then it still uses TypeHelper (Sitecore.Mvc.Helpers) to create the instance.

  if (TypeHelper.LooksLikeTypeName(controllerName))
      {
        Type type = TypeHelper.GetType(controllerName);
        if (type != (Type) null)
        {
          IController controller = DependencyResolver.Current.GetService(type) as IController ?? TypeHelper.CreateObject<IController>(type);
          if (controller != null)
            return controller;
        }
      }
   return this.InnerFactory.CreateController(requestContext, controllerName);

What this really means is that you don’t have to use your own custom controller factory anymore. You still need to use the fully qualified class name for the controller, though.

An update to how setup a custom dependency resolver

In my earlier post, I wrote about a simple custom dependency resolver using SimpleInjector. Steven van Deursen, one of the founders of SimpleInjector showed me a better way to do this, so that it would be compatible with upcoming changes in v3 and future changes. It involves wrapping your own implementation with a wrapper, so that creation of all instances are delegated to the SimpleInjectorDependencyResolver. Instead of implementing the GetService method yourself, you use the wrapper’s GetService method – this way, any updates done to SimpleInjector is seamless. So now, the class would look like this:

public class CustomDependencyResolver : IDependencyResolver
    {

        private IDependencyResolver wrappedResolver;

        public SitecoreDependencyResolver(IDependencyResolver wrappedResolver)
        {
            this.wrappedResolver = wrappedResolver;
        }



        public object GetService(Type serviceType)
        {
            try
            {
                return this.wrappedResolver.GetService(serviceType);
            }
            catch
            {
                return Sitecore.Mvc.Helpers.TypeHelper.CreateObject<IController>(serviceType, new object[0]);
            }

        }



        public IEnumerable<object> GetServices(Type serviceType)
        {
            return this.wrappedResolver.GetServices(serviceType);
        }

    }

And then when setting the DependencyResolver in App_Start, it would look like this:

public static class SimpleInjectorInitializer
    {
        

        //Initialize the container and register it as MVC Dependency Resolver.
        public static void Initialize()
        {
            var container = new Container();
            
            InitializeContainer(container);

            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            
            container.Verify();

            DependencyResolver.SetResolver(new CustomDependencyResolver(new SimpleInjectorDependencyResolver(container)));

        }
     
        private static void InitializeContainer(Container container)
        {
            // Register your classes (anything other than the MVC controllers)
            // For instance:
            // container.Register<IUserRepository, SqlUserRepository>();
        }
    }

Happy Coding!

Advertisement