白话ASP.NET MVC之三：Controller是如何解析出来的

时间：2017-08-15 18:54:05 阅读：227 评论：0 收藏：0 [点我收藏+]

标签：amp 完整关系图 ext processes thunk str 目的查看

我们在上一篇文章中介绍Controller激活系统中所涉及到的一些类型，比如有关Controller类型的相关定义类型就包括了IController类型，IAsyncController类型，ControllerBase抽象类型和我们最终要使用的抽象类型Controller，这是ASP.NET MVC 框架中和Controller本身定义相关的类型。其他辅助类型，包括管理Controller的类型ControllerFactory，这个工厂负责Controller的生产和销毁。我们还涉及到另一个辅助类型，用于把系统默认定义的或者自定义的ControllerFactory注册到ASP.NET MVC框架中的类型ControllerBuilder。

Controller类型、ControllerFactory类型和ControllerBuilder类型，他们之间的关系可以描述为：ControllerBuilder是面向客户的，或者说是程序员和ASP.NET MVC框架之间的桥梁。我们通过ControllerBuilder类型的SetControllerFactory方法把我们自定义的ControllerFactory类型实例注册到ASP.NET MVC框架中，ControllerFactory类型用于管理Controller类型实例，其实也就是说ControllerFactory类型就是ASP.NET MVC框架中的一个扩展点。

我们今天主要讲Controller是怎么解析出来的，之所以把这一部分分开写，因为合在一起太长了，也说的不详细，如果大家对以上说的不太清楚，可以查看《白话ASP.NET MVC之二：Controller激活系统的概览》，该文对ASP.NET MVC框架中所提到的Controlelr激活系统所涉及的类型有详细的介绍。

一、“路由系统”和“激活系统”是怎么关联起来的

上一篇文章有过讲述，我们在这里简单说一下。ASP.NET 的路由系统是建立在一个叫做UrlRoutingModule的HttpModule组件上的，针对请求的路由解析是通过注册HttpApplication对象的PostResolveRequestCache事件来实现的，为当前的请求动态映射到一个HttpHandler类型上，最终由该HttpHandler接管请求并处理。我们来看看UrlRoutingModule类型的代码吧。

 1 public class UrlRoutingModule : IHttpModule
 2 {
 3     private static readonly object _contextKey = new object();
 4 
 5     private static readonly object _requestDataKey = new object();
 6 
 7     private RouteCollection _routeCollection;
 8 
 9     public RouteCollection RouteCollection
10     {
11         get
12         {
13             if (this._routeCollection == null)
14             {
15                 this._routeCollection = RouteTable.Routes;
16             }
17             return this._routeCollection;
18         }
19         set
20         {
21             this._routeCollection = value;
22         }
23     }
24 
25     protected virtual void Dispose()
26     {
27     }
28 
29     protected virtual void Init(HttpApplication application)
30     {
31         if (application.Context.Items[UrlRoutingModule._contextKey] != null)
32         {
33             return;
34         }
35             application.Context.Items[UrlRoutingModule._contextKey] = UrlRoutingModule._contextKey;
36         application.PostResolveRequestCache += new EventHandler(this.OnApplicationPostResolveRequestCache);
37     }
38 
39     private void OnApplicationPostResolveRequestCache(object sender, EventArgs e)
40     {
41         HttpContextBase context = new HttpContextWrapper(((HttpApplication)sender).Context);
42             this.PostResolveRequestCache(context);
43     }
44 
45     [Obsolete("This method is obsolete. Override the Init method to use the PostMapRequestHandler event.")]
46         public virtual void PostMapRequestHandler(HttpContextBase context)
47     {
48     }
49 
50     public virtual void PostResolveRequestCache(HttpContextBase context)
51     {
52         RouteData routeData = this.RouteCollection.GetRouteData(context);
53         if (routeData == null)
54         {
55             return;
56         }
57         IRouteHandler routeHandler = routeData.RouteHandler;
58         if (routeHandler == null)
59         {
60             throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, SR.GetString("UrlRoutingModule_NoRouteHandler"), new object[0]));
61         }
62         if (routeHandler is StopRoutingHandler)
63         {
64             return;
65         }
66         RequestContext requestContext = new RequestContext(context, routeData);
67         context.Request.RequestContext = requestContext;
68         IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);
69         if (httpHandler == null)
70         {
71             throw new InvalidOperationException(string.Format(CultureInfo.CurrentUICulture, SR.GetString("UrlRoutingModule_NoHttpHandler"), new object[]
72             {
73                 routeHandler.GetType()
74             }));
75         }
76         if (!(httpHandler is UrlAuthFailureHandler))
77         {
78             context.RemapHandler(httpHandler);
79             return;
80         }
81         if (FormsAuthenticationModule.FormsAuthRequired)
82         {
83                 UrlAuthorizationModule.ReportUrlAuthorizationFailure(HttpContext.Current, this);
84             return;
85         }
86         throw new HttpException(401, SR.GetString("Assess_Denied_Description3"));
87     }
88 
89     void IHttpModule.Dispose()
90     {
91             this.Dispose();
92     }
93 
94     void IHttpModule.Init(HttpApplication application)
95     {
96             this.Init(application);
97     }
98 }

