理解ASP.NET MVC的DependencyResolver组件

1、前言

　　DependencyResolver是MVC中一个重要的组件，从名字能够看出，它负责依赖对象的解析，能够说它是MVC框架内部使用的一个IOC容器。MVC内部不少对象的建立都是经过它完成的，或许咱们平时没有直接用到它，可是若是你在使用unity、autofac，或者在看一些开源项目时，总会看到它的身影。接下来就让咱们看一下这个组件是如何工做的。

2、经过Controller的激活理解DependencyResolver的工做过程

　　这里先插一个题外话，常常会有面试问：asp.net 几个核心对象是什么？通常人都会回答：Server、Request、Response、Session、Cookie这些。但个人回答会是HttpApplication、HttpHandler和HttpModule，这才是管道模型中的核心类型，整个asp.net的处理流程和可扩展性也都是创建在这几个对象上的。

　　回到主题，asp.net请求都是交给HttpHandler处理的，对于MVC来讲，是交给一个MvcHandler，它负责激活Controller，若是你不知道为何，请看这里。在这里咱们直接定位到MvcHandler的PR方法：

protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
{
    IController controller;
    IControllerFactory factory;
    ProcessRequestInit(httpContext, out controller, out factory);

    //其它操做
    //调用 controller.Execute方法
}

private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory)
{
    HttpContext currentContext = HttpContext.Current;

    //从路由获取controller名称
    string controllerName = RequestContext.RouteData.GetRequiredString("controller");

    //经过ControllerBuilder获取ControllerFactory，默认就是DefaultControllerFactory
    factory = ControllerBuilder.GetControllerFactory();

    //经过ControllerFactory获取Controller对象
    controller = factory.CreateController(RequestContext, controllerName);
}

　　ControllerFactory故名思议就是用于建立Controller的，咱们也能够本身实现IControllerFactory，参与Controller的激活过程，具体是在全局调用ControllerBuilder.Current.SetControllerFactory方法。咱们这里主要关注的是Controller的激活过程，实际上它们的建立过程是类似的。默认使用的ControllerFactory是DefaultControllerFactory。DefaultControllerFactory的CreateController方法以下：　　

         public virtual IController CreateController(RequestContext requestContext, string controllerName)
        {
            //获取Controller类型
            Type controllerType = GetControllerType(requestContext, controllerName);

            IController controller = GetControllerInstance(requestContext, controllerType);
            return controller;
        }

        protected internal virtual IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            return ControllerActivator.Create(requestContext, controllerType);
        }

　　能够看到，它经过一个ControllerActivator来建立IController对象，默认使用的是DefaultControllerActivator。与ControllerFactory相似，咱们能够实现IControllerActivator，参与Controller的激活过程，具体是将ControllerActivator做为DefaultConrtollerFactory构造函数参数，而后再在全局调用ControllerBuilder.Current.SetControllerFactory方法。能够看到MVC的Controller激活过程是很灵活的，它提供多种方式让咱们自定义激活过程。DefaultControllerActivator定义以下：

        private class DefaultControllerActivator : IControllerActivator
        {
            private Func<IDependencyResolver> _resolverThunk;

            public DefaultControllerActivator()
                : this(null)
            {
            }

            public DefaultControllerActivator(IDependencyResolver resolver)
            {
                if (resolver == null)
                {
                    _resolverThunk = () => DependencyResolver.Current;
                }
                else
                {
                    _resolverThunk = () => resolver;
                }
            }

            public IController Create(RequestContext requestContext, Type controllerType)
            {
                try
                {
                    return (IController)(_resolverThunk().GetService(controllerType) ?? Activator.CreateInstance(controllerType));
                }
                catch (Exception ex)
                {
                }
            }
        }  

　　这里的_resolverThunk是一个用于获取IDepencyResolver对象的委托，实际得到的是DependencyResolver.Current。咱们也能够本身实现IDependencyResolver，参与Controller的激活过程，具体是在全局调用DependencyResolver的静态方法SetResolver方法。须要注意的是这里的DependencyResolver类型（这里是类型，而其它地方提到的DependencyResolver都是组件的意思）并无实现IDependencyResolver接口，我以为将它命名为DependencyResolverContainer会更合适一些。IDepdencyResolver接口的定义以下：

    public interface IDependencyResolver
    {
        object GetService(Type serviceType);
        IEnumerable<object> GetServices(Type serviceType);
    }

