一、前言
DependencyResolver是MVC中一個重要的組件，從名字可以看出，它負責依賴對象的解析，可以說它是MVC框架內部使用的一個IOC容 器。MVC內部很多對象的創建都是通過它完成的，或許我們平時沒有直接用到它，但是如果你在使用unity、autofac，或者在看一些開源項目時，總 會看到它的身影。接下來就讓我們看一下這個組件是如何工作的。
二、通過Controller的激活理解DependencyResolver的工作過程
這里先插一個題外話，經常會有面試問：asp.net 幾個核心對象是什么？一般人都會回答：Server、Request、Response、Session、Cookie這些。但我的回答會是 HttpApplication、HttpHandler和HttpModule，這才是管道模型中的核心類型，整個asp.net的處理流程和可擴展性 也都是建立在這幾個對象上的。
回到主題，asp.net請求都是交給HttpHandler處理的，對於MVC來說，是交給一個MvcHandler，它負責激活Controller，如果你不知道為什么，請看這里。在這里我們直接定位到MvcHandler的PR方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
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方法如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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定義如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
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接口的定義如下：
|
1
2
3
4
5
|
public
interface
IDependencyResolver
{
object
GetService(Type serviceType);
IEnumerable<
object
> GetServices(Type serviceType);
}
|
默認DependencyResolver.Current使用的是DefaultDependencyResolver類型，這里又和ControllerFactory和ControllerActivator的設計一樣了，如果我們自定義，那么就使用，否則就使用默認的。DefaultDependencyResolver定義如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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激活過程的三種做法。
三、實現IDependencyResolver接口
接下來通過一個例子證明上面的過程。我們要實現的需求是通過實現IDependencyResolver接口，實現Controller構造函數注入服務。如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
class
HomeController : Controller
{
private
IUserService _service;
public
HomeController(IUserService service)
{
_service = service;
}
public
ActionResult Index()
{
return
Content(_service.GetUserName());
}
}
|
HomeController只依賴於IUserService接口，不依賴於具體對象。
接下來我們實現IDependencyResolver接口，依賴注入的實現方式有很多種，這里我們使用Unity。如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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類在這里很簡單，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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:
|
1
2
|
Ioc.RegisterType<IUserService, UserService>();
DependencyResolver.SetResolver(
new
IocDependencyResolver());
|
運行就可以看到HomeController構造函數的IUserService就是UserService類型了。
四、總結
實際上，上面的例子我們也可以用實現IControllerFactory或者IControllerActivator達到同樣的目的，但使用 IDependencyResolver會更簡單一點，而且大部分的IOC框架都已經提供了這樣的功能。例如上面 UnityDependencyResolver根本不用自己定義，Unity for MVC 已經有這么一個類型了，直接使用即可。如果使用Autofac的話可以是：DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
分享源碼學習：http://www.jinhusns.com/Products/Download/?type=xcj