具体来说，该组件通过以RouteTable的静态属性Routes表示的路由表针对当前请求实施路由解析，如果有匹配，就会根据路由对象Route来生成RouteData路由数据对象，然后我们借助RouteData对象的RouteHandler属性获取想要的HttpHandler对象。在默认情况下这个RouteHandler属性所代表的对象是MvcRouteHandler。翠花，上代码：

 1 /// <summary>Creates an object that implements the IHttpHandler interface and passes the request context to it.</summary>
 2 public class MvcRouteHandler : IRouteHandler
 3 {
 4     private IControllerFactory _controllerFactory;
 5 
 6     /// <summary>Initializes a new instance of the <see cref="T:System.Web.Mvc.MvcRouteHandler" /> class.</summary>
 7     public MvcRouteHandler()
 8     {
 9     }
10 
11     /// <summary>Initializes a new instance of the <see cref="T:System.Web.Mvc.MvcRouteHandler" /> class using the specified factory controller object.</summary>
12     /// <param name="controllerFactory">The controller factory.</param>
13     public MvcRouteHandler(IControllerFactory controllerFactory)
14     {
15         this._controllerFactory = controllerFactory;
16     }
17 
18     /// <summary>Returns the HTTP handler by using the specified HTTP context.</summary>
19     /// <returns>The HTTP handler.</returns>
20     /// <param name="requestContext">The request context.</param>
21     protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
22     {
23         requestContext.HttpContext.SetSessionStateBehavior(this.GetSessionStateBehavior(requestContext));
24         return new MvcHandler(requestContext);
25     }
26 
27     /// <summary>Returns the session behavior.</summary>
28     /// <returns>The session behavior.</returns>
29     /// <param name="requestContext">The request context.</param>
30     protected virtual SessionStateBehavior GetSessionStateBehavior(RequestContext requestContext)
31     {
32         string text = (string)requestContext.RouteData.Values["controller"];
33         if (string.IsNullOrWhiteSpace(text))
34         {
35             throw new InvalidOperationException(MvcResources.MvcRouteHandler_RouteValuesHasNoController);
36         }
37         IControllerFactory controllerFactory = this._controllerFactory ?? ControllerBuilder.Current.GetControllerFactory();
38         return controllerFactory.GetControllerSessionBehavior(requestContext, text);
39     }
40 
41     /// <summary>Returns the HTTP handler by using the specified request context.</summary>
42     /// <returns>The HTTP handler.</returns>
43     /// <param name="requestContext">The request context.</param>
44     IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext)
45     {
46         return this.GetHttpHandler(requestContext);
47     }
48 }

在该类型里面包含了一个IControllerFactory类型成员字段，这个接口类型是所有ControllerFactory都要必须实现的接口，否则就不叫Controller的工厂了。MvcRouteHandler类型有两个构造函数，无参的没的说，另一个需要传递一个IControllerFactory类型的参数，这个参数用于初始化MvcRouteHandler类型内部包含的类型为IControllerFactory的_controllerFactory字段。当我们构造MvcRouteHandler实例的时候，如果我们调用了无参的构造函数，它会在内部使用ControllerBuilder.Current.GetControllerFactory（）方法来获取我们通过ControllerBuilder类型注册的IControllerFactory类型的实例，代码很明显：

IControllerFactory controllerFactory = this._controllerFactory ?? ControllerBuilder.Current.GetControllerFactory();

MvcRouteHandler实现了IRouteHandler接口，目的只有一个，提供后续的HttpHandler，IRouteHandler接口定义如下：

1 public interface IRouteHandler
2 {
3     IHttpHandler GetHttpHandler(RequestContext requestContext);
4 }

