class/System.Web.Mvc/System.Web.Mvc/ReflectedActionDescriptor.cs

   1 /* ****************************************************************************
   2  *
   3  * Copyright (c) Microsoft Corporation. All rights reserved.
   4  *
   5  * This software is subject to the Microsoft Public License (Ms-PL).
   6  * A copy of the license can be found in the license.htm file included
   7  * in this distribution.
   8  *
   9  * You must not remove this notice, or any other, from this software.
  10  *
  11  * ***************************************************************************/
  12
  13 namespace System.Web.Mvc {
  14     using System;
  15     using System.Collections.Generic;
  16     using System.Globalization;
  17     using System.Linq;
  18     using System.Reflection;
  19     using System.Web.Mvc.Resources;
  20
  21     public class ReflectedActionDescriptor : ActionDescriptor {
  22
  23         private readonly static ActionMethodDispatcherCache _staticDispatcherCache = new ActionMethodDispatcherCache();
  24         private ActionMethodDispatcherCache _instanceDispatcherCache;
  25
  26         private readonly string _actionName;
  27         private readonly ControllerDescriptor _controllerDescriptor;
  28         private ParameterDescriptor[] _parametersCache;
  29
  30         public ReflectedActionDescriptor(MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor)
  31             : this(methodInfo, actionName, controllerDescriptor, true /* validateMethod */) {
  32         }
  33
  34         internal ReflectedActionDescriptor(MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethod) {
  35             if (methodInfo == null) {
  36                 throw new ArgumentNullException("methodInfo");
  37             }
  38             if (String.IsNullOrEmpty(actionName)) {
  39                 throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
  40             }
  41             if (controllerDescriptor == null) {
  42                 throw new ArgumentNullException("controllerDescriptor");
  43             }
  44
  45             if (validateMethod) {
  46                 string failedMessage = VerifyActionMethodIsCallable(methodInfo);
  47                 if (failedMessage != null) {
  48                     throw new ArgumentException(failedMessage, "methodInfo");
  49                 }
  50             }
  51
  52             MethodInfo = methodInfo;
  53             _actionName = actionName;
  54             _controllerDescriptor = controllerDescriptor;
  55         }
  56
  57         public override string ActionName {
  58             get {
  59                 return _actionName;
  60             }
  61         }
  62
  63         public override ControllerDescriptor ControllerDescriptor {
  64             get {
  65                 return _controllerDescriptor;
  66             }
  67         }
  68
  69         internal ActionMethodDispatcherCache DispatcherCache {
  70             get {
  71                 if (_instanceDispatcherCache == null) {
  72                     _instanceDispatcherCache = _staticDispatcherCache;
  73                 }
  74                 return _instanceDispatcherCache;
  75             }
  76             set {
  77                 _instanceDispatcherCache = value;
  78             }
  79         }
  80
  81         public MethodInfo MethodInfo {
  82             get;
  83             private set;
  84         }
  85
  86         public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters) {
  87             if (controllerContext == null) {
  88                 throw new ArgumentNullException("controllerContext");
  89             }
  90             if (parameters == null) {
  91                 throw new ArgumentNullException("parameters");
  92             }
  93
  94             ParameterInfo[] parameterInfos = MethodInfo.GetParameters();
  95             var rawParameterValues = from parameterInfo in parameterInfos
  96                                      select ExtractParameterFromDictionary(parameterInfo, parameters, MethodInfo);
  97             object[] parametersArray = rawParameterValues.ToArray();
  98
  99             ActionMethodDispatcher dispatcher = DispatcherCache.GetDispatcher(MethodInfo);
 100             object actionReturnValue = dispatcher.Execute(controllerContext.Controller, parametersArray);
 101             return actionReturnValue;
 102         }
 103
 104         private static object ExtractParameterFromDictionary(ParameterInfo parameterInfo, IDictionary<string, object> parameters, MethodInfo methodInfo) {
 105             object value;
 106
 107             if (!parameters.TryGetValue(parameterInfo.Name, out value)) {
 108                 // the key should always be present, even if the parameter value is null
 109                 string message = String.Format(CultureInfo.CurrentUICulture, MvcResources.ReflectedActionDescriptor_ParameterNotInDictionary,
 110                     parameterInfo.Name, parameterInfo.ParameterType, methodInfo, methodInfo.DeclaringType);
 111                 throw new ArgumentException(message, "parameters");
 112             }
 113
 114             if (value == null && !TypeHelpers.TypeAllowsNullValue(parameterInfo.ParameterType)) {
 115                 // tried to pass a null value for a non-nullable parameter type
 116                 string message = String.Format(CultureInfo.CurrentUICulture, MvcResources.ReflectedActionDescriptor_ParameterCannotBeNull,
 117                     parameterInfo.Name, parameterInfo.ParameterType, methodInfo, methodInfo.DeclaringType);
 118                 throw new ArgumentException(message, "parameters");
 119             }
 120
 121             if (value != null && !parameterInfo.ParameterType.IsInstanceOfType(value)) {
 122                 // value was supplied but is not of the proper type
 123                 string message = String.Format(CultureInfo.CurrentUICulture, MvcResources.ReflectedActionDescriptor_ParameterValueHasWrongType,
 124                     parameterInfo.Name, methodInfo, methodInfo.DeclaringType, value.GetType(), parameterInfo.ParameterType);
 125                 throw new ArgumentException(message, "parameters");
 126             }
 127
 128             return value;
 129         }
 130
 131         public override object[] GetCustomAttributes(bool inherit) {
 132             return MethodInfo.GetCustomAttributes(inherit);
 133         }
 134
 135         public override object[] GetCustomAttributes(Type attributeType, bool inherit) {
 136             return MethodInfo.GetCustomAttributes(attributeType, inherit);
 137         }
 138
 139         public override FilterInfo GetFilters() {
 140             // Enumerable.OrderBy() is a stable sort, so this method preserves scope ordering.
 141             FilterAttribute[] typeFilters = (FilterAttribute[])MethodInfo.ReflectedType.GetCustomAttributes(typeof(FilterAttribute), true /* inherit */);
 142             FilterAttribute[] methodFilters = (FilterAttribute[])MethodInfo.GetCustomAttributes(typeof(FilterAttribute), true /* inherit */);
 143             List<FilterAttribute> orderedFilters = typeFilters.Concat(methodFilters).OrderBy(attr => attr.Order).ToList();
 144
 145             FilterInfo filterInfo = new FilterInfo();
 146             MergeFiltersIntoList(orderedFilters, filterInfo.ActionFilters);
 147             MergeFiltersIntoList(orderedFilters, filterInfo.AuthorizationFilters);
 148             MergeFiltersIntoList(orderedFilters, filterInfo.ExceptionFilters);
 149             MergeFiltersIntoList(orderedFilters, filterInfo.ResultFilters);
 150             return filterInfo;
 151         }
 152
 153         public override ParameterDescriptor[] GetParameters() {
 154             ParameterDescriptor[] parameters = LazilyFetchParametersCollection();
 155
 156             // need to clone array so that user modifications aren't accidentally stored
 157             return (ParameterDescriptor[])parameters.Clone();
 158         }
 159
 160         public override ICollection<ActionSelector> GetSelectors() {
 161             ActionMethodSelectorAttribute[] attrs = (ActionMethodSelectorAttribute[])MethodInfo.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true /* inherit */);
 162             ActionSelector[] selectors = Array.ConvertAll(attrs, attr => (ActionSelector)(controllerContext => attr.IsValidForRequest(controllerContext, MethodInfo)));
 163             return selectors;
 164         }
 165
 166         public override bool IsDefined(Type attributeType, bool inherit) {
 167             return MethodInfo.IsDefined(attributeType, inherit);
 168         }
 169
 170         private ParameterDescriptor[] LazilyFetchParametersCollection() {
 171             return DescriptorUtil.LazilyFetchOrCreateDescriptors<ParameterInfo, ParameterDescriptor>(
 172                 ref _parametersCache /* cacheLocation */,
 173                 MethodInfo.GetParameters /* initializer */,
 174                 parameterInfo => new ReflectedParameterDescriptor(parameterInfo, this) /* converter */);
 175         }
 176
 177         private static void MergeFiltersIntoList<TFilter>(IList<FilterAttribute> allFilters, IList<TFilter> destFilters) where TFilter : class {
 178             foreach (FilterAttribute filter in allFilters) {
 179                 TFilter castFilter = filter as TFilter;
 180                 if (castFilter != null) {
 181                     destFilters.Add(castFilter);
 182                 }
 183             }
 184         }
 185
 186         internal static ReflectedActionDescriptor TryCreateDescriptor(MethodInfo methodInfo, string name, ControllerDescriptor controllerDescriptor) {
 187             ReflectedActionDescriptor descriptor = new ReflectedActionDescriptor(methodInfo, name, controllerDescriptor, false /* validateMethod */);
 188             string failedMessage = VerifyActionMethodIsCallable(methodInfo);
 189             return (failedMessage == null) ? descriptor : null;
 190         }
 191
 192         private static string VerifyActionMethodIsCallable(MethodInfo methodInfo) {
 193             // we can't call instance methods where the 'this' parameter is a type other than ControllerBase
 194             if (!methodInfo.IsStatic && !typeof(ControllerBase).IsAssignableFrom(methodInfo.ReflectedType)) {
 195                 return String.Format(CultureInfo.CurrentUICulture, MvcResources.ReflectedActionDescriptor_CannotCallInstanceMethodOnNonControllerType,
 196                     methodInfo, methodInfo.ReflectedType.FullName);
 197             }
 198
 199             // we can't call methods with open generic type parameters
 200             if (methodInfo.ContainsGenericParameters) {
 201                 return String.Format(CultureInfo.CurrentUICulture, MvcResources.ReflectedActionDescriptor_CannotCallOpenGenericMethods,
 202                     methodInfo, methodInfo.ReflectedType.FullName);
 203             }
 204
 205             // we can't call methods with ref/out parameters
 206             ParameterInfo[] parameterInfos = methodInfo.GetParameters();
 207             foreach (ParameterInfo parameterInfo in parameterInfos) {
 208                 if (parameterInfo.IsOut || parameterInfo.ParameterType.IsByRef) {
 209                     return String.Format(CultureInfo.CurrentUICulture, MvcResources.ReflectedActionDescriptor_CannotCallMethodsWithOutOrRefParameters,
 210                         methodInfo, methodInfo.ReflectedType.FullName, parameterInfo);
 211                 }
 212             }
 213
 214             // we can call this method
 215             return null;
 216         }
 217
 218     }
 219 }