一、概述
上篇博文《白话学习MVC(七)Action的执行一》介绍了ASP.NET MVC中Action的执行的简要流程，并且对TempData的运行机制进行了详细的分析，本篇来分析上一篇中遗留的【3-2、ActionInvoker.InvokeAction(ControllerContext, actionName)】部分的内容，其中包含了Action的执行、过滤器的执行、View的呈现(下节介绍)。
public abstract class Controller : ControllerBase, IActionFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter {protected override void ExecuteCore() { //获取上次处理过程中没有被使用的TempData PossiblyLoadTempData(); try { //从路由数据中获取请求的Action的名字 string actionName = RouteData.GetRequiredString("action"); if (!ActionInvoker.InvokeAction(ControllerContext, actionName)) { HandleUnknownAction(actionName); } } finally { //将TempData保存到Session中。等待之后将Session的key【__ControllerTempData】发送到响应流中！ PossiblySaveTempData(); } } }
二、详细分析
概述中的红色字体部分，也就是我们上一节中遗留的代码段，它实现了Action的执行。现在我们就来通过MVC源代码分析此段代码所涉及的所有部分。
public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer { private IActionInvoker _actionInvoker; public IActionInvoker ActionInvoker { get { //ActionInvoker的InvokeAction方法就是执行Action的调用。 //可见，此处又有一个扩展点，设置自定义的ActionInvoker（即：在激活Controller后，执行该控制器实例的ActionInvoker属性，为属性赋值即可）。 if (_actionInvoker == null) { _actionInvoker = CreateActionInvoker(); } return _actionInvoker; } set { _actionInvoker = value; } } protected override void ExecuteCore() { PossiblyLoadTempData(); try { //从路由数据中获取请求的Action的名字（路由系统从请求地址中获取） string actionName = RouteData.GetRequiredString("action"); //ActionInvoker是Controller类中的一个属性，该属性默认返回的是一个AsyncControllerActionInvoker对象 if (!ActionInvoker.InvokeAction(ControllerContext, actionName)) { HandleUnknownAction(actionName); } } finally { PossiblySaveTempData(); } } protected virtual IActionInvoker CreateActionInvoker() {//对于Resolver，只能根据类型反射创建实例，接口和抽象类都是返回null，所以下面的代码返回的是一个AsyncControllerActionInvoker对象！（MVC3中是直接返回一个ControllerActionInvoker） //AsyncControllerActionInvoker不只是异步的，他还包括了同步。因为他继承自ControllerActionInvoker类，并实现了IAsyncActionInvoker接口。 //这里就有疑问了，既然接口和抽象类都不能创建实例且返回null，那为什么还以接口为参数呢？ return Resolver.GetService<IAsyncActionInvoker>() ?? Resolver.GetService<IActionInvoker>() ?? new AsyncControllerActionInvoker(); } }
上述代码中，红色字体部分中的ActionInvoker是Controller类的一个属性，该属性返回的是私有IActionInvoker类型的字段_actionInvoker的值，如果_actionInvoker不等于null，则返回字段_actionInvoker的值，否则创建一个 AsyncControllerAtionInvoker对象赋值给_actionInvoker字段并返回。所以，在我们没有设置自定义ActionInvoker时，默认这个ActionInvoker是一个AsyncControllerActonInvoker对象。即：执行AsyncControllerActonInvoker对象的InvokeAction方法来完成Action的执行！
扩展：此处我们可以创建一个自定义的ActionInvoker，然后使用自定义的ActionInvoker来实现Action的执行！
1、创建自定义一个ActionInvoker（实现IActionInvoker接口的类或者直接继承AsyncControllerActonInvoker类）。
2、创建好自定义的ActionInvoker之后，就需要将我们的ActionInvoker设置到系统中，就是通过请求的控制器HomeController的基类Controller的这个ActionInvoker属性来进行设置。所以，我们就需要在HomeController被激活时，直接执行该控制器实例的ActionInvoker属性来设置，而控制器的激活是在一个ControllerActivator的Create方法中完成的，ControllerActivator的选择又是ControllerFactory来做的！
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); RegisterGlobalFilters(GlobalFilters.Filters); RegisterRoutes(RouteTable.Routes); ControllerBuilder controllerBulder = ControllerBuilder.Current; controllerBulder.SetControllerFactory(new DefaultControllerFactory(new MyControllerActivator())); }
public class MyControllerActivator:IControllerActivator { public IController Create(System.Web.Routing.RequestContext requestContext, Type controllerType) { Controller con = (Controller)Activator.CreateInstance(controllerType); con.ActionInvoker = new MyActionInvoker(); return con; } }
public class MyActionInvoker : AsyncControllerActionInvoker { public override bool InvokeAction(System.Web.Mvc.ControllerContext controllerContext, string actionName) { //自己来实现Action的执行 } }
上面指出两部分内容，一、在默认情况下的ActionInvoker(AsyncControllerActonInvoker)；二、使用自定义ActionInvoker。我们所提到的ActionInvoker都是泛指实现了IActionInvoker接口的类，而上述两个中情况【默认ActionInvoker(AsyncControllerActonInvoker)】和【自定义ActionInvoker】便是实现了IActionInvoker接口，并实现了该接口中唯一的一个方法InvokeAction，而实现的这个方法中包含了对Action执行的所有操作，下面就来看看默认情况下ActionInvoker（AsyncControllerActonInvoker）的InvokeAction方法中是如何定义的！其实，自定义ActionInvoker的InvokeAction方法也是仿照AsyncControllerActonInvoker类来实现的。
public class AsyncControllerActionInvoker : ControllerActionInvoker, IAsyncActionInvoker { //调用父类ControllerActionInvoker中的InvokeAction方法 }
public class ControllerActionInvoker : IActionInvoker { public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { //ControllerDescriptor封装描述控制器的信息，如控制器的名称、类型和操作。 ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext); //FindAction方法：找到要执行的那么Action，并将该Action的相关信息封装在ActionDescriptor中。 ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName); if (actionDescriptor != null) { //GetFilters方法：获取应用在Action上的所有过滤器，并封装到一个FilterInfo对象中。 FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor); try { //Authorize授权过滤器需要实现IAuthorizationFilter接口，该接口有一个方法：OnAuthorization //循环执行应用在Actio上所有Authorize授权过滤器的OnAuthorization方法,定义如果不满足过滤器条件，则需要创建一个ActionResult复制给Result属性 //AuthorizeAttribute是MVC封装好的一个授权过滤器，从Cookie中获取信息，检查是否授权成功，可参考定义自己的授权管理器 AuthorizationContext authContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor); if (authContext.Result != null) { //没有通过Authorize授权过滤器，直接根据自定义的ActionResult进行View的呈现！
//View的呈现（下一节介绍） InvokeActionResult(controllerContext, authContext.Result); } else { //ValidateRequest,该值指示是否为此请求启用请求验证 //是否对请求必须验证，默认为true，该属性定义在ControllerBase类中 if (controllerContext.Controller.ValidateRequest) { //ValidateRequest应该是检查XSS威胁之类的，在模型绑定请求中获取值前进行处理。 ValidateRequest(controllerContext); } //获取Action方法参数的值（模型绑定） IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor); //执行【方法过滤器】(实现IActionFilter接口)并执行Action内代码 ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters); //执行【结果过滤器】(实现IResultFilter接口)，再做View的呈现。 InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, postActionContext.Result); } } catch (ThreadAbortException) { throw; } catch (Exception ex) { //执行异常过滤器 ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex); if (!exceptionContext.ExceptionHandled) { throw; }
//根据异常过滤器中定义的ActionResult进行View的呈现 InvokeActionResult(controllerContext, exceptionContext.Result); } return true; } // notify controller that no method matched return false; } }
上述代码中已添加了详细的注释，大致流程为：首先，根据【控制器信息】和【Action的Name】从被请求控制器的众多Action中找到要访问的Action，然后再执行应用在Action上的过滤器，最后根据ActionResult再进行View的呈现（下一节介绍）。
扩展：此处ControllerActionInvoker是MVC4中的，MVC5中新添加Authorizetion过滤器，并且这个过滤器的执行模式和Authorizetion过滤器是一样。对于Authentic过滤器，它需要实现IAuthenticationFilter接口，该接口中有两个方法：OnAuthentication和OnAuthenticationChallenge，执行顺序为：【Authentic过滤器的OnAuthentication方法】—>【Action过滤器的执行】—>【Action内代码的执行】—>【Authentic过滤器的OnAuthenticationChallenge方法】—>【Result过滤器的执行】—>【View的呈现】，所以就目前看来，通过这个过滤器也就可以在Action执行前且View呈现之前进行一些操作，从而可增强扩展性！
public class ControllerActionInvoker : IActionInvoker { public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { //ControllerDescriptor封装描述控制器的信息，如控制器的名称、类型和操作。 ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext); //FindAction方法：找到要执行的那么Action，并将其封装在ActionDescriptor中。 //ActionDescriptor提供有关操作方法的信息，如操作方法的名称、控制器、参数、特性和筛选器。 ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName); if (actionDescriptor != null) { //GetFilters方法：获取应用在Action上的所有过滤器，并封装到一个FilterInfo对象中。 FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor); try { //注意：Authentic过滤器需要实现IAuthenticationFilter接口，此接口有两个方法：OnAuthentication和OnAuthenticationChallenge //循环执行Action上应用的所有Authentic过滤器的OnAuthentication方法，判定未通过验证，则创建ActionResult对象给Result属性（以此来进行View的呈现）。 AuthenticationContext authenticationContext = InvokeAuthenticationFilters(controllerContext, filterInfo.AuthenticationFilters, actionDescriptor); //未通过Authentic过滤器的Onauthentication方法 if (authenticationContext.Result != null) { //循环执行所有Authentic过滤器的OnAuthenticationChallenge方法（可以是任何操作，例：对ActionResult进一步处理等） AuthenticationChallengeContext challengeContext = InvokeAuthenticationFiltersChallenge(controllerContext,filterInfo.AuthenticationFilters,AcionDescriptor,authenticationContext.Result); //根据自定义的ActionResult进行View的呈现（没有通过Authentic过滤器，不需再继续执行，直接返回结果） InvokeActionResult(controllerContext, challengeContext.Result ?? authenticationContext.Result); } //没有设置认证器或者认证成功 else { //Authorize授权过滤器需要实现IAuthorizationFilter接口，该接口有一个方法：OnAuthorization //循环执行应用在Actio上所有Authorize授权过滤器的OnAuthorization方法(AuthorizeAttribute是MVC封装好的一个授权过滤器，从Cookie中获取信息，检查是否授权成功，可参考定义自己的授权管理器) AuthorizationContext authorizationContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor); if (authorizationContext.Result != null) { //没有通过Authorization过滤器，即：OnAuthorization方法中不符合条件 //循环执行Authentica过滤器的OnAuthenticationChallenge方法（可以是任何操作，例：对ActionResult进一步处理）！ AuthenticationChallengeContext challengeContext = InvokeAuthenticationFiltersChallenge(controllerContext, filterInfo.AuthenticationFilters, actionDescriptor,authorizationContext.Result); //View的呈现 InvokeActionResult(controllerContext, challengeContext.Result ?? authorizationContext.Result); } //未设置Authorize过滤器或授权成功 else { //ValidateRequest,该值指示是否为此请求启用请求验证 //是否对请求必须验证，默认为true，该属性定义在ControllerBase类中 if (controllerContext.Controller.ValidateRequest) { //ValidateRequest应该是检查XSS威胁之类的，在模型绑定请求中获取值前进行处理。 ValidateRequest(controllerContext); } //获取Action参数的值（模型绑定） IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor); //执行【方法过滤器】(实现IActionFilter接口)并执行Action内代码 ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters); //再一次循环执行认证过滤器的OnAuthenticationChallenge方法（可以是任何操作，例：对ActionResult进一步处理）！ AuthenticationChallengeContext challengeContext = InvokeAuthenticationFiltersChallenge(controllerContext, filterInfo.AuthenticationFilters, actionDescriptor,postActionContext.Result); //执行【结果过滤器】(实现IResultFilter接口)，再做View的呈现。 InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters,challengeContext.Result ?? postActionContext.Result); } } } catch (ThreadAbortException) { throw; } catch (Exception ex) { ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex); if (!exceptionContext.ExceptionHandled) { throw; } InvokeActionResult(controllerContext, exceptionContext.Result); } return true; } return false; } }
InvokeAction方法解析
1、ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName);
在控制器HomeController对象的所有方法中，找到当前请求的Action（控制器对象的一个方法）。
public class ControllerActionInvoker : IActionInvoker { private static readonly ControllerDescriptorCache _staticDescriptorCache = new ControllerDescriptorCache(); private ControllerDescriptorCache _instanceDescriptorCache; internal ControllerDescriptorCache DescriptorCache { get { if (_instanceDescriptorCache == null) { _instanceDescriptorCache = _staticDescriptorCache; } return _instanceDescriptorCache; } set { _instanceDescriptorCache = value; } } public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { //ControllerDescriptor封装描述控制器的信息，如控制器的名称、类型和操作。 //此处是controllerDescriptor对象是ControllerDescriptor的派生类ReflectedControllerDescriptor的对象。 ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext); //FindAction方法：找到要执行的那么Action，并将该Action的相关信息封装在ActionDescriptor中。 ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName); //省略其他代码 } protected virtual ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext) { //获取Controller的类型 Type controllerType = controllerContext.Controller.GetType(); //DescriptorCache是本类的属性，是一个ControllerDescriptorCache实例。 //GetDescriptor方法的本质是根据controllerType去缓存中获取，如果没有的话，就执行委托(第二个参数)去创建，并做为返回值。再添加到缓存字典表中，以便下次利用。 //如下，没有缓存的情况下，就执行委托创建一个ReflectedControllerDescriptor对象。即：可以看出所有的ControllerDescriptor都是一个ReflectedControllerDescriptor。 ControllerDescriptor controllerDescriptor = DescriptorCache.GetDescriptor(controllerType, () => new ReflectedControllerDescriptor(controllerType)); //返回这个继承自ControllerDescriptor的ReflectedControllerDescriptor对象。 return controllerDescriptor; } protected virtual ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName) { //执行参数controllerDescriptor(ReflectedControllerDescriptor对象)的FindAction方法 ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName); return actionDescriptor; } }
public class ReflectedControllerDescriptor : ControllerDescriptor { private readonly Type _controllerType; private readonly ActionMethodSelector _selector; //构造函数 public ReflectedControllerDescriptor(Type controllerType) { if (controllerType == null) { throw new ArgumentNullException("controllerType"); } _controllerType = controllerType; _selector = new ActionMethodSelector(_controllerType); } public override ActionDescriptor FindAction(ControllerContext controllerContext, string actionName) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } if (String.IsNullOrEmpty(actionName)) { throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName"); } //_selector.FindActionMethod方法，先根据类型找到他的所有方法，然后根据方法名字再去匹配。 //_selector是在该类的构造函数中创建的ActionMethodSelector对象。 //获取指定的Action MethodInfo matched = _selector.FindActionMethod(controllerContext, actionName); if (matched == null) { return null; } //将找到的那个Action封装到一个ReflectedActionDescriptor对象（即：ActionDescriptor的派生类）中。 return new ReflectedActionDescriptor(matched, actionName, this); } }
internal sealed class ActionMethodSelector { //构造函数 public ActionMethodSelector(Type controllerType) { ControllerType = controllerType; //获取控制HomeController的所有方法 PopulateLookupTables(); } public Type ControllerType { get; private set; } public MethodInfo[] AliasedMethods { get; private set; } public ILookup<string, MethodInfo> NonAliasedMethods { get; private set; } private AmbiguousMatchException CreateAmbiguousMatchException(List<MethodInfo> ambiguousMethods, string actionName) { StringBuilder exceptionMessageBuilder = new StringBuilder(); foreach (MethodInfo methodInfo in ambiguousMethods) { string controllerAction = Convert.ToString(methodInfo, CultureInfo.CurrentCulture); string controllerType = methodInfo.DeclaringType.FullName; exceptionMessageBuilder.AppendLine(); exceptionMessageBuilder.AppendFormat(CultureInfo.CurrentCulture, MvcResources.ActionMethodSelector_AmbiguousMatchType, controllerAction, controllerType); } string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ActionMethodSelector_AmbiguousMatch, actionName, ControllerType.Name, exceptionMessageBuilder); return new AmbiguousMatchException(message); } public MethodInfo FindActionMethod(ControllerContext controllerContext, string actionName) { //对应用了ActionNameSelectorAttribute特性的Action方法集合处理，获取方法名字是actionName的所有Action方法。 List<MethodInfo> methodsMatchingName = GetMatchingAliasedMethods(controllerContext, actionName); //对没有应用ActionNameSelectorAttribute特性的Action方法集合处理，获取方法名字是actionName的所有方法，并添加集合尾部。 methodsMatchingName.AddRange(NonAliasedMethods[actionName]); //目前为止，methodsMatchingName集合中保存的是HomeController中Action方法的名字等于actionName的方法 //再做一次筛选和处理，处理Action方法上应用了NonAction、AcceptVerbs、HttpGet、HttpPost、HttpDelete、HttpPut特性情况 List<MethodInfo> finalMethods = RunSelectionFilters(controllerContext, methodsMatchingName); //只有符合条件的Action方法仅有一个时，才返回。（这就是为何，当我们定义两个方法名相同且参数不同且又都应用HttpGet特性时，会报错） switch (finalMethods.Count) { case 0: return null; case 1: return finalMethods[0]; default: throw CreateAmbiguousMatchException(finalMethods, actionName); } } internal List<MethodInfo> GetMatchingAliasedMethods(ControllerContext controllerContext, string actionName) { //有一个缓存，保存Action方法的ActionName特性。 //ReflectedAttributeCache.GetActionNameSelectorAttributes(methodInfo)根据methodInfo去缓存表中找，如果没有的话，就利用methodInfo的GetCustomAttributes方法去获取ActionName属性（一个ActionNameAttribute对象）。 //遍历所有应用了ActionName特性的方法，并筛选得到特性的名字=当前请求的action名称 //ActionNameAttribute的IsValidName方法,就是根据String.Equals(actionName, Name, StringComparison.OrdinalIgnoreCase)判断的 var methods = from methodInfo in AliasedMethods let attrs = ReflectedAttributeCache.GetActionNameSelectorAttributes(methodInfo) where attrs.All(attr => attr.IsValidName(controllerContext, actionName, methodInfo)) select methodInfo; return methods.ToList(); } private static bool IsMethodDecoratedWithAliasingAttribute(MethodInfo methodInfo) { //在派生类中重写时，指示是否 attributeType 的一个或多个实例应用于此成员。 //第二个参数：指定是否搜索该ActionNameSelectorAttribute的继承链以查找这些特性。 //返回如果 (ActionNameSelectorAttribute) 的一个或多个实例应用于此成员（包括特性基类），则为 true；否则为 false。 //也就是该Action上应用了ActionName特性来实现一个别名 return methodInfo.IsDefined(typeof(ActionNameSelectorAttribute), true /* inherit */); } private static bool IsValidActionMethod(MethodInfo methodInfo) { //获取定义在自定义的Controller（HomeController）中的方法。过滤掉Controller类中的方法和Controller类的基类中的方法。 //IsSpecialName表示方法是否具有特殊名称。（如果是HomeController中自己写得方法，则返回false，如果是Controller类或其基类中的方法时，返回true） //GetBaseDefinition方法得到该methodInfo被第一次定义的方法，（我们写的Action都是第一次定义在HomeControlelr中，如果在自定格的HomeController中重写基类中的方法，则这个GetBaseDefinition方法得到的就是第一次被创建的那个方法-可能是接口中定义的方法，） //DeclaringType属性获取该方法所在的类 //IsAssignableFrom(typeof(Controller)方法，检查是否该类型可以从Controller的实例分配。 //如果methodInfo.GetBaseDefinition().DeclaringType得到的 type类型 是Controller类或Controller的基类或Controller实现的接口，则返回true return !(methodInfo.IsSpecialName || methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(Controller))); } private void PopulateLookupTables() { //反射得到控制器HomeController的所有方法,包括继承自基类的所有方法 MethodInfo[] allMethods = ControllerType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public); //筛选，获取在控制器HomeController中创建的Action方法（依据：循环所有方法，方法是否可利用Controller类实例得到） MethodInfo[] actionMethods = Array.FindAll(allMethods, IsValidActionMethod); //筛选，获取HomeConroller中应用了ActionNameSelectorAttribute特性的Action方法。(ActionName特性的目的就是为Action设置一个别名) AliasedMethods = Array.FindAll(actionMethods, IsMethodDecoratedWithAliasingAttribute); //筛选，获取HomeController中除去应用了ActionName特性的方法之外的所有方法。（只要应用了ActionName特性的方法都不在这个集合内） NonAliasedMethods = actionMethods.Except(AliasedMethods).ToLookup(method => method.Name, StringComparer.OrdinalIgnoreCase); } private static List<MethodInfo> RunSelectionFilters(ControllerContext controllerContext, List<MethodInfo> methodInfos) { //局部变量，保存应用了NonAction、AcceptVerbs、HttpGet、HttpPost、HttpDelete、HttpPut特性的Action方法（也可以叫做选择特性） List<MethodInfo> matchesWithSelectionAttributes = new List<MethodInfo>(); ////局部变量，保存应用了NonAction、AcceptVerbs、HttpGet、HttpPost、HttpDelete、HttpPut特性的Action方法 List<MethodInfo> matchesWithoutSelectionAttributes = new List<MethodInfo>(); foreach (MethodInfo methodInfo in methodInfos) { //从缓存中根据methodInfo获取【选择特性】，如果缓存中没有的话，就主动去获取方法的所有特性中【选择特性】，并添加到缓存表中。 //ActionName特性类继承自ActionNameSelectorAttribute类 //NonAction、AcceptVerbs、HttpGet、HttpPost、HttpDelete、HttpPut特性类都继承自ActionMethodSelectorAttribute类。 ICollection<ActionMethodSelectorAttribute> attrs = ReflectedAttributeCache.GetActionMethodSelectorAttributes(methodInfo); if (attrs.Count == 0) { //如果Action方法上没有应用【选择特性】 matchesWithoutSelectionAttributes.Add(methodInfo); } //检查方法上定义的选择特性 是否 和客户端使用的 HTTP 数据传输方法一致 //调用应用在方法上的特性的IsValidForRequest方法。（只有那6个继承自ActionMethodSelectorAttribute类的特性，因为IsValidForRequest最开始是在此类中定义抽象方法） //对于NonAction特性，IsValidForRequest方法直接返回false //All方法：所有元素全部通过则返回true，否则返回false else if (attrs.All(attr => attr.IsValidForRequest(controllerContext, methodInfo))) { //特性通过验证，也就是和客户端使用的http数据传输方法一直 matchesWithSelectionAttributes.Add(methodInfo); } } //如果Action方法上存在应用了【选择特性】且又通过了验证，则返回应用了【选择特性】的Action方法集合， //当【选择特性】都未通过验证时，则返回没有应用【选择特性】的Action方法集合（即：Action上没有HttpGet、HttpPost等特性的方法） //此处说明了Action方法执行的优先级：应用了正确的HttpGet、HttpPost等特性的Action方法优先于未应用HttpGet、HttpPost等特性的Action方法 return (matchesWithSelectionAttributes.Count > 0) ? matchesWithSelectionAttributes : matchesWithoutSelectionAttributes; } } ActionMethodSelector
上述代码中，其实就是通过HomeController实例利用反射获取到所有的方法（包括父类中的方法），然后就是进行筛选，首先通过判断得到的方法是否是Controller类实例的方法，从而将HomeController父类中的方法过滤掉；之后再根据方法的名字来做判断，从而将方法名字不是请求的actionName的方法过滤掉；再之后判断应用在Action方法上的特性是否和客户端使用的 HTTP 数据传输方法一致，将不符合Http数据传输方法的Action过滤掉；再再之后，当符合条件的Action方法只有一个时，就将该Action方法返回，即：得到了指定的Action。最后将得到的Action方法封装到一个继承自ActionDescriptor类的ReflectedActionDescriptor对象中。
扩展：由上面介绍可知，其实对Action方法的查找和筛选都是在ActionMethodSelector中进行的，MVC5中的ActionMethodSelector虽然大体上流程是和MVC4相同的，但是具体实现上还是有点差异，有兴趣的可以看一下。
internal sealed class ActionMethodSelector { public ActionMethodSelector(Type controllerType) { ControllerType = controllerType; PopulateLookupTables(); } public Type ControllerType { get; private set; } public MethodInfo[] AliasedMethods { get; private set; } public ILookup<string, MethodInfo> NonAliasedMethods { get; private set; } private AmbiguousMatchException CreateAmbiguousMatchException(List<MethodInfo> ambiguousMethods, string actionName) { StringBuilder exceptionMessageBuilder = new StringBuilder(); foreach (MethodInfo methodInfo in ambiguousMethods) { string controllerAction = Convert.ToString(methodInfo, CultureInfo.CurrentCulture); string controllerType = methodInfo.DeclaringType.FullName; exceptionMessageBuilder.AppendLine(); exceptionMessageBuilder.AppendFormat(CultureInfo.CurrentCulture, MvcResources.ActionMethodSelector_AmbiguousMatchType, controllerAction, controllerType); } string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ActionMethodSelector_AmbiguousMatch, actionName, ControllerType.Name, exceptionMessageBuilder); return new AmbiguousMatchException(message); } public MethodInfo FindActionMethod(ControllerContext controllerContext, string actionName) { //断言，成功时什么也不做 Contract.Assert(controllerContext != null); if (controllerContext.RouteData != null) { //尼玛，RouteData的这个GetTargetActionMethod方法在那里呀？ MethodInfo target = controllerContext.RouteData.GetTargetActionMethod(); if (target != null) { // short circuit the selection process if a direct route was matched. return target; } } //得到所有满足要求的Action，（包括应用了ActionName特性和原Action的名字和请求的Action相同的） List<MethodInfo> finalMethods = FindActionMethods(controllerContext, actionName, AliasedMethods, NonAliasedMethods); //只有当HomeController中的Action有且只有一个满足请求的，才返回。所以，Controller中不允许Action重复（参数不同可以） switch (finalMethods.Count) { case 0: return null; //只有里面有一个合适的Action时才正确返回。 case 1: return finalMethods[0]; default: throw CreateAmbiguousMatchException(finalMethods, actionName); } } internal static List<MethodInfo> FindActionMethods(ControllerContext controllerContext, string actionName, MethodInfo[] aliasedMethods, ILookup<string, MethodInfo> nonAliasedMethods) { List<MethodInfo> matches = new List<MethodInfo>(); //遍历所有应用了ActionName属性的所有方法。 for (int i = 0; i < aliasedMethods.Length; i++) { MethodInfo method = aliasedMethods[i]; //IsMatchingAliasedMethod方法获取Action上应用的ActionName属性的值，并将该值和请求的Action相比较，如果一致则直接添加到列表。 if (IsMatchingAliasedMethod(method, controllerContext, actionName)) { matches.Add(method); } } matches.AddRange(nonAliasedMethods[actionName]);//将所有方法再添加到集合matches的末尾（最后获取Action的时候，是获取索引的第一个。这就是为什么ActionName特性优先于原Action的名字） //到现在为止，集合matches中剩下只有和请求的Action相同的 方法（包含Action、应用了ActionName才符合的Action、普通方法）了 RunSelectionFilters(controllerContext, matches);//筛选Controller中定义的所以方法，是否为Aciton，如果不是，则移除 return matches; } private static bool IsMatchingAliasedMethod(MethodInfo method, ControllerContext controllerContext, string actionName) { //又一个缓存，如果缓存表中没有的话，缓存着Action的ActionName特性(每个Action只能使用一个ActionName属性，这里为什么是个集合呢？不明白)。 //ReflectedAttributeCache.GetActionNameSelectorAttributes(method)根据method去缓存表中找，如果没有的话，就利用method的GetCustomAttributes方法去获取ActionName属性（一个ActionNameAttribute对象）。 //获取方法上应用了 继承了ActionNameSelectorAttribute 类的特性！ //只有ActionNameAttribute继承自ActionNameSelectorAttribute类 ReadOnlyCollection<ActionNameSelectorAttribute> attributes = ReflectedAttributeCache.GetActionNameSelectorAttributes(method); // Caching count is faster for ReadOnlyCollection int attributeCount = attributes.Count; //遍历每个ActionName属性，即ActionNameAttribute对象（在Action上应用该特性时就实例化了ActionNameAttribute，且构造函数的参数就是：Action上定义的Action的别名）。 for (int i = 0; i < attributeCount; i++) { //判断特性中设置别名和请求的Action是否一致。 //ActionNameSelectorAttribute是抽象类，ActionNameAttribute实现IsValidName方法,就是根据名字的String.Equals(actionName, Name, StringComparison.OrdinalIgnoreCase); if (!attributes[i].IsValidName(controllerContext, actionName, method)) { return false; } } return true; } private static bool IsValidMethodSelector(ReadOnlyCollection<ActionMethodSelectorAttribute> attributes, ControllerContext controllerContext, MethodInfo method) { int attributeCount = attributes.Count; Contract.Assert(attributeCount > 0); for (int i = 0; i < attributeCount; i++) { //调用应用在方法上的特性的IsValidForRequest方法。（只有那6个继承自ActionMethodSelectorAttribute类的特性，因为IsValidForRequest最开始是在此类中定义抽象方法） //NonAction特性，IsValidForRequest方法直接返回false，括号内就是true，整个方法返回 false //AcceptVerbs特性，应用时，AcceptVerbsAttribute构造函数传入的HttpVerbs类型(枚举，有Get、Post、Put、Delete、Head)的参数，并在构造函数内以此参数为参数又创建了一个HttpVerbsValidator实例，HttpVerbsValidator的构造函数中，将httpverbs参数存入到私有的集合变量中，而AcceptVerbs特性的IsValidForRequest方法，内部本质上执行的是HttpVerbsValidator实例的IsValidForRequest方法，这个方法就是检查 保存HttpVerbs的私有变量集合中 是否含有发来的请求的HttpVerbs //其实，AcceptVerbs特性和这些HttpGet、HttpPost、HttpPut、HttpDelete一样，只不过其多了一个Head，这个是什么呢？ //HttpGet特性，HttpGetAttribute继承自HttpVerbAttribut。执行HttpGetAttribute构造函数时，执行HttpVerbAttribut构造函数并直接给一个参数（HttpVerbs.HttpGet）,其构造函数内部也是创建一个参数为HttpGet的HttpVerbsValidator实例，之后同上... //HttpPost特性，和HttpGet一样，只不过传入的HttpVerbAttribut构造函数的参数为HttpVerbs.Post //HttpDelete特性，同上 //HttpPut特性，同上 //其实就是 检查方法上定义的特性 是否 和客户端使用的 HTTP 数据传输方法一致。 //如果一致，则返回 true，括号内为false，整个方法返回true //如果不一致，则返回 false，括号内为true，整个方法返回false if (!attributes[i].IsValidForRequest(controllerContext, method)) { return false; } } return true; } private static bool IsMethodDecoratedWithAliasingAttribute(MethodInfo methodInfo) { //在派生类中重写时，指示是否 attributeType 的一个或多个实例应用于此成员。 //第二个参数：指定是否搜索该ActionNameSelectorAttribute的继承链以查找这些特性。 //返回如果 (ActionNameSelectorAttribute) 的一个或多个实例应用于此成员（包括特性基类），则为 true；否则为 false。 //也就是该Action上应用了ActionName特性来实现一个别名 return methodInfo.IsDefined(typeof(ActionNameSelectorAttribute), true /* inherit */); } //获取定义在自定义的Controller（HomeController）中的方法。过滤掉Controller类中的方法和Controller类的基类中的方法。 private static bool IsValidActionMethod(MethodInfo methodInfo) { //IsSpecialName表示方法是否具有特殊名称。（如果是HomeController中自己写得方法，则返回false，如果是Controller类或其基类中的方法时，返回true） //GetBaseDefinition方法得到该methodInfo被第一次定义的方法，（我们写的Action都是第一次定义在HomeControlelr中，如果在自定格的HomeController中重写基类中的方法，则这个GetBaseDefinition方法得到的就是第一次被创建的那个方法-可能是接口中定义的方法，） //DeclaringType属性获取该方法所在的类 //IsAssignableFrom(typeof(Controller)方法，检查是否该类型可以从Controller的实例分配。 //如果methodInfo.GetBaseDefinition().DeclaringType得到的 type类型 是Controller类或Controller的基类或Controller实现的接口，则返回true return !(methodInfo.IsSpecialName || methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(Controller))); } private void PopulateLookupTables() { //根据类型反射所有方法，包括继承自基类的所有方法 MethodInfo[] allMethods = ControllerType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public); //筛选，得到自定义在Controller中添加的方法。 //Array的FindAll方法,第二个参数是一个委托 MethodInfo[] actionMethods = Array.FindAll(allMethods, IsValidActionMethod); //集合、筛选逻辑（委托） //筛选，获取应用了ActionNameSelectorAttribute特性的Action。ActionName特性的目的就是为Action设置一个别名 AliasedMethods = Array.FindAll(actionMethods, IsMethodDecoratedWithAliasingAttribute); //错误=筛选，获取所有的方法（不含别名，但是有有别名的Action的原名在内），并且根据方法名进行分组，且方法名不区分大小写。（Action名字相同，参数不同则分在一组） //正确=上述理解错误，这里获取的是除去了应用了ActionName特性的方法之外的所有方法。（只要应用了ActionName特性的方法都不在这个集合内） NonAliasedMethods = actionMethods.Except(AliasedMethods).ToLookup(method => method.Name, StringComparer.OrdinalIgnoreCase); } //最后的筛选 private static void RunSelectionFilters(ControllerContext controllerContext, List<MethodInfo> methodInfos) { //到现在为止，集合methodInfos中剩下只有和请求的Action相同的 方法（包含：原名符合的Action、应用了ActionName才符合的Action、普通方法）了 bool hasValidSelectionAttributes = false; //遍历目前符合条件的所有方法 for (int i = methodInfos.Count - 1; i >= 0; i--) { MethodInfo methodInfo = methodInfos[i]; //获取方法集合中，是Action的方法。 //如果应用了NonAction特性，attrs.Count=1； //如果应用了HttpPut特性，attrs.Count=1 //如果应用了HttpDelete特性，attrs.Count=1 //如果应用了HttpPost特性，attrs.Count=1 //如果应用了HttpGet特性，attrs.Count=1 //如果应用了ccetpVerbs特性，attrs.Count=1A //以上的特性如果共同应用在方法上，那么attrs.Count=2.3.4.5.6.7.8.9... //如果是应用了ActionName特性才符合的Action，这里attrs.Count=0。ActionName继承自ActionNameSelectorAttribute==== 我们称之为 名称特性 //只要没有应用以上特性，无论是定义的Action还是普通方法 均为：atters.count=0，即:符合要求 //其实就是获取方法上应用的所有特性（特性是ActionMethodSelectorAttribute类的派生类，我们称之为方法特性）。 //也只有以上6个特性继承自ActionMethodSelectorAttribute类。（只有ActionNameAttribute继承自ActionNameSelectorAttribute类） ReadOnlyCollection<ActionMethodSelectorAttribute> attrs = ReflectedAttributeCache.GetActionMethodSelectorAttributesCollection(methodInfo); //如果该方法上没有应用方法特性 if (attrs.Count == 0) { // case 1: this method does not have a MethodSelectionAttribute //第一次进来时hasValidSelectionAttributes是false，不做操作，故：没有应用NonAction特性的方法就通过了。 if (hasValidSelectionAttributes) { // if there is already method with a valid selection attribute, remove method without one methodInfos.RemoveAt(i); } } //其实就是 检查方法上定义的特性 是否 和客户端使用的 HTTP 数据传输方法一致。 //如果一致，则返回true //如果不一致，则返回false else if (IsValidMethodSelector(attrs, controllerContext, methodInfo)) { //客户端使用的Http数据传输方式和 定义在Action上的特性设置的一致 if (!hasValidSelectionAttributes) //第一次时，true 可进入 { //符合条件的Action集合中， //只有第一个进入到这里（应用了方法特性且Http传输方式一致）或不符合的已删除当前索引位于顶层，不符合i + 1 < methodInfos.Count //当前索引不位于集合的顶层（即：已经有符合条件的Action存在）， if (i + 1 < methodInfos.Count) { //猜测：是将当前索引上层的所有项都移除（即已经筛选出的符合的Action都移除--没有应用特性的）。 //猜想正确，此RemoveFrom是MVC写的一个List<T>的扩展方法，MVC源码的目录 .srcCommon 的CollectionExtensions.cs类中 methodInfos.RemoveFrom(i + 1); } //将这个标识设置为true。 //当下次循环的Action没有应用ActionMethodSelectorAttribute特性时，移除。=======所以，应用了ActionMethodSelectorAttribute特性的Action比没有应用的优先级要高！（例：定义两个Action，其中一个应用HttpGet，应用了的优先级高） //当下次循环的Action应用了ActionMethodSelectorAttribute特性，并且和客户端使用的传输方法一致。直接通过... 这就是当定义两个Action，都设置为HttpGet，就会出现：【对控制器类型“HomeController”的操作“Index”的当前请求在下列操作方法之间不明确:】 hasValidSelectionAttributes = true; } } //应用数据传输方法特性，但是请求和Action上设置的不一致。移除该Action else { methodInfos.RemoveAt(i); } } } }
2、FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);
获取应用在Action方法上的所有过滤器，并将封装到一个FilterInfo对象中。这些过滤器有：ActionFilter、AuthorizationFilter、ExceptionFilter、ResultFilter，另外在MVC5中又新添加了一个AuthenticationFilter过滤器。
public class ControllerActionInvoker : IActionInvoker { private static readonly ControllerDescriptorCache _staticDescriptorCache = new ControllerDescriptorCache(); //FilterProviders.Providers.GetFilters是有两个参数的方法，该方法就是去获取并筛选过滤器 //IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) private Func<ControllerContext, ActionDescriptor, IEnumerable<Filter>> _getFiltersThunk = FilterProviders.Providers.GetFilters; public ControllerActionInvoker() { } protected virtual FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { return new FilterInfo(_getFiltersThunk(controllerContext, actionDescriptor)); } public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext); ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName); if (actionDescriptor != null) { //过去应用在Action方法上的所有过滤器 FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor); //省略其他代码 } } }
public static class FilterProviders { //静态构造函数 static FilterProviders() { //FilterProviderCollection继承自Collection<IFilterProvider>类 //实例化FilterProviderCollection时，会先实例化其父类。Collection<IFilterProvider>实例化时，会创建一个List<IFilterProvider>对象items作为私有变量。 Providers = new FilterProviderCollection(); //Add方法定义在Collection<IFilterProvider>中，就是将参数添加到私有变量 items 中。 Providers.Add(GlobalFilters.Filters); //GlobalFilters.Filters属性的值其实就是 new GlobalFilterCollection(); Providers.Add(new FilterAttributeFilterProvider()); Providers.Add(new ControllerInstanceFilterProvider()); } public static FilterProviderCollection Providers { get; private set; } }
public class FilterProviderCollection : Collection<IFilterProvider> { private static FilterComparer _filterComparer = new FilterComparer(); private IResolver<IEnumerable<IFilterProvider>> _serviceResolver; public FilterProviderCollection() { //Items是父类Collection<IFilterProvider>中的一个属性，该属性得到已添加到该集合中的所有【过滤器】的【提供器】 //将【过滤器】的【提供器】集合和一个空的Objcect类型集合IEnumerable<object>连接并复制到MultiServiceResolver类中的一个字段中 //之后MultiServiceResolver对象的Current属性就是获取该集合 _serviceResolver = new MultiServiceResolver<IFilterProvider>(() => Items); } public FilterProviderCollection(IList<IFilterProvider> providers) : base(providers) { _serviceResolver = new MultiServiceResolver<IFilterProvider>(() => Items); } internal FilterProviderCollection(IResolver<IEnumerable<IFilterProvider>> serviceResolver, params IFilterProvider[] providers) : base(providers) { _serviceResolver = serviceResolver ?? new MultiServiceResolver<IFilterProvider>(() => Items); } private IEnumerable<IFilterProvider> CombinedItems { //获取【过滤器】的【提供器】集合 get { return _serviceResolver.Current; } } private static bool AllowMultiple(object filterInstance) { IMvcFilter mvcFilter = filterInstance as IMvcFilter; //过滤器没有直接或间接的实现IMvcFilter接口,FilterAttribute类实现了IMvcFilter接口，也就是说该过滤器是一个普通特性。 if (mvcFilter == null) { return true; } return mvcFilter.AllowMultiple; } public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } if (actionDescriptor == null) { throw new ArgumentNullException("actionDescriptor"); } //遍历【过滤器】的【提供器】，也就是在实例化FilterProviders时候添加的那 3 个对象 【GlobalFilters.Filters(也就是new GlobalFilterCollection())】、【new FilterAttributeFilterProvider()】、【new ControllerInstanceFilterProvider()】 //执行各【提供器】对象的GetFilters方法，获取相应的过滤器，并根据Scope值排序，最后将过滤器添加到combineFilters集合中 //全局过滤器：Global = 10 //Controller上应用的过滤器：Controller = 20, //Action上应用的过滤：Action=30 //其实，控制器本身也是一个过滤器：First=0 IEnumerable<Filter> combinedFilters = CombinedItems.SelectMany(fp => fp.GetFilters(controllerContext, actionDescriptor)) .OrderBy(filter => filter, _filterComparer); //移除重复的过滤器，允许重复的过滤器不做移除，即：应用了AllowMultiple=true的过滤器即使重复也不移除 //combinedFilters.Reverse()将集合次序倒转去执行移除，从而使得添加过滤器的位置不同优先级也不同。 //即：如果过滤器没有定义AllowMultiple属性，则只保留Scope值大的过滤器。 //如果定义AllowMultiple=true，那么就先执行Scope值小的，再执行Scope值大的过滤器。 return RemoveDuplicates(combinedFilters.Reverse()).Reverse(); } private IEnumerable<Filter> RemoveDuplicates(IEnumerable<Filter> filters) { HashSet<Type> visitedTypes = new HashSet<Type>(); //从后向前循环所有的过滤器 foreach (Filter filter in filters) { object filterInstance = filter.Instance; Type filterInstanceType = filterInstance.GetType(); //visitedTypes集合中不包含该过滤器 //AllowMultiple方法：该过滤器如果没有继承FilterAttribute类（该类实现了IMvcFilter接口），返回true；否则返回该过滤器的AllowMultiple属性（默认为false）。 //即：visitedTypes集合中不包含该过滤器，添加 // 使用过滤器时定义AllowMultiple属性为true时，添加 // 该过滤器没有实现IMvcFilter接口，则添加；指的是该特性不是MVC过滤器，即：应用的普通特性，而不是MVC过滤器 if (!visitedTypes.Contains(filterInstanceType) || AllowMultiple(filterInstance)) { yield return filter; visitedTypes.Add(filterInstanceType); } } } private class FilterComparer : IComparer<Filter> { public int Compare(Filter x, Filter y) { // Nulls always have to be less than non-nulls if (x == null && y == null) { return 0; } if (x == null) { return -1; } if (y == null) { return 1; } // Sort first by order... if (x.Order < y.Order) { return -1; } if (x.Order > y.Order) { return 1; } // ...then by scope if (x.Scope < y.Scope) { return -1; } if (x.Scope > y.Scope) { return 1; } return 0; } } }
internal class MultiServiceResolver<TService> : IResolver<IEnumerable<TService>> where TService : class { private Lazy<IEnumerable<TService>> _itemsFromService; private Func<IEnumerable<TService>> _itemsThunk; private Func<IDependencyResolver> _resolverThunk; //过滤器时TService=IFilterProvider public MultiServiceResolver(Func<IEnumerable<TService>> itemsThunk) { if (itemsThunk == null) { throw new ArgumentNullException("itemsThunk"); } _itemsThunk = itemsThunk; _resolverThunk = () => DependencyResolver.Current; //resolver.GetServices<TService>()方法是反射获取实例对象，此处内部执行的是 return Enumerable.Empty<object>(); 也就返回了一个空的Objcect类型集合IEnumerable<object> _itemsFromService = new Lazy<IEnumerable<TService>>(() => _resolverThunk().GetServices<TService>()); } internal MultiServiceResolver(Func<IEnumerable<TService>> itemsThunk, IDependencyResolver resolver) : this(itemsThunk) { if (resolver != null) { _resolverThunk = () => resolver; } } public IEnumerable<TService> Current { //Concat方法连接两个序列，是将 【空的IEnumerable<TService>集合】和【原来添加的过滤器提供器的集合】连接起来，并转换为数组类型。（其实还是【过滤器提供器的集合】） get { return _itemsFromService.Value.Concat(_itemsThunk()); } } }
public sealed class GlobalFilterCollection : IEnumerable<Filter>, IFilterProvider { private List<Filter> _filters = new List<Filter>(); public int Count { get { return _filters.Count; } } public void Add(object filter) { AddInternal(filter, order: null); } public void Add(object filter, int order) { AddInternal(filter, order); } private void AddInternal(object filter, int? order) { ValidateFilterInstance(filter); //将过滤器添加到集合中 _filters.Add(new Filter(filter, FilterScope.Global, order)); } public void Clear() { _filters.Clear(); } public bool Contains(object filter) { return _filters.Any(f => f.Instance == filter); } public IEnumerator<Filter> GetEnumerator() { return _filters.GetEnumerator(); } //这个的目的是，当将实现了IEnumerable接口的类型的对象 转换为IEnumerable接口才能执行该方法 //在GlobalFilterCollection中声明了一个只有将对象转换为指定类型IEnumerable才可以访问的方法！ IEnumerator IEnumerable.GetEnumerator() { return _filters.GetEnumerator(); } //IFilterProvider.GetFilters的目的是，只有将GlobalFilterCollection实例转换为IFilterProvider接口类型后才能执行该方法。 //在GlobalFilterCollection中声明了一个只有将对象转换为指定类型IFilterProvider才可以访问的方法！ IEnumerable<Filter> IFilterProvider.GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { //将本类的当前对象返回。 //因为这个类实现了IEnumerable<Filter>接口。也完成了迭代器的重写（上面的两个方法中_filters.GetEnumerator()），所以Foreach才能遍历_filters变量中的值。 return this; } public void Remove(object filter) { _filters.RemoveAll(f => f.Instance == filter); } private static void ValidateFilterInstance(object instance) { if (instance != null && !( instance is IActionFilter || instance is IAuthorizationFilter || instance is IExceptionFilter || instance is IResultFilter || instance is IAuthenticationFilter)) { throw new InvalidOperationException(MvcResources.GlobalFilterCollection_UnsupportedFilterInstance); } } }
public class FilterAttributeFilterProvider : IFilterProvider { //构造函数中设置为true private readonly bool _cacheAttributeInstances; public FilterAttributeFilterProvider() : this(true) { } public FilterAttributeFilterProvider(bool cacheAttributeInstances) { _cacheAttributeInstances = cacheAttributeInstances; } protected virtual IEnumerable<FilterAttribute> GetActionAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { //通过Action描述（封装了当前的Action的信息），获取应用在Action上的过滤器 return actionDescriptor.GetFilterAttributes(_cacheAttributeInstances); } protected virtual IEnumerable<FilterAttribute> GetControllerAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { //根据Action描述先获取Controller描述（封装了当前的Controller的信息）， return actionDescriptor.ControllerDescriptor.GetFilterAttributes(_cacheAttributeInstances); } //yield关键字，当遍历此方法GetFilters的返回值IEnumerable<Filter>时，只有循环到来时才执行一次return，延迟执行。（其实是实现每次循环值返回一个Filter对象。而不是一个Filter集合） public virtual IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { // Results are low in number in the common case so use yield return to avoid creating intermediate collections or nested enumerables if (controllerContext.Controller != null) { //遍历获取应用在Controller上的过滤器 //先执行GetControllerAttributes方法，获取所有应用在Controller上的过滤器。（直接全部得到） //然后根据过滤器创建Filter对象。 foreach (FilterAttribute attr in GetControllerAttributes(controllerContext, actionDescriptor)) { yield return new Filter(attr, FilterScope.Controller, order: null); } //遍历获取应用在Action上的过滤器 foreach (FilterAttribute attr in GetActionAttributes(controllerContext, actionDescriptor)) { yield return new Filter(attr, FilterScope.Action, order: null); } } } }
public class ControllerInstanceFilterProvider : IFilterProvider { public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { if (controllerContext.Controller != null) { // Use FilterScope.First and Order of Int32.MinValue to ensure controller instance methods always run first yield return new Filter(controllerContext.Controller, FilterScope.First, Int32.MinValue); } } }
public class FilterInfo { private List<IActionFilter> _actionFilters = new List<IActionFilter>(); private List<IAuthorizationFilter> _authorizationFilters = new List<IAuthorizationFilter>(); private List<IExceptionFilter> _exceptionFilters = new List<IExceptionFilter>(); private List<IResultFilter> _resultFilters = new List<IResultFilter>(); public FilterInfo() { } public FilterInfo(IEnumerable<Filter> filters) { // evaluate the 'filters' enumerable only once since the operation can be quite expensive var filterInstances = filters.Select(f => f.Instance).ToList(); _actionFilters.AddRange(filterInstances.OfType<IActionFilter>()); _authorizationFilters.AddRange(filterInstances.OfType<IAuthorizationFilter>()); _exceptionFilters.AddRange(filterInstances.OfType<IExceptionFilter>()); _resultFilters.AddRange(filterInstances.OfType<IResultFilter>()); } public IList<IActionFilter> ActionFilters { get { return _actionFilters; } } public IList<IAuthorizationFilter> AuthorizationFilters { get { return _authorizationFilters; } } public IList<IExceptionFilter> ExceptionFilters { get { return _exceptionFilters; } } public IList<IResultFilter> ResultFilters { get { return _resultFilters; } } }
上述代码中，实现了获取过滤器，而过滤器可以通过4种方式添加：1、Global.asax中的RegisterGlobalFilters方法，Scope=10；2、在控制器HomeController上以特性的方法添加，Scope=20；3、在Action上以特性的方式添加，Scope=30；4、控制器HomeController本身也是过滤器，它实现了各过滤器接口，Scope=0；
针对以上的4中添加方法，【1】直接通过GlobalFilterCollection集合来获取，应为GlobalFilterCollection实现了IEnumerable接口、【2】【3】通过FilterAttributeFilterProvider对象的GetFilters方法来获取、【4】通过ControllerInstanceFilterProvider对象的GetFilters方法来获取。
所以，整个流程为：遍历执行各【过滤器的提供器】的GetFilters方法，从而得到所有过滤器且过滤器按照Scope值从小到大排列，然后再从后向前执行来对不允许重复使用的过滤器进行去重（只保留Scope值大的过滤器），如果允许重复使用的话（AllowMutiple=true），表示允许重复使用该过滤器，则不执行去重。最终将得到的过滤器按照过滤器类型(按接口不同)分类封装到FilterInfo对象中。
更正：FilterProviderCollection类的AllowMultiple方法中【if(mvcFilter==null){true}】，也表示该过滤器为控制器本身。因为Controller类只实现了过滤器接口，而没有实现IMvcFilter接口或继承实现了IMvcFilter接口的类。
扩展：如有兴趣可以看一下MVC5中过获取过滤器代码
public class FilterProviderCollection : Collection<IFilterProvider> { private static FilterComparer _filterComparer = new FilterComparer(); private IFilterProvider[] _combinedItems; private IDependencyResolver _dependencyResolver; //先执行父类Collection<IFilterProvider>的无参数构造函数，创建一个私有变量来保存 【过滤器的提供器】 public FilterProviderCollection() { } public FilterProviderCollection(IList<IFilterProvider> providers) : base(providers) { } internal FilterProviderCollection(IList<IFilterProvider> list, IDependencyResolver dependencyResolver) : base(list) { _dependencyResolver = dependencyResolver; } //其实得到的是添加到该集合中的所有【过滤器】的【提供器】。 internal IFilterProvider[] CombinedItems { get { IFilterProvider[] combinedItems = _combinedItems; if (combinedItems == null) { //Items是父类Collection<IFilterProvider>中的一个属性，得到添加到该集合中的所有【过滤器】的【提供器】。 //通过GetCombined方法将 【一个空的IEnumerable<IFilterProvider>集合】 和 【原来的过滤器的提供器集合】连接，并转换为IFilterProvider数组类型，返回。 //这里的【一个空的IEnumerable<IFilterProvider>集合】是通过DefaultDependencyResolver的GetServices方法获取的。（原来定义这个的功能是反射创建实例，这里返回空的集合，可能是为下一个版本做扩展而留下的吧） combinedItems = MultiServiceResolver.GetCombined<IFilterProvider>(Items, _dependencyResolver); _combinedItems = combinedItems; } return combinedItems; } } private static bool AllowMultiple(object filterInstance) { IMvcFilter mvcFilter = filterInstance as IMvcFilter; if (mvcFilter == null) { return true; } return mvcFilter.AllowMultiple; } //获取筛选器 public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } if (actionDescriptor == null) { throw new ArgumentNullException("actionDescriptor"); } //得到所有的过滤器提供器。（实例化FilterProviders时候添加的那 3 个 【GlobalFilters.Filters(也就是new GlobalFilterCollection())】、【new FilterAttributeFilterProvider()】、【new ControllerInstanceFilterProvider()】） IFilterProvider[] providers = CombinedItems; List<Filter> filters = new List<Filter>(); for (int i = 0; i < providers.Length; i++) { //第一个是GlobalFilterCollection对象，其继承自IFilterProvider。（在Global.ascx文件的RegisterGlobalFilters方法中，添加过滤器到此过滤器提供器中） //第二个是FilterAttributeFilterProvider对象，也继承自IFilterProvider。 IFilterProvider provider = providers[i]; //第一个GlobalFilterCollection，GetFilters方法得到就是当前GlobalFilterCollection对象（它实现了IEnumerable，所以也是集合）。而foreach遍历的是该对象的变量_filters中的值，并将值添加到此方法中声明的局部变量filters中。到===第一个中设计两个知识点：迭代，接口点方法 //第二个FilterAttributeFilterProvider，GetFilters方法得的是Controller上应用的过滤器和Action上应用的过滤器 foreach (Filter filter in provider.GetFilters(controllerContext, actionDescriptor)) { filters.Add(filter); } } filters.Sort(_filterComparer); if (filters.Count > 1) { RemoveDuplicates(filters); } return filters; } private static void RemoveDuplicates(List<Filter> filters) { HashSet<Type> visitedTypes = new HashSet<Type>(); // Remove duplicates from the back forward for (int i = filters.Count - 1; i >= 0; i--) { Filter filter = filters[i]; object filterInstance = filter.Instance; Type filterInstanceType = filterInstance.GetType(); if (!visitedTypes.Contains(filterInstanceType) || AllowMultiple(filterInstance)) { visitedTypes.Add(filterInstanceType); } else { filters.RemoveAt(i); } } } protected override void ClearItems() { _combinedItems = null; base.ClearItems(); } protected override void InsertItem(int index, IFilterProvider item) { _combinedItems = null; base.InsertItem(index, item); } protected override void RemoveItem(int index) { _combinedItems = null; base.RemoveItem(index); } protected override void SetItem(int index, IFilterProvider item) { _combinedItems = null; base.SetItem(index, item); } private class FilterComparer : IComparer<Filter> { public int Compare(Filter x, Filter y) { // Nulls always have to be less than non-nulls if (x == null && y == null) { return 0; } if (x == null) { return -1; } if (y == null) { return 1; } // Sort first by order... if (x.Order < y.Order) { return -1; } if (x.Order > y.Order) { return 1; } // ...then by scope if (x.Scope < y.Scope) { return -1; } if (x.Scope > y.Scope) { return 1; } return 0; } } }
internal static class MultiServiceResolver { //过滤器时TService=IFilterProvider internal static TService[] GetCombined<TService>(IList<TService> items, IDependencyResolver resolver = null) where TService : class { if (resolver == null) { resolver = DependencyResolver.Current; } //resolver.GetServices<TService>()方法内部执行 return Enumerable.Empty<object>(); ，也就返回了一个空的Objcect类型集合IEnumerable<object> 。 IEnumerable<TService> services = resolver.GetServices<TService>(); //Concat方法连接两个序列，应该是将 【空的IEnumerable<TService>集合】和【原来添加的过滤器提供器的集合】连接起来，并转换为数组类型。（其实还是【过滤器提供器的集合】） return services.Concat(items).ToArray(); } }
3、AuthorizationContext authContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor);
执行Authorize授权过滤器，其实就是执过滤器的OnAuthorization方法。AuthorizeAttribute是一个MVC的授权过滤器，可参考定义自己的授权过滤器。授权过滤器本质上是去读取cookie，检查cookie中相应的值是否和授权过滤器中设置的一致（可以用来做登录之后才能访问某页面的功能）。
public class ControllerActionInvoker : IActionInvoker { public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext); ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName); if (actionDescriptor != null) { FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor); try { //执行Authorize过滤器 AuthorizationContext authContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor); if (authContext.Result != null) { //没有通过过滤器，按照自定义的ActionResult直接进行View的呈现 //View的呈现 InvokeActionResult(controllerContext, authContext.Result); } //省略其他代码 } return true; } return false; } protected virtual AuthorizationContext InvokeAuthorizationFilters(ControllerContext controllerContext, IList<IAuthorizationFilter> filters, ActionDescriptor actionDescriptor) { AuthorizationContext context = new AuthorizationContext(controllerContext, actionDescriptor); foreach (IAuthorizationFilter filter in filters) { //当没有通过Authorize过滤器时，OnAuthorization方法中会创建一个ActionResult对象并赋值给Result属性 filter.OnAuthorization(context); if (context.Result != null) { //如果有任意Authorize过滤器未通过，则跳出循环不再继续执行其他Authorize过滤器 break; } } return context; } }
上述代码中，遍历所有的Authorize授权过滤器并执行其OnAuthorization方法，在OnAuthorization方法中，如果请求不满足条件，则创建一个ActionResult对象并赋值给AuthorizationContext对象的Result属性，之后直接使用该ActionResult进行View的呈现。
在MVC中，AuthorizeAttribute是微软定义的一个授权过滤器，它的OnAuthorization方法中规定，如果不满足条件的话，就跳转到登录页面（在WebConfig文件中配置）。
4、IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor);
模型绑定，获取Action方法参数对象的实参。详细请看：白话学习MVC(六)模型绑定
5、ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters);
执行【方法过滤器】(实现IActionFilter接口)并执行Action方法内的代码
public class ControllerActionInvoker : IActionInvoker { public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext); ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName); if (actionDescriptor != null) { FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor); try { AuthorizationContext authContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor); if (authContext.Result != null) { InvokeActionResult(controllerContext, authContext.Result); } else { if (controllerContext.Controller.ValidateRequest) { ValidateRequest(controllerContext); } IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor); //执行【方法过滤器】(实现IActionFilter接口)并执行Action方法内的代码 ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters); InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, postActionContext.Result); } } catch (ThreadAbortException) { // This type of exception occurs as a result of Response.Redirect(), but we special-case so that // the filters don't see this as an error. throw; } catch (Exception ex) { // something blew up, so execute the exception filters ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex); if (!exceptionContext.ExceptionHandled) { throw; } InvokeActionResult(controllerContext, exceptionContext.Result); } return true; } // notify controller that no method matched return false; } protected virtual ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList<IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters) { ////创建Executing上下文，其中封装了请求上下文、当前Controller，当前Action，当前Action的参数 ActionExecutingContext preContext = new ActionExecutingContext(controllerContext, actionDescriptor, parameters); //将【Action内代码的执行】添加到委托中 Func<ActionExecutedContext> continuation = () => new ActionExecutedContext(controllerContext, actionDescriptor, false /* canceled */, null /* exception */) { //InvokeActionMethod执行Action方法内的代码，并返回方法的返回值。 Result = InvokeActionMethod(controllerContext, actionDescriptor, parameters) }; //------------------调炸天的一句代码------------------ //代码的实现是在InvokeActionMethodFilter方法中， //此句代码保证了在InvokeActionMethodFilter方法中，先循环执行所有的【方法过滤器】的ActionExecting方法,然后再执行Action方法内的代码，最后再循环执行所有的【方法过滤器】的ActionExected方法 Func<ActionExecutedContext> thunk = filters.Reverse().Aggregate(continuation, (next, filter) => () => InvokeActionMethodFilter(filter, preContext, next)); return thunk(); } //执行Action内的代码，并获取返回值！ protected virtual ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters) { //执行Action方法内的代码。 //actionDescriptor是一个ReflectedActionDescriptor对象 object returnValue = actionDescriptor.Execute(controllerContext, parameters); ActionResult result = CreateActionResult(controllerContext, actionDescriptor, returnValue); return result; } internal static ActionExecutedContext InvokeActionMethodFilter(IActionFilter filter, ActionExecutingContext preContext, Func<ActionExecutedContext> continuation) { //代码的实现是在InvokeActionMethodFilter方法中 //首先，循环执行应用在Action上的所有过滤器的ActionExecuting，如果没有通过，则按照定义在ActionExecuting方法中创建的ActionResult（Result=New ActionResult()）去执行view的呈现，不在继续执行！ //如果通过（则Result==null，默认），那么执行Action方法内的代码，并将Action方法的返回值设置给上下文对象的Result属性！ //如果Action内的方法的执行出现异常，那么不再去执行过滤器的ActionExecuted。否则，继续执行过滤器的ActionExecuted //执行ActionExecuted，参数为Action上下文（Result=Action方法内的返回值）。 //如果没有通过ActionExecuted，那么就更改上下文中的Result为自己定义的ActionReuslt，并设置到上下文中。 //返回这个上下文，view的呈现时，便使用这个ActionResult作为返回值。 //执行Action过滤器的ActionExecuting方法 filter.OnActionExecuting(preContext); //过滤器是否通过的判断为：是否在方法中定义了返回结果 if (preContext.Result != null) { //没有通过 return new ActionExecutedContext(preContext, preContext.ActionDescriptor, true /* canceled */, null /* exception */) { Result = preContext.Result }; } //通过了ActionExecuting bool wasError = false; ActionExecutedContext postContext = null; //以上代码循环所有的filter，全部执行一次！之后再继续执行... //执行Action方法内的代码 try { //执行InvokeActionMethodWithFilters方法中的continuation委托。==也就是执行Action方法内的代码 postContext = continuation(); } catch (ThreadAbortException) { // This type of exception occurs as a result of Response.Redirect(), but we special-case so that // the filters don't see this as an error. postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, false /* canceled */, null /* exception */); filter.OnActionExecuted(postContext); throw; } catch (Exception ex) { wasError = true; postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, false /* canceled */, ex); filter.OnActionExecuted(postContext); if (!postContext.ExceptionHandled) { throw; } } //循环执行所有的ActionExecuted //在循环所有的filter执行循环的时候return之前的！ if (!wasError) { filter.OnActionExecuted(postContext); } //最终返回 return postContext; } }
上述代码，首先循环执行所有Action过滤器的ActionExecuting方法，然后执行Action方法内的代码，最后再循环执行所有的Action过滤器的ActionExecuted方法。此过程的过滤器中，如果不满足过滤器的要求，则直接利用自定义的ActionResult对象进行View的呈现！
在执行Action方法内部代码时，那些返回值：return Content()、return View()、return Json()等，其实都是执行Controller类的方法，这些方法内创建继承自ActionResult类的ContentResult、ViewResult、JsonResult的对象并返回。
public abstract class Controller : ControllerBase, IActionFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer { //仅列举部分方法 protected internal FileContentResult File(byte[] fileContents, string contentType) { return File(fileContents, contentType, null /* fileDownloadName */); } protected internal virtual FileContentResult File(byte[] fileContents, string contentType, string fileDownloadName) { return new FileContentResult(fileContents, contentType) { FileDownloadName = fileDownloadName }; } protected internal FileStreamResult File(Stream fileStream, string contentType) { return File(fileStream, contentType, null /* fileDownloadName */); } protected internal virtual FileStreamResult File(Stream fileStream, string contentType, string fileDownloadName) { return new FileStreamResult(fileStream, contentType) { FileDownloadName = fileDownloadName }; } protected internal FilePathResult File(string fileName, string contentType) { return File(fileName, contentType, null /* fileDownloadName */); } protected internal virtual FilePathResult File(string fileName, string contentType, string fileDownloadName) { return new FilePathResult(fileName, contentType) { FileDownloadName = fileDownloadName }; } protected virtual void HandleUnknownAction(string actionName) { throw new HttpException(404, String.Format(CultureInfo.CurrentCulture, MvcResources.Controller_UnknownAction, actionName, GetType().FullName)); } protected internal HttpNotFoundResult HttpNotFound() { return HttpNotFound(null); } protected internal virtual HttpNotFoundResult HttpNotFound(string statusDescription) { return new HttpNotFoundResult(statusDescription); } protected internal virtual JavaScriptResult JavaScript(string script) { return new JavaScriptResult { Script = script }; } protected internal JsonResult Json(object data) { return Json(data, null /* contentType */, null /* contentEncoding */, JsonRequestBehavior.DenyGet); } protected internal JsonResult Json(object data, string contentType) { return Json(data, contentType, null /* contentEncoding */, JsonRequestBehavior.DenyGet); } protected internal virtual JsonResult Json(object data, string contentType, Encoding contentEncoding) { return Json(data, contentType, contentEncoding, JsonRequestBehavior.DenyGet); } protected internal JsonResult Json(object data, JsonRequestBehavior behavior) { return Json(data, null /* contentType */, null /* contentEncoding */, behavior); } protected internal JsonResult Json(object data, string contentType, JsonRequestBehavior behavior) { return Json(data, contentType, null /* contentEncoding */, behavior); } protected internal virtual JsonResult Json(object data, string contentType, Encoding contentEncoding, JsonRequestBehavior behavior) { return new JsonResult { Data = data, ContentType = contentType, ContentEncoding = contentEncoding, JsonRequestBehavior = behavior }; } }
补充：过滤器的ActionExecuting方法和ActionExecuted方法的执行是按照一条龙的顺序执行的。
此图摘自：http://www.cnblogs.com/artech/archive/2012/08/06/action-filter.html
重要：InvokeActionMethodWithFilters方法中的那句碉堡的代码实现了一条龙的方式去【OnActionExecuting】和【OnActionExecuted】方法，必须要好好学习下！！！
6、InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, postActionContext.Result);
执行【结果过滤器】(实现IResultFilter接口)，再做View的呈现。
public class ControllerActionInvoker : IActionInvoker { public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext); ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName); if (actionDescriptor != null) { FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor); try { AuthorizationContext authContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor); if (authContext.Result != null) { InvokeActionResult(controllerContext, authContext.Result); } else { if (controllerContext.Controller.ValidateRequest) { ValidateRequest(controllerContext); } IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor); ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters); //执行【结果过滤器】(实现IResultFilter接口)，再做View的呈现。（执行的模式和上一句代码的执行模式相同！） InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, postActionContext.Result); } } catch (ThreadAbortException) { // This type of exception occurs as a result of Response.Redirect(), but we special-case so that // the filters don't see this as an error. throw; } catch (Exception ex) { // something blew up, so execute the exception filters ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex); if (!exceptionContext.ExceptionHandled) { throw; } InvokeActionResult(controllerContext, exceptionContext.Result); } return true; } // notify controller that no method matched return false; } protected virtual ResultExecutedContext InvokeActionResultWithFilters(ControllerContext controllerContext, IList<IResultFilter> filters, ActionResult actionResult) { ResultExecutingContext preContext = new ResultExecutingContext(controllerContext, actionResult); //将View的呈现加入到委托链中 Func<ResultExecutedContext> continuation = delegate { //执行View的呈现 InvokeActionResult(controllerContext, actionResult); return new ResultExecutedContext(controllerContext, actionResult, false /* canceled */, null /* exception */); }; //先循环执行所有的Result过滤器的OnResultExecuting方法，然后执行View的呈现，再循环执行所有的Result过滤器的OnResultExecuted方法 //执行过滤器方法时候还是一条龙的方式 Func<ResultExecutedContext> thunk = filters.Reverse().Aggregate(continuation, (next, filter) => () => InvokeActionResultFilter(filter, preContext, next)); return thunk(); } internal static ResultExecutedContext InvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Func<ResultExecutedContext> continuation) { //循环执行所有的Result过滤器的OnResultExecuting方法 filter.OnResultExecuting(preContext); if (preContext.Cancel) { return new ResultExecutedContext(preContext, preContext.Result, true /* canceled */, null /* exception */); } bool wasError = false; ResultExecutedContext postContext = null; try { //执行委托，委托链中的InvokeActionResult方法进行View的呈现！ postContext = continuation(); } catch (ThreadAbortException) { // This type of exception occurs as a result of Response.Redirect(), but we special-case so that // the filters don't see this as an error. postContext = new ResultExecutedContext(preContext, preContext.Result, false /* canceled */, null /* exception */); filter.OnResultExecuted(postContext); throw; } catch (Exception ex) { wasError = true; postContext = new ResultExecutedContext(preContext, preContext.Result, false /* canceled */, ex); filter.OnResultExecuted(postContext); if (!postContext.ExceptionHandled) { throw; } } if (!wasError) { //循环执行所有的Result过滤器的OnResultExecuted方法 //扩展：由于过滤器的此方法是在View的呈现之后，所以可以利用Result过滤器的OnResultExecuted在此生成静态页 filter.OnResultExecuted(postContext); } return postContext; } }
上述代码中，先循环执行所有的Result过滤器的OnResultExecuting方法，然后执行View的呈现，再循环执行所有的Result过滤器的OnResultExecuted方法。执行流程也是一条龙的方方式！
以上所有就是Action执行的全部，如果不符之处，请指正！由以上的执行可知【View的呈现】是通过ControllerActionInvoker类的InvokeActionResult方法来实现的，下一篇就来详细分析View的呈现相关的知识！