MvcRouteHandler会给我们直接返回MvcHandler对象，这个对象用于处理请求，包括激活Controler对象，代码最有说服力，这份代码，上篇文章也贴过，现在也贴一下把，上代码：

  1 /// <summary>Selects the controller that will handle an HTTP request.</summary>
  2 public class MvcHandler : IHttpAsyncHandler, IHttpHandler, IRequiresSessionState
  3 {
  4     private struct ProcessRequestState
  5     {
  6         internal IAsyncController AsyncController;
  7 
  8         internal IControllerFactory Factory;
  9 
 10         internal RequestContext RequestContext;
 11 
 12         internal void ReleaseController()
 13         {
 14                 this.Factory.ReleaseController(this.AsyncController);
 15         }
 16     }
 17 
 18     private static readonly object _processRequestTag = new object();
 19 
 20     internal static readonly string MvcVersion = MvcHandler.GetMvcVersionString();
 21 
 22     /// <summary>Contains the header name of the ASP.NET MVC version.</summary>
 23     public static readonly string MvcVersionHeaderName = "X-AspNetMvc-Version";
 24 
 25     private ControllerBuilder _controllerBuilder;
 26 
 27     internal ControllerBuilder ControllerBuilder
 28     {
 29         get
 30         {
 31             if (this._controllerBuilder == null)
 32             {
 33                 this._controllerBuilder = ControllerBuilder.Current;
 34             }
 35             return this._controllerBuilder;
 36         }
 37         set
 38         {
 39             this._controllerBuilder = value;
 40         }
 41     }
 42 
 43     /// <summary>Gets or sets a value that indicates whether the MVC response header is disabled.</summary>
 44     /// <returns>true if the MVC response header is disabled; otherwise, false.</returns>
 45     public static bool DisableMvcResponseHeader
 46     {
 47         get;
 48         set;
 49     }
 50 
 51     /// <summary>Gets a value that indicates whether another request can use the <see cref="T:System.Web.IHttpHandler" /> instance.</summary>
 52     /// <returns>true if the <see cref="T:System.Web.IHttpHandler" /> instance is reusable; otherwise, false.</returns>
 53     protected virtual bool IsReusable
 54     {
 55         get
 56         {
 57             return false;
 58         }
 59     }
 60 
 61     /// <summary>Gets the request context.</summary>
 62     /// <returns>The request context.</returns>
 63     public RequestContext RequestContext
 64     {
 65         get;
 66         private set;
 67     }
 68 
 69     /// <summary>Gets a value that indicates whether another request can use the <see cref="T:System.Web.IHttpHandler" /> instance.</summary>
 70     /// <returns>true if the <see cref="T:System.Web.IHttpHandler" /> instance is reusable; otherwise, false.</returns>
 71     bool IHttpHandler.IsReusable
 72     {
 73         get
 74         {
 75             return this.IsReusable;
 76         }
 77     }
 78 
 79     /// <summary>Initializes a new instance of the <see cref="T:System.Web.Mvc.MvcHandler" /> class.</summary>
 80     /// <param name="requestContext">The request context.</param>
 81     /// <exception cref="T:System.ArgumentNullException">The <paramref name="requestContext" /> parameter is null.</exception>
 82     public MvcHandler(RequestContext requestContext)
 83     {
 84         if (requestContext == null)
 85         {
 86             throw new ArgumentNullException("requestContext");
 87         }
 88         this.RequestContext = requestContext;
 89     }
 90 
 91     /// <summary>Adds the version header by using the specified HTTP context.</summary>
 92     /// <param name="httpContext">The HTTP context.</param>
 93     protected internal virtual void AddVersionHeader(HttpContextBase httpContext)
 94     {
 95         if (!MvcHandler.DisableMvcResponseHeader)
 96         {
 97             httpContext.Response.AppendHeader(MvcHandler.MvcVersionHeaderName, MvcHandler.MvcVersion);
 98         }
 99     }
100 
101     /// <summary>Called by ASP.NET to begin asynchronous request processing.</summary>
102     /// <returns>The status of the asynchronous call.</returns>
103     /// <param name="httpContext">The HTTP context.</param>
104     /// <param name="callback">The asynchronous callback method.</param>
105     /// <param name="state">The state of the asynchronous object.</param>
106     protected virtual IAsyncResult BeginProcessRequest(HttpContext httpContext, AsyncCallback callback, object state)
107     {
108         HttpContextBase httpContext2 = new HttpContextWrapper(httpContext);
109         return this.BeginProcessRequest(httpContext2, callback, state);
110     }
111 
112     /// <summary>Called by ASP.NET to begin asynchronous request processing using the base HTTP context.</summary>
113     /// <returns>The status of the asynchronous call.</returns>
114     /// <param name="httpContext">The HTTP context.</param>
115     /// <param name="callback">The asynchronous callback method.</param>
116     /// <param name="state">The state of the asynchronous object.</param>
117     protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
118     {
119         IController controller;
120         IControllerFactory factory;
121         this.ProcessRequestInit(httpContext, out controller, out factory);
122         IAsyncController asyncController = controller as IAsyncController;
123         if (asyncController != null)
124         {
125             BeginInvokeDelegate<MvcHandler.ProcessRequestState> beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState, MvcHandler.ProcessRequestState innerState)
126             {
127                 IAsyncResult result;
128                 try
129                 {
130                     result = innerState.AsyncController.BeginExecute(innerState.RequestContext, asyncCallback, asyncState);
131                 }
132                 catch
133                 {
134                     innerState.ReleaseController();
135                     throw;
136                 }
137                 return result;
138             };
139             EndInvokeVoidDelegate<MvcHandler.ProcessRequestState> endDelegate = delegate(IAsyncResult asyncResult, MvcHandler.ProcessRequestState innerState)
140             {
141                 try
142                 {
143                     innerState.AsyncController.EndExecute(asyncResult);
144                 }
145                 finally
146                 {
147                     innerState.ReleaseController();
148                 }
149                 ;
150                 MvcHandler.ProcessRequestState invokeState = new MvcHandler.ProcessRequestState
151                 {
152                     AsyncController = asyncController,
153                     Factory = factory,
154                     RequestContext = this.RequestContext
155                 };
156                 SynchronizationContext synchronizationContext = SynchronizationContextUtil.GetSynchronizationContext();
157                 return AsyncResultWrapper.Begin<MvcHandler.ProcessRequestState>(callback, state, beginDelegate, endDelegate, invokeState, MvcHandler._processRequestTag, -1, synchronizationContext);
158             }
159             Action action = delegate
160             {
161                 try
162                 {
163                     controller.Execute(this.RequestContext);
164                 }
165                 finally
166                 {
167                     factory.ReleaseController(controller);
168                 }
169             };
170             return AsyncResultWrapper.BeginSynchronous(callback, state, action, MvcHandler._processRequestTag);
171         }
172 
173         /// <summary>Called by ASP.NET when asynchronous request processing has ended.</summary>
174         /// <param name="asyncResult">The asynchronous result.</param>
175         protected internal virtual void EndProcessRequest(IAsyncResult asyncResult)
176         {
177             AsyncResultWrapper.End(asyncResult, MvcHandler._processRequestTag);
178         }
179 
180         private static string GetMvcVersionString()
181         {
182             return new AssemblyName(typeof(MvcHandler).Assembly.FullName).Version.ToString(2);
183         }
184 
185         /// <summary>Processes the request by using the specified HTTP request context.</summary>
186         /// <param name="httpContext">The HTTP context.</param>
187         protected virtual void ProcessRequest(HttpContext httpContext)
188         {
189             HttpContextBase httpContext2 = new HttpContextWrapper(httpContext);
190             this.ProcessRequest(httpContext2);
191         }
192 
193         /// <summary>Processes the request by using the specified base HTTP request context.</summary>
194         /// <param name="httpContext">The HTTP context.</param>
195         protected internal virtual void ProcessRequest(HttpContextBase httpContext)
196         {
197             IController controller;
198             IControllerFactory controllerFactory;
199             this.ProcessRequestInit(httpContext, out controller, out controllerFactory);
200             try
201             {
202                 controller.Execute(this.RequestContext);
203             }
204             finally
205             {
206                 controllerFactory.ReleaseController(controller);
207             }
208     }
209 
210     private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory)
211     {
212         HttpContext current = HttpContext.Current;
213         if (current != null && ValidationUtility.IsValidationEnabled(current) == true)
214             {                ValidationUtility.EnableDynamicValidation(current);
215             }            this.AddVersionHeader(httpContext);
216             this.RemoveOptionalRoutingParameters();
217             string requiredString = this.RequestContext.RouteData.GetRequiredString("controller");
218             factory = this.ControllerBuilder.GetControllerFactory();
219             controller = factory.CreateController(this.RequestContext, requiredString);
220             if (controller == null)
221             {
222                 throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, MvcResources.ControllerBuilder_FactoryReturnedNull, new object[]
223                 {
224                     factory.GetType(),
225                     requiredString
226                 }));
227             }
228         }
229 
230         private void RemoveOptionalRoutingParameters()
231         {
232             RouteValueDictionary values = this.RequestContext.RouteData.Values;
233             values.RemoveFromDictionary((KeyValuePair<string, object> entry) => entry.Value == UrlParameter.Optional);
234         }
235 
236         /// <summary>Enables processing of HTTP Web requests by a custom HTTP handler that implements the <see cref="T:System.Web.IHttpHandler" /> interface.</summary>
237         /// <param name="httpContext">An <see cref="T:System.Web.HttpContext" /> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) that are used to service HTTP requests.</param>
238         void IHttpHandler.ProcessRequest(HttpContext httpContext)
239         {
240             this.ProcessRequest(httpContext);
241         }
242 
243         /// <summary>Called by ASP.NET to begin asynchronous request processing using the base HTTP context.</summary>
244         /// <returns>The status of the asynchronous call.</returns>
245         /// <param name="context">The HTTP context.</param>
246         /// <param name="cb">The asynchronous callback method.</param>
247         /// <param name="extraData">The data.</param>
248         IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
249         {
250             return this.BeginProcessRequest(context, cb, extraData);
251         }
252 
253         /// <summary>Called by ASP.NET when asynchronous request processing has ended.</summary>
254         /// <param name="result">The asynchronous result.</param>
255         void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result)
256         {
257             this.EndProcessRequest(result);
258         }
259     }

