private static bool IsSameAction(ActionDescriptor descriptor1, ActionDescriptor descriptor2)
{
ParameterDescriptor[] parameters1 = descriptor1.GetParameters();
ParameterDescriptor[] parameters2 = descriptor2.GetParameters();
bool same = descriptor1.ControllerDescriptor.ControllerName.Equals(descriptor2.ControllerDescriptor.ControllerName, StringComparison.OrdinalIgnoreCase) &&
descriptor1.ActionName.Equals(descriptor2.ActionName, StringComparison.OrdinalIgnoreCase) &&
(parameters1.Length == parameters2.Length);
if (same)
{
for (int i = parameters1.Length - 1; i >= 0; i--)
{
if (parameters1[i].ParameterType == parameters2[i].ParameterType)
{
continue;
}
same = false;
break;
}
}
return(same);
}
private bool HasAcceptableParameters(
ActionDescriptor actionDescriptor,
object model = null,
object message = null)
{
var parameters = actionDescriptor.GetParameters();
// Has either no parameters OR
if (!parameters.Any())
{
return(true);
}
// Has 1 parameter ...
if (parameters.Count() == 1 &&
( // ...that accepts either the Model or the Message (and we have a model or a message)
(model != null && parameters.First().ParameterType.IsAssignableFrom(model.GetType())) ||
(message != null && parameters.First().ParameterType.IsAssignableFrom(message.GetType()))))
{
return(true);
}
// Has 2 parameters ...
if (parameters.Count() == 2 && model != null && message != null &&
(( // ... where one accepts the Model and the other accepts the Message
parameters.First().ParameterType.IsAssignableFrom(model.GetType()) &&
parameters.Last().ParameterType.IsAssignableFrom(message.GetType())) ||
(parameters.Last().ParameterType.IsAssignableFrom(model.GetType()) &&
parameters.First().ParameterType.IsAssignableFrom(message.GetType()))))
{
return(true);
}
return(false);
}
public IEnumerable <System.Web.Mvc.Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
//if ((controllerContext.Controller is ProductController || controllerContext.Controller is ProductsController) &&
// actionDescriptor.ActionName.Equals("ProductList",
// StringComparison.InvariantCultureIgnoreCase))
if ((actionDescriptor.ControllerDescriptor.ControllerName == "Product" || actionDescriptor.ControllerDescriptor.ControllerName == "Products") &&
actionDescriptor.ActionName.Equals("ProductList", StringComparison.InvariantCultureIgnoreCase))
{
if (controllerContext.RouteData.Values["area"] != null &&
(controllerContext.RouteData.Values["area"].ToString() == "Admin" || controllerContext.RouteData.Values["area"].ToString() == "Vendor"))
{
//return new List<System.Web.Mvc.Filter>() { new System.Web.Mvc.Filter(this, FilterScope.Action, 0) };
}
}
if ((actionDescriptor.ControllerDescriptor.ControllerName == "Home") &&
actionDescriptor.ActionName.Equals("Index",
StringComparison.InvariantCultureIgnoreCase))
{
return(new List <System.Web.Mvc.Filter>()
{
new System.Web.Mvc.Filter(this, FilterScope.Action, 0)
});
}
var a = actionDescriptor.GetCustomAttributes(true);
var b = actionDescriptor.GetFilterAttributes(true);
var c = actionDescriptor.GetParameters();
return(new List <System.Web.Mvc.Filter>());
}
public bool IsSameAction(ActionDescriptor descriptor)
{
var desc = descriptor as ReflectedActionDescriptor;
if (desc != null)
{
bool sameAction = ActionDescriptor.MethodInfo == desc.MethodInfo;
if (sameAction)
{
return(true);
}
}
ParameterDescriptor[] parameters1 = descriptor.GetParameters();
bool same = descriptor.ControllerDescriptor.ControllerName.Equals(ActionDescriptor.ControllerDescriptor.ControllerName, StringComparison.OrdinalIgnoreCase) &&
descriptor.ActionName.Equals(ActionDescriptor.ActionName, StringComparison.OrdinalIgnoreCase) &&
(parameters1.Length == _actionParameterDescriptors.Length);
if (same)
{
for (int i = parameters1.Length - 1; i >= 0; i--)
{
if (parameters1[i].ParameterType == _actionParameterDescriptors[i].ParameterType)
{
continue;
}
same = false;
break;
}
}
return(same);
}
private IDictionary <string, object> GetMultiObjectsFormString(string input, ActionDescriptor action)
{
Dictionary <string, object> dict = jss.DeserializeObject(input) as Dictionary <string, object>;
//if( dict.Count != action.Parameters.Length )
// throw new ArgumentException("客户端提交的数据项与服务端的参数项的数量不匹配。");
var Parameters = action.GetParameters();
Dictionary <string, object> parameters = new Dictionary <string, object>(Parameters.Length);
for (int i = 0; i < Parameters.Length; i++)
{
var parameterDescriptor = Parameters[i];
string name = parameterDescriptor.ParameterName;
object value = (from kv in dict
where string.Compare(kv.Key, parameterDescriptor.BindingInfo.Prefix + name, StringComparison.OrdinalIgnoreCase) == 0
select kv.Value).FirstOrDefault();
if (value != null)
{
Type destType = parameterDescriptor.ParameterType.GetRealType();
MethodInfo method = s_methodConvertToType.MakeGenericMethod(destType);
object parameter = method.FastInvoke(jss, new object[] { PropertyFilter(value, parameterDescriptor) });
parameters[name] = parameter;
}
else
{
parameters[name] = parameterDescriptor.DefaultValue;
}
}
return(parameters);
}
private void Log(string methodName, ControllerDescriptor controllerDescriptor, ActionDescriptor actionDescriptor, IDictionary <string, object> actionParameters)
{
if (Execute)
{
var actionParametersToLog = new Dictionary <string, object>();
foreach (var parameter in actionDescriptor.GetParameters())
{
var attr = parameter.GetCustomAttributes(typeof(NoLogAttribute), false);
if (attr.Length == 0)
{
actionParametersToLog.Add(parameter.ParameterName, actionParameters[parameter.ParameterName]);
}
}
string parameters = string.Empty;
if (actionParametersToLog.Count > 0)
{
parameters = _jsonSerializer.Serialize(actionParametersToLog);
}
var message = String.Format("{0} controller:{1} action: {2} params:{3}", methodName, controllerDescriptor.ControllerName, actionDescriptor.ActionName, parameters);
_log.Debug(message);
}
}
protected override IDictionary <string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
ThriftActionResult context = ThriftActionResult.GetThriftResult(controllerContext.HttpContext);
//check if current request is thrift
if (context != null && context.GetParameterValues != null)
{
Dictionary <string, object> parameterDictionary = new Dictionary <string, object>();
context.GetParameterValues(context.Input, parameterDictionary);
context.Parameters = parameterDictionary;
Dictionary <string, object> MatchDict = new Dictionary <string, object>();
//ignore case
foreach (var pd in actionDescriptor.GetParameters())
{
string key = pd.ParameterName.ToLower();
if (parameterDictionary.ContainsKey(key))
{
MatchDict.Add(pd.ParameterName, parameterDictionary[key]);
}
}
return(MatchDict);
}
return(base.GetParameterValues(controllerContext, actionDescriptor));
}
public IEnumerable <object> GetParameterValues(ActionDescriptor actionDescriptor)
{
foreach (ParameterDescriptor parameterDescriptor in actionDescriptor.GetParameters())
{
string prefix = parameterDescriptor.BindingInfo.Prefix ?? parameterDescriptor.ParameterName;
yield return(GetParameterValue(parameterDescriptor, prefix));
}
}
/// <summary>
/// Gets the values of the action-method parameters.
/// </summary>
public virtual IDictionary <string, object> GetParameterValues()
{
var dictionary = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
foreach (var parameterDescriptor in ActionDescriptor.GetParameters())
{
dictionary[parameterDescriptor.ParameterName] = GetParameterValue(parameterDescriptor);
}
return(dictionary);
}
protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters)
{
var uowParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IUnitOfWork));
if (uowParam != null)
{
var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute <ConnectionKeyAttribute>();
if (connectionKey == null)
{
throw new ArgumentNullException("connectionKey");
}
using (var connection = SqlConnections.NewByKey(connectionKey.Value))
using (var uow = new UnitOfWork(connection))
{
parameters[uowParam.ParameterName] = uow;
var result = base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
uow.Commit();
return(result);
}
}
var cnnParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IDbConnection));
if (cnnParam != null)
{
var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute <ConnectionKeyAttribute>();
if (connectionKey == null)
{
throw new ArgumentNullException("connectionKey");
}
using (var cnn = SqlConnections.NewByKey(connectionKey.Value))
{
parameters[cnnParam.ParameterName] = cnn;
return(base.InvokeActionMethod(controllerContext, actionDescriptor, parameters));
}
}
return(base.InvokeActionMethod(controllerContext, actionDescriptor, parameters));
}
public ActionResult Index()
{
ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(typeof(HomeController));
ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(ControllerContext, "DemoAction");
Dictionary <ParameterDescriptor, IModelBinder> binders = new Dictionary <ParameterDescriptor, IModelBinder>();
foreach (ParameterDescriptor parameterDescriptor in actionDescriptor.GetParameters())
{
binders.Add(parameterDescriptor, this.GetModelBinder(parameterDescriptor));
}
return(View(binders));
}
protected virtual IDictionary <string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
Dictionary <string, object> parametersDict = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
ParameterDescriptor[] parameterDescriptors = actionDescriptor.GetParameters();
foreach (ParameterDescriptor parameterDescriptor in parameterDescriptors)
{
parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
}
return(parametersDict);
}
private string GetActionName(ActionDescriptor mvcActionDescriptor)
{
var sb = new StringBuilder(mvcActionDescriptor.ActionName + "(");
foreach (var parameter in mvcActionDescriptor.GetParameters())
{
sb.Append(parameter.ParameterType + " ");
sb.Append(parameter.ParameterName + ", ");
}
sb.Remove(sb.Length - 2, 2);
sb.Append(")");
return(sb.ToString());
}
private IDictionary <string, object> GetMultiObjectsFormRequest(HttpRequest request, ActionDescriptor action)
{
string xml = request.ReadInputStream();
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode root = doc.LastChild;
//if( root.ChildNodes.Count != action.Parameters.Length )
// throw new ArgumentException("客户端提交的数据项与服务端的参数项的数量不匹配。");
var Parameters = action.GetParameters();
Dictionary <string, object> parameters = new Dictionary <string, object>(Parameters.Length);
for (int i = 0; i < Parameters.Length; i++)
{
var parameterDescriptor = Parameters[i];
string name = parameterDescriptor.ParameterName;
XmlNode node = (from n in root.ChildNodes.Cast <XmlNode>()
where string.Compare(n.Name, parameterDescriptor.BindingInfo.Prefix + name, StringComparison.OrdinalIgnoreCase) == 0
select n).FirstOrDefault();
if (node != null)
{
object parameter = null;
Type destType = parameterDescriptor.ParameterType.GetRealType();
if (destType.IsSupportableType())
{
parameter = ModelHelper.SafeChangeType(node.InnerText, destType);
}
else
{
parameter = XmlDeserialize(node.OuterXml, destType, request.ContentEncoding);
}
if (parameter == null)
{
parameter = parameterDescriptor.DefaultValue;
}
parameters[name] = parameter;
}
}
return(parameters);
}
public IDictionary <string, object> GetParameters(HttpRequest request, ActionDescriptor action)
{
var Parameters = action.GetParameters();
if (Parameters.Length == 1)
{
object value = GetObjectFromRequest(request, Parameters[0].ParameterType.GetRealType());
return(new Dictionary <string, object> {
{ Parameters[0].ParameterName, value }
});
}
else
{
return(GetMultiObjectsFormRequest(request, action));
}
}
protected override IDictionary <string, object> GetParameterValues(ControllerContext controllerContext,
ActionDescriptor actionDescriptor)
{
if (controllerContext.RouteData.DataTokens.ContainsKey("IsXmlRpc") &&
(bool)controllerContext.RouteData.DataTokens["IsXmlRpc"])
{
IList <XmlRpcParameter> parameters =
controllerContext.RouteData.Values["parameters"] as IList <XmlRpcParameter>;
IDictionary <string, object> mappedParameters =
XmlRpcParameterMapper.Map(actionDescriptor.GetParameters(), parameters);
foreach (var mappedParameter in mappedParameters)
{
controllerContext.RouteData.Values.Add(mappedParameter.Key, mappedParameter.Value);
}
}
return(base.GetParameterValues(controllerContext, actionDescriptor));
}
//returns a method name like "Index(int id)" instead of "Index"
internal static string GetMethodNameWithParameters(this ActionDescriptor mvcActionDescriptor)
{
var sb = new StringBuilder(mvcActionDescriptor.ActionName + "(");
var parameters = mvcActionDescriptor.GetParameters();
foreach (var parameter in parameters)
{
sb.Append(parameter.ParameterType + " ");
sb.Append(parameter.ParameterName + ", ");
}
if (parameters.Length > 0)
{
sb.Remove(sb.Length - 2, 2);
}
sb.Append(")");
return(sb.ToString());
}
/// <summary>
/// 格式化Action的参数字符串
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public static string FormatParams(ActionDescriptor action)
{
var param = action.GetParameters();
var result = new StringBuilder();
if (param.Length > 0)
{
foreach (var item in param)
{
result.Append(string.Format("Type:{0}, Name:{1}; ", item.ParameterType, item.ParameterName));
}
return(result.ToString());
}
else
{
return(null);
}
}
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
ViewDataDictionary model = null;
// get our query parameter
var query = GetParameterValue(controllerContext, actionDescriptor.GetParameters().Where(x => x.ParameterName == "query").FirstOrDefault());
// pass the query to our mediator
if (query is DetailsQuery)
{
model = new ViewDataDictionary(this.mediator.Request((DetailsQuery)query));
}
// return the view with read model returned from mediator
return(new ViewResult
{
ViewName = actionDescriptor.ActionName,
ViewData = model
});
}
private static string GetSamplePath(RequestContext requestContext, ActionDescriptor action)
{
var urlHelper = new UrlHelper(requestContext);
var actionNameAttrib = action.GetCustomAttributes(inherit: true).OfType <ActionNameAttribute>().FirstOrDefault();
// This is tricky because some of the action parameters may not be meant to come from the route.
// e.g. they could come from a POST body.
// In that case, they may end up as bogus query string params on the path, which is a bit buggy
var routeValues = new RouteValueDictionary();
foreach (ParameterDescriptor param in action.GetParameters())
{
routeValues.Add(param.ParameterName, GetDefaultValue(param));
}
return(urlHelper.Action(
actionNameAttrib != null ? actionNameAttrib.Name : action.ActionName,
action.ControllerDescriptor.ControllerName.ToLowerInvariant(),
routeValues));
}
protected IEnumerable <ParameterDescriptor> FindActionParameters <T>(
ActionDescriptor actionDescriptor,
bool requireDefaultConstructor = true,
bool throwIfNotFound = true,
Func <ParameterDescriptor, bool> predicate = null)
{
Guard.NotNull(actionDescriptor, nameof(actionDescriptor));
var t = typeof(T);
var query = actionDescriptor
.GetParameters()
.Where(x => t.IsAssignableFrom(x.ParameterType));
if (predicate != null)
{
query = query.Where(predicate);
}
if (throwIfNotFound && !query.Any())
{
throw new InvalidOperationException(
$"A controller action method with a '{this.GetType().Name}' attribute requires an action parameter of type '{t.Name}' in order to execute properly.");
}
if (requireDefaultConstructor)
{
foreach (var param in query)
{
if (!param.ParameterType.HasDefaultConstructor())
{
throw new InvalidOperationException($"The parameter '{param.ParameterName}' must have a default parameterless constructor.");
}
}
}
return(query);
}
public static object InvokeAction(this Controller controller, string actionName)
{
IModelBinder modelBinder = new MyDefaultModelBinder();
ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controller.GetType());
ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controller.ControllerContext, actionName);
Dictionary <string, object> arguments = new Dictionary <string, object>();
foreach (ParameterDescriptor parameterDescriptor in actionDescriptor.GetParameters())
{
string modelName = parameterDescriptor.BindingInfo.Prefix ?? parameterDescriptor.ParameterName;
ModelBindingContext bindingContext = new ModelBindingContext
{
FallbackToEmptyPrefix = parameterDescriptor.BindingInfo.Prefix == null,
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, parameterDescriptor.ParameterType),
ModelName = modelName,
ModelState = controller.ModelState,
ValueProvider = controller.ValueProvider
};
object argument = modelBinder.BindModel(controller.ControllerContext, bindingContext);
arguments.Add(parameterDescriptor.ParameterName, argument);
}
return(actionDescriptor.Execute(controller.ControllerContext, arguments));
}
protected override IDictionary <string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var directRequest = controllerContext.HttpContext.Items[DirectRequest.DirectRequestKey] as DirectRequest;
var parametersDict = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
ParameterDescriptor[] parameterDescriptors = actionDescriptor.GetParameters();
if (directRequest == null)
{
throw new NullReferenceException(DirectResources.Common_DirectRequestIsNull);
}
if (!directRequest.IsFormPost && directRequest.Data != null)
{
controllerContext.Controller.ValueProvider = new DirectValueProvider(directRequest, parameterDescriptors);
}
foreach (ParameterDescriptor parameterDescriptor in parameterDescriptors)
{
parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
}
return(parametersDict);
}
public override RequestAnalysisResult GetRequestAnalysis(RequestAnalysisContext analysisContext)
{
RouteData routeData = analysisContext.RouteData;
RequestAnalysisResult analysisResult = new RequestAnalysisResult();
string controllerName = routeData.Values.TryGetValue("controller", out object controller) ? controller.ToString() : null;
analysisResult.ActionName = routeData.Values.TryGetValue("action", out object action) ? action.ToString() : null;
if (!string.IsNullOrEmpty(controllerName) && !string.IsNullOrEmpty(analysisResult.ActionName))
{
IControllerFactory controllerFactory = ControllerBuilder.Current.GetControllerFactory();
RequestContext requestContext = new RequestContext(new HttpContextWrapper(HttpContext.Current), routeData);
IController controllerInstance = controllerFactory.CreateController(requestContext, controllerName);
ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerInstance.GetType());
ControllerContext controllerContext = new ControllerContext(requestContext, controllerInstance as ControllerBase);
ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controllerContext, analysisResult.ActionName);
analysisResult.Url = HttpContext.Current.Request.Url.ToString();
analysisResult.Mode = Mode;
analysisResult.Values = routeData.Values;
analysisResult.DataTokens = routeData.DataTokens;
analysisResult.ControllerName = controllerDescriptor.ControllerType.FullName;
analysisResult.Parameters = actionDescriptor.GetParameters().Select(parameter => parameter.ParameterName).ToArray();
analysisResult.SupportedHttpMethods = actionDescriptor.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true)
.Select(methodAttribute => methodAttribute.GetType().Name.Replace("Attribute", "").Replace("Http", "")).ToArray();
analysisResult.SupportedHttpMethods = analysisResult.SupportedHttpMethods.Count() == 0
? new string[1] {
"All"
} : analysisResult.SupportedHttpMethods;
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, LookupPrefix);
analysisResult.FilePath = LookupFilePath(path, analysisResult.ControllerName);
}
return(analysisResult);
}
public override ParameterDescriptor[] GetParameters()
{
return(descriptor?.GetParameters() ?? new ParameterDescriptor[0]);
}
public override ParameterDescriptor[] GetParameters()
{
return(_internalDescriptor.GetParameters());
}
public IDictionary <string, object> GetParameters(HttpRequest request, ActionDescriptor action)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (action == null)
{
throw new ArgumentNullException("action");
}
ParameterDescriptor[] ActionParam = action.GetParameters();
IDictionary <string, object> parameters = new Dictionary <string, object>(ActionParam.Length);
for (int i = 0; i < ActionParam.Length; i++)
{
ParameterDescriptor p = ActionParam[i];
if (p.ParameterInfo.IsOut)
{
continue;
}
if (p.ParameterType == ReflectionHelper.VoidType)
{
continue;
}
if (p.ParameterType == typeof(NameValueCollection))
{
if (string.Compare(p.ParameterName, "Form", StringComparison.OrdinalIgnoreCase) == 0)
{
parameters[p.ParameterName] = request.Form;
}
else if (string.Compare(p.ParameterName, "QueryString", StringComparison.OrdinalIgnoreCase) == 0)
{
parameters[p.ParameterName] = request.QueryString;
}
else if (string.Compare(p.ParameterName, "Headers", StringComparison.OrdinalIgnoreCase) == 0)
{
parameters[p.ParameterName] = request.Headers;
}
else if (string.Compare(p.ParameterName, "ServerVariables", StringComparison.OrdinalIgnoreCase) == 0)
{
parameters[p.ParameterName] = request.ServerVariables;
}
}
else
{
Type paramterType = p.ParameterType.GetRealType();
// 如果参数是可支持的类型，则直接从HttpRequest中读取并赋值
if (paramterType.IsSupportableType())
{
object val = GetValueByNameAndTypeFrommRequest(request, p.ParameterType.GetRealType(), p.ParameterName, p.BindingInfo.Prefix);
if (val != null)
{
parameters[p.ParameterName] = val;
}
else
{
if (p.ParameterType.IsValueType && p.ParameterType.IsNullableType() == false)
{
throw new ArgumentException("未能找到指定的参数值：" + p.ParameterName);
}
}
}
else
{
// 自定义的类型。首先创建实例，然后给所有成员赋值。
// 注意：这里不支持嵌套类型的自定义类型。
//object item = Activator.CreateInstance(paramterType);
object item = paramterType.GetConstructor(Type.EmptyTypes).FastCreate();
FillModel(request, item, p);
parameters[p.ParameterName] = item;
}
}
}
return(parameters);
}
protected virtual IDictionary<string, object> GetParameterValues(
ControllerContext context, ActionDescriptor descriptor)
{
Precondition.Require(context, () => Error.ArgumentNull("context"));
Precondition.Require(descriptor, () => Error.ArgumentNull("descriptor"));
return descriptor.GetParameters().ToDictionary(
p => p.Name, p => GetParameterValue(context, p),
StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Inject the Model & Message into the parameters that will be passed to this Action (if appropriate parameters are available).
/// </summary>
/// <param name="controller">The controller that contains this action</param>
/// <param name="actionDescriptor">The Action in the Controller that is going to be executed</param>
/// <param name="model">The Model that should be passed to the Action if possible</param>
/// <param name="message">The Message that should be passed to the Action if possible</param>
private void PopulateActionParameters(
ControllerBase controller,
ActionDescriptor actionDescriptor,
object model = null,
object message = null)
{
if (actionDescriptor.ControllerDescriptor.ControllerType != controller.GetType())
{
throw new ArgumentException("actionDescriptor does not describe a valid action for the controller supplied");
}
if (!this.HasAcceptableParameters(actionDescriptor, model, message))
{
throw new ArgumentException("actionDescriptor does not have valid parameters that can be populated");
}
// Extract the Actions Parameters
var parameters = actionDescriptor.GetParameters();
// Extract the parameters we're likely to be filling in
var firstParam = actionDescriptor.GetParameters().FirstOrDefault();
var lastParam = actionDescriptor.GetParameters().LastOrDefault();
// If we're expecting 1, assign either the model or message
if (parameters.Count() == 1 && (model != null || message != null) && firstParam != null)
{
// If it's assignable from Model
if (model != null && firstParam.ParameterType.IsAssignableFrom(model.GetType()))
{
controller.ControllerContext.RouteData.Values[firstParam.ParameterName] = model;
}
else if (message != null)
// Don't need to double check this because the HasAcceptableParameters method has already done this
/* if (message != null && firstParam.ParameterType.IsAssignableFrom(message.GetType())) */
{
controller.ControllerContext.RouteData.Values[firstParam.ParameterName] = message;
}
}
// If we're expecting 2, assign both the correct way round
else if (parameters.Count() == 2 && model != null && message != null && firstParam != null &&
lastParam != null)
{
if (
firstParam.ParameterType.IsAssignableFrom(model.GetType()) &&
lastParam.ParameterType.IsAssignableFrom(message.GetType()))
{
controller.ControllerContext.RouteData.Values[firstParam.ParameterName] = model;
controller.ControllerContext.RouteData.Values[lastParam.ParameterName] = message;
}
else
// Don't need to double check this because the HasAcceptableParameters method has already done this
/*
* if (
* firstParam.ParameterType.IsAssignableFrom(message.GetType()) &&
* lastParam.ParameterType.IsAssignableFrom(model.GetType()))
*/
{
controller.ControllerContext.RouteData.Values[firstParam.ParameterName] = message;
controller.ControllerContext.RouteData.Values[lastParam.ParameterName] = model;
}
}
}