　　默认DependencyResolver.Current使用的是DefaultDependencyResolver类型，这里又和ControllerFactory和ControllerActivator的设计同样了，若是咱们自定义，那么就使用，不然就使用默认的。DefaultDependencyResolver定义以下：

        private class DefaultDependencyResolver : IDependencyResolver
        {
            public object GetService(Type serviceType)
            {
                if (serviceType.IsInterface || serviceType.IsAbstract)
                {
                    return null;
                }

                try
                {
                    //若是Controller Type建立Controller实例对象
                    return Activator.CreateInstance(serviceType);
                }
                catch
                {
                    return null;
                }
            }

            public IEnumerable<object> GetServices(Type serviceType)
            {
                return Enumerable.Empty<object>();
            }
        }

　　能够看到，MVC会将Controller对象的建立经过DependencyResolver完成。将对象的建立经过DependencyResolver完成的好处是能够下降对象间的耦合度；另外，经过实现IDependencyResolver接口，咱们能够彻底控制对象的建立过程，例如将对象的依赖关系转移到配置文件中等等。

　　经过上面咱们还知道了有三种默认类型：DefaultControllerFactory、DefaultControllerActivator和DefaultDependencyResolver，分别对应三个接口：IControllerFactory、IControllerActivator、IDependencyResolver。它们的设计是相似的，都是提供给外部一个接口，若是外部本身实现了这个过程，那么就使用，不然用默认的。实际上这也是咱们参与Controller激活过程的三种作法。

3、实现IDependencyResolver接口

　　接下来经过一个例子证实上面的过程。咱们要实现的需求是经过实现IDependencyResolver接口，实现Controller构造函数注入服务。如：

        public class HomeController : Controller
        {            
            private IUserService _service;
            public HomeController(IUserService service)
            {
                _service = service;
            }

            public ActionResult Index()
            {
                return Content(_service.GetUserName());
            }
	    }

　　HomeController只依赖于IUserService接口，不依赖于具体对象。

　　接下来咱们实现IDependencyResolver接口，依赖注入的实现方式有不少种，这里咱们使用Unity。以下：

        public class UnityDependencyResolver : IDependencyResolver
        {
            public object GetService(Type serviceType)
            {
                if(serviceType == null)
                {
                    throw new ArgumentNullException("serviceType");
                }            
                return (serviceType.IsClass && !serviceType.IsAbstract) 
                    || Ioc.IsRegistered(serviceType) ? Ioc.GetService(serviceType) : null;
            }

            public IEnumerable<object> GetServices(Type serviceType)
            {
                if (serviceType == null)
                {
                    throw new ArgumentNullException("serviceType");
                }
                return (serviceType.IsClass && !serviceType.IsAbstract)
                    || Ioc.IsRegistered(serviceType) ? Ioc.GetServices(serviceType) : null;
            }
        }

　　这里须要判断 (serviceType.IsClass && !serviceType.IsAbstract) || Ioc.IsRegistered(serviceType) 缘由是咱们前面说过的，MVC内部不少对象都是经过DependencyResolver组件建立的，如上面的IConrtollerFactoy，因此这里咱们只负责对已注册的类型或类（非抽象类）进行解析。

　　Ioc类在这里很简单，以下：

    public class Ioc
    {
        private static IUnityContainer _container = new UnityContainer();

        public static void RegisterType<TFrom,TTo>()
            where TTo : TFrom
        {            
            _container.RegisterType<TFrom, TTo>();
        }

        public static object GetService(Type type)
        {                        
            return _container.Resolve(type);
        }

        public static IEnumerable<object> GetServices(Type type)
        {
            return _container.ResolveAll(type);
        }

        public static bool IsRegistered(Type type)
        {
            return _container.IsRegistered(type);
        }
    }

　　接着，在Application_Start方法中，注册Service和设置IocDependencyResolver:

            Ioc.RegisterType<IUserService, UserService>();
            DependencyResolver.SetResolver(new IocDependencyResolver());

　　运行就能够看到HomeController构造函数的IUserService就是UserService类型了。

4、总结

 　　实际上，上面的例子咱们也能够用实现IControllerFactory或者IControllerActivator达到一样的目的，但使用IDependencyResolver会更简单一点，并且大部分的IOC框架都已经提供了这样的功能。例如上面UnityDependencyResolver根本不用本身定义，Unity for MVC 已经有这么一个类型了，直接使用便可。若是使用Autofac的话能够是：DependencyResolver.SetResolver(new AutofacDependencyResolver(container));