MvcHandler类型的BeginProcessRequest方法用来处理请求，包括激活Controller实例等。由于MvcHandler类型同时实现了IHttpHandler接口和IHttpAsyncHandler接口，所以他总是异步方式去执行（调用BeginProcessRequest/EndProcessRequest方法）。BeginProcessRequest方法在执行的时候通过RequestContext对象的RouteData属性获得Controller的名字，然后在通过ControllerBuilder获得ControllerFactory对象，然后用Controller的名字和ControllerFactory对象来激活目标Controller实例。如果Controller类型实现了IAsyncController接口，那就以异步方式执行Controller，否则以同步方式执行。Controller对象成功执行后，MvcHandler对象会调用ControllerFactory对象ReleaseController方法来销毁Controller实例对象。

我们小结一下，ASP.NET MVC的路由系统和Controller的激活系统是通过这些对象关联起来的：请求Url ------->Route------->RouteData------->RouteHandler（MvcRouteHandler）-------->MvcRouteHandler------>MvcHandler，通过这些对象就能串起来了。

二、Controller的详细解析过程

我先来简述一下Controller解析的原理吧。Controller实例对象的解析是通过实现了IControllerFactory接口的ControllerFactory对象实现的，ControllerFactory是怎么来的呢？是通过调用ControllerBuilder的SetControllerFactory方法实现对ControllerFactory类型或者实例对象的注册。如果我们没有调用ControllerBuilder的SetControllerFactory方法对象ControllerFactory类型或者实例显示注册，系统会使用默认的ControllerFactory来完成对Controller对象的解析，这个对象就是DefaultControllerFactory类型，该类型的实现正好反映了ASP.NET MVC框架对Controller实例的激活采取的默认策略。今天我们就看看DefaultControllerFactory类型是如何把Controller对象激活的，这也是Controller激活系统的默认实现，我们可以扩展ControllerFactory类型，实现自定义的Controller激活策略。

我把代码流程写一下，在MvcHandler类型里面有两个方法，一个方法是：BeginProcessRequest（HttpContextBase httpContext,AsyncCallback callback,object state），该方法用于对请求进行处理；第二个方法是：ProcessRequestInit(HttpContextbase httpContext,out IController controller,out IControllerFactory controllerFactory)，该方法就是定义了激活Controller算法的骨架，上代码吧，代码最无二意，我们先看BeginProcessRequest的代码：

 1     protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
 2     {
 3         IController controller;
 4         IControllerFactory factory;
 5         this.ProcessRequestInit(httpContext, out controller, out factory);
 6         IAsyncController asyncController = controller as IAsyncController;
 7         if (asyncController != null)
 8         {
 9                 BeginInvokeDelegate<MvcHandler.ProcessRequestState> beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState, MvcHandler.ProcessRequestState innerState)
10             {
11                 IAsyncResult result;
12                 try
13                 {
14                     result = innerState.AsyncController.BeginExecute(innerState.RequestContext, asyncCallback, asyncState);
15                 }
16                 catch
17                 {
18                     innerState.ReleaseController();
19                     throw;
20                 }
21                 return result;
22             };
23                 EndInvokeVoidDelegate<MvcHandler.ProcessRequestState> endDelegate = delegate(IAsyncResult asyncResult, MvcHandler.ProcessRequestState innerState)
24             {
25                 try
26                 {
27                     innerState.AsyncController.EndExecute(asyncResult);
28                 }
29                 finally
30                 {
31                     innerState.ReleaseController();
32                 }
33             };
34             MvcHandler.ProcessRequestState invokeState = new MvcHandler.ProcessRequestState
35             {
36                 AsyncController = asyncController,
37                 Factory = factory,
38                 RequestContext = this.RequestContext
39             };
40             SynchronizationContext synchronizationContext = SynchronizationContextUtil.GetSynchronizationContext();
41             return AsyncResultWrapper.Begin<MvcHandler.ProcessRequestState>(callback, state, beginDelegate, endDelegate, invokeState, MvcHandler._processRequestTag, -1, synchronizationContext);
42         }
43         Action action = delegate
44         {
45             try
46             {
47                 controller.Execute(this.RequestContext);
48             }
49             finally
50             {
51                 factory.ReleaseController(controller);
52             }
53         };
54         return AsyncResultWrapper.BeginSynchronous(callback, state, action, MvcHandler._processRequestTag);
55     }

在这个方法里面根据解析出来的Controller的类型来执行，如果是异步的Controller那就异步执行，否则就同步执行。在该方法里面，第三行，标红色的方法就是定义解析和执行Controller的算法骨架，就是我们要贴代码的第二个方法ProcessRequestInit，源码如下：

 1     private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory)
 2     {
 3         HttpContext current = HttpContext.Current;
 4         if (current != null && ValidationUtility.IsValidationEnabled(current) == true)
 5         {
 6                 ValidationUtility.EnableDynamicValidation(current);
 7         }
 8         this.AddVersionHeader(httpContext);
 9         this.RemoveOptionalRoutingParameters();
10         string requiredString = this.RequestContext.RouteData.GetRequiredString("controller");
11         factory = this.ControllerBuilder.GetControllerFactory();
12         controller = factory.CreateController(this.RequestContext, requiredString);
13         if (controller == null)
14         {
15             throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, MvcResources.ControllerBuilder_FactoryReturnedNull, new object[]
16             {
17                 factory.GetType(),
18                 requiredString
19             }));
20         }
21     }

这个方法主要是获取ControllerFactory实例，根据获得的ControllerFactory对象激活Controller对象，红色标注的代码就是核心关键点。说明一点，这个方法只是定义了激活Controller算法的骨架，具体的实现在DefaultControllerFactory类型中。代码很简单，我相信大家看的清楚。

DefaultControllerFactory通过调用BuildManager的静态方法GetReferencedAssemblies获取到系统所使用到的所有程序集，然后针对每个程序集通过反射的方式获得所有实现了IController接口的类型，并保存起来。然后我们把Controller的名称和命名空间作为匹配条件去查找对应的Controller类型。当我们获得了符合标准的真是的Controller类型后，DefaultControllerFactory对象通过反射的方式创建Controller类型的实例对象。解析逻辑不复杂，但是代码不少。我把完整的源码贴出来，大家可以仔细体会一下。

  1 /// <summary>Represents the controller factory that is registered by default.</summary>
  2     public class DefaultControllerFactory : IControllerFactory
  3     {
  4         private class DefaultControllerActivator : IControllerActivator
  5         {
  6             private Func<IDependencyResolver> _resolverThunk;
  7 
  8             public DefaultControllerActivator() : this(null)
  9             {
 10             }
 11 
 12             public DefaultControllerActivator(IDependencyResolver resolver)
 13             {
 14                 if (resolver == null)
 15                 {
 16                     this._resolverThunk = (() => DependencyResolver.Current);
 17                     return;
 18                 }
 19                 this._resolverThunk = (() => resolver);
 20             }
 21 
 22             public IController Create(RequestContext requestContext, Type controllerType)
 23             {
 24                 IController result;
 25                 try
 26                 {
 27                     result = (IController)(this._resolverThunk().GetService(controllerType) ?? Activator.CreateInstance(controllerType));
 28                 }
 29                 catch (Exception innerException)
 30                 {
 31                     throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ErrorCreatingController, new object[]
 32                     {
 33                         controllerType
 34                     }), innerException);
 35                 }
 36                 return result;
 37             }
 38         }
 39 
 40         private static readonly ConcurrentDictionary<Type, SessionStateBehavior> _sessionStateCache = new ConcurrentDictionary<Type, SessionStateBehavior>();
 41 
 42         private static ControllerTypeCache _staticControllerTypeCache = new ControllerTypeCache();
 43 
 44         private IBuildManager _buildManager;
 45 
 46         private IResolver<IControllerActivator> _activatorResolver;
 47 
 48         private IControllerActivator _controllerActivator;
 49 
 50         private ControllerBuilder _controllerBuilder;
 51 
 52         private ControllerTypeCache _instanceControllerTypeCache;
 53 
 54         private IControllerActivator ControllerActivator
 55         {
 56             get
 57             {
 58                 if (this._controllerActivator != null)
 59                 {
 60                     return this._controllerActivator;
 61                 }
 62                 this._controllerActivator = this._activatorResolver.Current;
 63                 return this._controllerActivator;
 64             }
 65         }
 66 
 67         internal IBuildManager BuildManager
 68         {
 69             get
 70             {
 71                 if (this._buildManager == null)
 72                 {
 73                     this._buildManager = new BuildManagerWrapper();
 74                 }
 75                 return this._buildManager;
 76             }
 77             set
 78             {
 79                 this._buildManager = value;
 80             }
 81         }
 82 
 83         internal ControllerBuilder ControllerBuilder
 84         {
 85             get
 86             {
 87                 return this._controllerBuilder ?? ControllerBuilder.Current;
 88             }
 89             set
 90             {
 91                 this._controllerBuilder = value;
 92             }
 93         }
 94 
 95         internal ControllerTypeCache ControllerTypeCache
 96         {
 97             get
 98             {
 99                 return this._instanceControllerTypeCache ?? DefaultControllerFactory._staticControllerTypeCache;
100             }
101             set
102             {
103                 this._instanceControllerTypeCache = value;
104             }
105         }
106 
107         /// <summary>Initializes a new instance of the <see cref="T:System.Web.Mvc.DefaultControllerFactory" /> class.</summary>
108         public DefaultControllerFactory() : this(null, null, null)
109         {
110         }
111 
112         /// <summary>Initializes a new instance of the <see cref="T:System.Web.Mvc.DefaultControllerFactory" /> class using a controller activator.</summary>
113         /// <param name="controllerActivator">An object that implements the controller activator interface.</param>
114         public DefaultControllerFactory(IControllerActivator controllerActivator) : this(controllerActivator, null, null)
115         {
116         }
117 
118         internal DefaultControllerFactory(IControllerActivator controllerActivator, IResolver<IControllerActivator> activatorResolver, IDependencyResolver dependencyResolver)
119         {
120             if (controllerActivator != null)
121             {
122                 this._controllerActivator = controllerActivator;
123                 return;
124             }
125             IResolver<IControllerActivator> arg_44_1 = activatorResolver;
126             if (activatorResolver == null)
127             {
128                 arg_44_1 = new SingleServiceResolver<IControllerActivator>(() => null, new DefaultControllerFactory.DefaultControllerActivator(dependencyResolver), "DefaultControllerFactory constructor");
129             }
130             this._activatorResolver = arg_44_1;
131         }
132 
133         internal static InvalidOperationException CreateAmbiguousControllerException(RouteBase route, string controllerName, ICollection<Type> matchingTypes)
134         {
135             StringBuilder stringBuilder = new StringBuilder();
136             foreach (Type current in matchingTypes)
137             {
138                 stringBuilder.AppendLine();
139                 stringBuilder.Append(current.FullName);
140             }
141             Route route2 = route as Route;
142             string message;
143             if (route2 != null)
144             {
145                 message = string.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ControllerNameAmbiguous_WithRouteUrl, new object[]
146                 {
147                     controllerName,
148                     route2.Url,
149                     stringBuilder,
150                     Environment.NewLine
151                 });
152             }
153             else
154             {
155                 message = string.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ControllerNameAmbiguous_WithoutRouteUrl, new object[]
156                 {
157                     controllerName,
158                     stringBuilder,
159                     Environment.NewLine
160                 });
161             }
162             return new InvalidOperationException(message);
163         }
164 
165         private static InvalidOperationException CreateDirectRouteAmbiguousControllerException(ICollection<Type> matchingTypes)
166         {
167             StringBuilder stringBuilder = new StringBuilder();
168             foreach (Type current in matchingTypes)
169             {
170                 stringBuilder.AppendLine();
171                 stringBuilder.Append(current.FullName);
172             }
173             string message = string.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_DirectRouteAmbiguous, new object[]
174             {
175                 stringBuilder,
176                 Environment.NewLine
177             });
178             return new InvalidOperationException(message);
179         }
180 
181         /// <summary>Creates the specified controller by using the specified request context.</summary>
182         /// <returns>The controller.</returns>
183         /// <param name="requestContext">The context of the HTTP request, which includes the HTTP context and route data.</param>
184         /// <param name="controllerName">The name of the controller.</param>
185         /// <exception cref="T:System.ArgumentNullException">The <paramref name="requestContext" /> parameter is null.</exception>
186         /// <exception cref="T:System.ArgumentException">The <paramref name="controllerName" /> parameter is null or empty.</exception>
187         public virtual IController CreateController(RequestContext requestContext, string controllerName)
188         {
189             if (requestContext == null)
190             {
191                 throw new ArgumentNullException("requestContext");
192             }
193             if (string.IsNullOrEmpty(controllerName) && !requestContext.RouteData.HasDirectRouteMatch())
194             {
195                 throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
196             }
197             Type controllerType = this.GetControllerType(requestContext, controllerName);
198             return this.GetControllerInstance(requestContext, controllerType);
199         }
200 
201         /// <summary>Retrieves the controller instance for the specified request context and controller type.</summary>
202         /// <returns>The controller instance.</returns>
203         /// <param name="requestContext">The context of the HTTP request, which includes the HTTP context and route data.</param>
204         /// <param name="controllerType">The type of the controller.</param>
205         /// <exception cref="T:System.Web.HttpException">
206         ///   <paramref name="controllerType" /> is null.</exception>
207         /// <exception cref="T:System.ArgumentException">
208         ///   <paramref name="controllerType" /> cannot be assigned.</exception>
209         /// <exception cref="T:System.InvalidOperationException">An instance of <paramref name="controllerType" /> cannot be created.</exception>
210         protected internal virtual IController GetControllerInstance(RequestContext requestContext, Type controllerType)
211         {
212             if (controllerType == null)
213             {
214                 throw new HttpException(404, string.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_NoControllerFound, new object[]
215                 {
216                     requestContext.HttpContext.Request.Path
217                 }));
218             }
219             if (!typeof(IController).IsAssignableFrom(controllerType))
220             {
221                 throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_TypeDoesNotSubclassControllerBase, new object[]
222                 {
223                     controllerType
224                 }), "controllerType");
225             }
226             return this.ControllerActivator.Create(requestContext, controllerType);
227         }
228 
229         /// <summary>Returns the controller‘s session behavior.</summary>
230         /// <returns>The controller‘s session behavior.</returns>
231         /// <param name="requestContext">The request context.</param>
232         /// <param name="controllerType">The type of the controller.</param>
233         protected internal virtual SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, Type controllerType)
234         {
235             if (controllerType == null)
236             {
237                 return SessionStateBehavior.Default;
238             }
239             return DefaultControllerFactory._sessionStateCache.GetOrAdd(controllerType, delegate(Type type)
240             {
241                 SessionStateAttribute sessionStateAttribute = type.GetCustomAttributes(typeof(SessionStateAttribute), true).OfType<SessionStateAttribute>().FirstOrDefault<SessionStateAttribute>();
242                 if (sessionStateAttribute == null)
243                 {
244                     return SessionStateBehavior.Default;
245                 }
246                 return sessionStateAttribute.Behavior;
247             });
248         }
249 
250         /// <summary>Retrieves the controller type for the specified name and request context.</summary>
251         /// <returns>The controller type.</returns>
252         /// <param name="requestContext">The context of the HTTP request, which includes the HTTP context and route data.</param>
253         /// <param name="controllerName">The name of the controller.</param>
254         protected internal virtual Type GetControllerType(RequestContext requestContext, string controllerName)
255         {
256             if (requestContext == null)
257             {
258                 throw new ArgumentNullException("requestContext");
259             }
260             if (string.IsNullOrEmpty(controllerName) && (requestContext.RouteData == null || !requestContext.RouteData.HasDirectRouteMatch()))
261             {
262                 throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
263             }
264             RouteData routeData = requestContext.RouteData;
265             if (routeData != null && routeData.HasDirectRouteMatch())
266             {
267                 return DefaultControllerFactory.GetControllerTypeFromDirectRoute(routeData);
268             }
269             object obj;
270             if (routeData.DataTokens.TryGetValue("Namespaces", out obj))
271             {
272                 IEnumerable<string> enumerable = obj as IEnumerable<string>;
273                 if (enumerable != null && enumerable.Any<string>())
274                 {
275                     HashSet<string> namespaces = new HashSet<string>(enumerable, StringComparer.OrdinalIgnoreCase);
276                     Type controllerTypeWithinNamespaces = this.GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaces);
277                     if (controllerTypeWithinNamespaces != null || false.Equals(routeData.DataTokens["UseNamespaceFallback"]))
278                     {
279                         return controllerTypeWithinNamespaces;
280                     }
281                 }
282             }
283             if (this.ControllerBuilder.DefaultNamespaces.Count > 0)
284             {
285                 HashSet<string> namespaces2 = new HashSet<string>(this.ControllerBuilder.DefaultNamespaces, StringComparer.OrdinalIgnoreCase);
286                 Type controllerTypeWithinNamespaces = this.GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaces2);
287                 if (controllerTypeWithinNamespaces != null)
288                 {
289                     return controllerTypeWithinNamespaces;
290                 }
291             }
292             return this.GetControllerTypeWithinNamespaces(routeData.Route, controllerName, null);
293         }
294 
295         private static Type GetControllerTypeFromDirectRoute(RouteData routeData)
296         {
297             IEnumerable<RouteData> directRouteMatches = routeData.GetDirectRouteMatches();
298             List<Type> list = new List<Type>();
299             foreach (RouteData current in directRouteMatches)
300             {
301                 if (current != null)
302                 {
303                     Type targetControllerType = current.GetTargetControllerType();
304                     if (targetControllerType == null)
305                     {
306                         throw new InvalidOperationException(MvcResources.DirectRoute_MissingControllerType);
307                     }
308                     if (!list.Contains(targetControllerType))
309                     {
310                         list.Add(targetControllerType);
311                     }
312                 }
313             }
314             if (list.Count == 0)
315             {
316                 return null;
317             }
318             if (list.Count == 1)
319             {
320                 return list[0];
321             }
322             throw DefaultControllerFactory.CreateDirectRouteAmbiguousControllerException(list);
323         }
324 
325         private Type GetControllerTypeWithinNamespaces(RouteBase route, string controllerName, HashSet<string> namespaces)
326         {
327             this.ControllerTypeCache.EnsureInitialized(this.BuildManager);
328             ICollection<Type> controllerTypes = this.ControllerTypeCache.GetControllerTypes(controllerName, namespaces);
329             switch (controllerTypes.Count)
330             {
331             case 0:
332                 return null;
333             case 1:
334                 return controllerTypes.First<Type>();
335             default:
336                 throw DefaultControllerFactory.CreateAmbiguousControllerException(route, controllerName, controllerTypes);
337             }
338         }
339 
340         /// <summary>Releases the specified controller.</summary>
341         /// <param name="controller">The controller to release.</param>
342         public virtual void ReleaseController(IController controller)
343         {
344             IDisposable disposable = controller as IDisposable;
345             if (disposable != null)
346             {
347                 disposable.Dispose();
348             }
349         }
350 
351         internal IReadOnlyList<Type> GetControllerTypes()
352         {
353             this.ControllerTypeCache.EnsureInitialized(this.BuildManager);
354             return this.ControllerTypeCache.GetControllerTypes();
355         }
356 
357         /// <summary>This API supports the ASP.NET MVC infrastructure and is not intended to be used directly from your code. This method calls the <see cref="M:System.Web.Mvc.DefaultControllerFactory.GetControllerSessionBehavior(System.Web.Routing.RequestContext,System.Type)" /> method.</summary>
358         /// <returns>The controller‘s session behavior.</returns>
359         /// <param name="requestContext">The request context.</param>
360         /// <param name="controllerName">The controller name.</param>
361         SessionStateBehavior IControllerFactory.GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
362         {
363             if (requestContext == null)
364             {
365                 throw new ArgumentNullException("requestContext");
366             }
367             if (string.IsNullOrEmpty(controllerName))
368             {
369                 throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
370             }
371             Type controllerType = this.GetControllerType(requestContext, controllerName);
372             return this.GetControllerSessionBehavior(requestContext, controllerType);
373         }
374     }

既然是ControllerFactory，DefaultControllerFactory肯定也实现了IControllerFactory接口，别的我们就不看了，我们看看是如何创建Controller对象的，方法代码如下：

 1 public virtual IController CreateController(RequestContext requestContext, string controllerName)
 2 {
 3     if (requestContext == null)
 4     {
 5         throw new ArgumentNullException("requestContext");
 6     }
 7     if (string.IsNullOrEmpty(controllerName) && !requestContext.RouteData.HasDirectRouteMatch())
 8     {
 9         throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
10     }
11     Type controllerType = this.GetControllerType(requestContext, controllerName);
12     return this.GetControllerInstance(requestContext, controllerType);
13 }

代码很简单，该方法获取Controller的Type类型对象，然后根据Type对象创建实例。这个方法里面有两个辅助方法，一个是GetControllerType方法，另一个是GetControllerInstance方法，根据名称我们就能知道是做什么的。我们先看看GetControllerType方法的源码吧，这里是关键，没有Type对象的获取，以后都是空言：　　

 1 protected internal virtual Type GetControllerType(RequestContext requestContext, string controllerName)
 2 {
 3     if (requestContext == null)
 4     {
 5         throw new ArgumentNullException("requestContext");
 6     }
 7     if (string.IsNullOrEmpty(controllerName) && (requestContext.RouteData == null || !requestContext.RouteData.HasDirectRouteMatch()))
 8     {
 9         throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
10     }
11     RouteData routeData = requestContext.RouteData;
12     if (routeData != null && routeData.HasDirectRouteMatch())
13     {
14         return DefaultControllerFactory.GetControllerTypeFromDirectRoute(routeData);
15     }
16     object obj;
17     if (routeData.DataTokens.TryGetValue("Namespaces", out obj))
18     {
19         IEnumerable<string> enumerable = obj as IEnumerable<string>;
20         if (enumerable != null && enumerable.Any<string>())
21         {
22             HashSet<string> namespaces = new HashSet<string>(enumerable, StringComparer.OrdinalIgnoreCase);
23             Type controllerTypeWithinNamespaces = this.GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaces);
24             if (controllerTypeWithinNamespaces != null || false.Equals(routeData.DataTokens["UseNamespaceFallback"]))
25             {
26                 return controllerTypeWithinNamespaces;
27             }
28         }
29     }
30     if (this.ControllerBuilder.DefaultNamespaces.Count > 0)
31     {
32         HashSet<string> namespaces2 = new HashSet<string>(this.ControllerBuilder.DefaultNamespaces, StringComparer.OrdinalIgnoreCase);
33         Type controllerTypeWithinNamespaces = this.GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaces2);
34         if (controllerTypeWithinNamespaces != null)
35         {
36             return controllerTypeWithinNamespaces;
37         }
38     }
39     return this.GetControllerTypeWithinNamespaces(routeData.Route, controllerName, null);
40 }

我们先根据RouteData路由数据来获取Controller的类型对象，如果RouteData不为空，并且在RouteData的Values属性中包含Key为“MS_DirectRouteMatches”的值，那我们就据此获取Controller的类型对象，如果没找到就返回Null值，如果有一个值，就会作为Controller的Type类型值返回，如果多于一个就会抛出异常。如果RouteData不包含Key为“MS_DirectRouteMatches”的值，我们就根据RouteData对象中DataTokens属性Key为“Namespaces”来获取Controller的Type对象，同理，如果没找到就返回null，找到一个就直接返回，如果多余一个的话就抛出异常。

如果我们还是没找到怎么办呢？我们就要看看能不能使用后备命名空间，如果可以，就根据此命名空间来查找，我们从RouteData路由数据的DataTokens属性中查找是否包含有Key为“UseNamespaceFallback”的值，如果有，并且是False，就直接返回，结束查找，如果不包含Key为“UseNamepsaceFallback”的值或者该值为True，我们就可以根据ControllerBuilder的DefaultNamespaces属性表示后备命名空间查找Controller的类型，同理，没有找到就返回null，找到一个就作为结果值直接返回，如果多于一个那就要抛出异常了。

好了，大概的逻辑写完了，

三、扩展点

到了现在，Controller激活系统就写的差不多了，唯一还差一点的就是扩展点还没提。ASP.NET MVC号称几乎任何地方都可以扩展，Controller激活系统中肯定也包含着扩展点，下来我们一一详述。

四、小结

我们可以小结了，到此，Controler激活系统这个小节我就写完了。其实不是很复杂，大家在看的时候，刚开始别太关注代码的细节，先把握整个数据流向，或者叫请求脉络，把里面所涉及到的对象和关系都整理清楚了，然后再有针对性的去看涉及到的每个对象，不是画画图，不是画画，是画各个对象之间的关系图，图能画出来，说明你的心中就有了整体把握了。如果太关注细节，太关注某个类型的代码，也会很容易顾此失彼，因为我开始就是那样，总是看了后面忘记前面，请求的线路也不是很清楚。所以我们学习的时候也要有方法，方法对，学的就快，成就感就能很快产生。好了，说了这么多了，继续努力吧，希望我写的东西对大家有所帮助。

白话ASP.NET MVC之三：Controller是如何解析出来的

标签：amp 完整关系图 ext processes thunk str 目的查看

原文地址：http://www.cnblogs.com/PatrickLiu/p/7359206.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行