public CandidateActionWithParams(CandidateAction candidateAction, ISet<string> parameters, IHttpRouteData routeDataSource)
{
CandidateAction = candidateAction;
CombinedParameterNames = parameters;
RouteDataSource = routeDataSource;
}
// Given a list of actionsByVerb, filter it to ones that match a given verb. This can match by name or IActionHttpMethodSelector.
// Since this list is fixed for a given verb type, it can be pre-computed and cached.
// This function should not do caching. It's the helper that builds the caches.
private static CandidateAction[] FindActionsForVerbWorker(HttpMethod verb, CandidateAction[] candidates)
{
List<CandidateAction> listCandidates = new List<CandidateAction>();
FindActionsForVerbWorker(verb, candidates, listCandidates);
return listCandidates.ToArray();
}
// Adds to existing list rather than send back as a return value.
private static void FindActionsForVerbWorker(HttpMethod verb, CandidateAction[] candidates, List<CandidateAction> listCandidates)
{
foreach (CandidateAction candidate in candidates)
{
if (candidate.ActionDescriptor != null && candidate.ActionDescriptor.SupportedHttpMethods.Contains(verb))
{
listCandidates.Add(candidate);
}
}
}
// Given a list of candidate actionsByVerb, return a parallel list that includes the parameter information.
// This is used for regular routing where all candidates come from a single route, so they all share the same route parameter names.
private static CandidateActionWithParams[] GetCandidateActionsWithBindings(HttpControllerContext controllerContext, CandidateAction[] candidatesFound)
{
HttpRequestMessage request = controllerContext.Request;
var queryNameValuePairs = request.GetQueryNameValuePairs();
IHttpRouteData routeData = controllerContext.RouteData;
IDictionary<string, object> routeValues = routeData.Values;
ISet<string> combinedParameterNames = GetCombinedParameterNames(queryNameValuePairs, routeValues);
CandidateActionWithParams[] candidatesWithParams = Array.ConvertAll(candidatesFound, candidate => new CandidateActionWithParams(candidate, combinedParameterNames, routeData));
return candidatesWithParams;
}
// This is called when we don't specify an Action name
// Get list of actionsByVerb that match a given verb. This can match by name or IActionHttpMethodSelector
private static CandidateAction[] FindActionsForVerb(HttpMethod verb, CandidateAction[][] actionsByVerb, CandidateAction[] otherActions)
{
// Check cache for common verbs.
for (int i = 0; i < _cacheListVerbKinds.Length; i++)
{
// verb selection on common verbs is normalized to have object reference identity.
// This is significantly more efficient than comparing the verbs based on strings.
if (Object.ReferenceEquals(verb, _cacheListVerbKinds[i]))
{
return actionsByVerb[i];
}
}
// General case for any verbs.
return FindActionsForVerbWorker(verb, otherActions);
}
private static CandidateAction[] FilterIncompatibleVerbs(HttpMethod incomingMethod, CandidateAction[] candidatesFoundByName)
{
return candidatesFoundByName.Where(candidate => candidate.ActionDescriptor.SupportedHttpMethods.Contains(incomingMethod)).ToArray();
}
private CandidateAction[] GetInitialCandidateList(HttpControllerContext controllerContext, bool ignoreVerbs = false)
{
// Initial candidate list is determined by:
// - Direct route?
// - {action} value?
// - ignore verbs?
string actionName;
HttpMethod incomingMethod = controllerContext.Request.Method;
IHttpRouteData routeData = controllerContext.RouteData;
Contract.Assert(routeData.GetSubRoutes() == null, "Should not be called on a direct route");
CandidateAction[] candidates;
if (routeData.Values.TryGetValue(RouteValueKeys.Action, out actionName))
{
// We have an explicit {action} value, do traditional binding. Just lookup by actionName
HttpActionDescriptor[] actionsFoundByName = _standardActions.StandardActionNameMapping[actionName].ToArray();
// Throws HttpResponseException with NotFound status because no action matches the Name
if (actionsFoundByName.Length == 0)
{
throw new HttpResponseException(CreateActionNotFoundResponse(controllerContext, actionName));
}
CandidateAction[] candidatesFoundByName = new CandidateAction[actionsFoundByName.Length];
for (int i = 0; i < actionsFoundByName.Length; i++)
{
candidatesFoundByName[i] = new CandidateAction
{
ActionDescriptor = actionsFoundByName[i]
};
}
if (ignoreVerbs)
{
candidates = candidatesFoundByName;
}
else
{
candidates = FilterIncompatibleVerbs(incomingMethod, candidatesFoundByName);
}
}
else
{
if (ignoreVerbs)
{
candidates = _standardActions.StandardCandidateActions;
}
else
{
// No direct routing or {action} parameter, infer it from the verb.
candidates = FindActionsForVerb(incomingMethod, _standardActions.CacheListVerbs, _standardActions.StandardCandidateActions);
}
}
return candidates;
}
public ActionSelectorCacheItem(HttpControllerDescriptor controllerDescriptor)
{
Contract.Assert(controllerDescriptor != null);
// Initialize the cache entirely in the ctor on a single thread.
_controllerDescriptor = controllerDescriptor;
MethodInfo[] allMethods = _controllerDescriptor.ControllerType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
MethodInfo[] validMethods = Array.FindAll(allMethods, IsValidActionMethod);
_combinedCandidateActions = new CandidateAction[validMethods.Length];
for (int i = 0; i < validMethods.Length; i++)
{
MethodInfo method = validMethods[i];
ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(_controllerDescriptor, method);
_combinedCandidateActions[i] = new CandidateAction
{
ActionDescriptor = actionDescriptor
};
HttpActionBinding actionBinding = actionDescriptor.ActionBinding;
// Building an action parameter name mapping to compare against the URI parameters coming from the request. Here we only take into account required parameters that are simple types and come from URI.
_actionParameterNames.Add(
actionDescriptor,
actionBinding.ParameterBindings
.Where(binding => !binding.Descriptor.IsOptional && TypeHelper.CanConvertFromString(binding.Descriptor.ParameterType) && binding.WillReadUri())
.Select(binding => binding.Descriptor.Prefix ?? binding.Descriptor.ParameterName).ToArray());
}
_combinedActionNameMapping =
_combinedCandidateActions
.Select(c => c.ActionDescriptor)
.ToLookup(actionDesc => actionDesc.ActionName, StringComparer.OrdinalIgnoreCase);
}
public ActionSelectorCacheItem(HttpControllerDescriptor controllerDescriptor)
{
Contract.Assert(controllerDescriptor != null);
// Initialize the cache entirely in the ctor on a single thread.
_controllerDescriptor = controllerDescriptor;
MethodInfo[] allMethods = _controllerDescriptor.ControllerType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
MethodInfo[] validMethods = Array.FindAll(allMethods, IsValidActionMethod);
_combinedCandidateActions = new CandidateAction[validMethods.Length];
for (int i = 0; i < validMethods.Length; i++)
{
MethodInfo method = validMethods[i];
ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(_controllerDescriptor, method);
_combinedCandidateActions[i] = new CandidateAction
{
ActionDescriptor = actionDescriptor
};
HttpActionBinding actionBinding = actionDescriptor.ActionBinding;
// Building an action parameter name mapping to compare against the URI parameters coming from the request. Here we only take into account required parameters that are simple types and come from URI.
_actionParameterNames.Add(
actionDescriptor,
actionBinding.ParameterBindings
.Where(binding => !binding.Descriptor.IsOptional && TypeHelper.CanConvertFromString(binding.Descriptor.ParameterType) && binding.WillReadUri())
.Select(binding => binding.Descriptor.Prefix ?? binding.Descriptor.ParameterName).ToArray());
}
if (controllerDescriptor.HasRoutingAttribute())
{
// The controller has an attribute route; no actions are accessible via standard routing.
_standardCandidateActions = new CandidateAction[0];
}
else
{
// The controller does not have an attribute route; some actions may be accessible via standard
// routing.
List<CandidateAction> standardCandidateActions = new List<CandidateAction>();
for (int i = 0; i < _combinedCandidateActions.Length; i++)
{
CandidateAction candidate = _combinedCandidateActions[i];
// Allow standard routes access inherited actions or actions without Route attributes.
if (((ReflectedHttpActionDescriptor)candidate.ActionDescriptor).MethodInfo.DeclaringType != controllerDescriptor.ControllerType
|| !candidate.ActionDescriptor.HasRoutingAttribute())
{
standardCandidateActions.Add(candidate);
}
}
_standardCandidateActions = standardCandidateActions.ToArray();
}
_combinedActionNameMapping = _combinedCandidateActions.Select(c => c.ActionDescriptor).ToLookup(actionDesc => actionDesc.ActionName, StringComparer.OrdinalIgnoreCase);
_standardActionNameMapping = _standardCandidateActions.Select(c => c.ActionDescriptor).ToLookup(actionDesc => actionDesc.ActionName, StringComparer.OrdinalIgnoreCase);
// Bucket the action descriptors by common verbs.
int len = _cacheListVerbKinds.Length;
_cacheListVerbs = new CandidateAction[len][];
for (int i = 0; i < len; i++)
{
_cacheListVerbs[i] = FindActionsForVerbWorker(_cacheListVerbKinds[i]);
}
}
private static Exception CreateDirectRouteAmbiguousControllerException(CandidateAction[] candidates)
{
Contract.Assert(candidates != null);
Contract.Assert(candidates.Length > 1);
HashSet<Type> matchingTypes = new HashSet<Type>();
for (int i = 0; i < candidates.Length; i++)
{
matchingTypes.Add(candidates[i].ActionDescriptor.ControllerDescriptor.ControllerType);
}
// we need to generate an exception containing all the controller types
StringBuilder typeList = new StringBuilder();
foreach (Type matchedType in matchingTypes)
{
typeList.AppendLine();
typeList.Append(matchedType.FullName);
}
return Error.InvalidOperation(SRResources.DirectRoute_AmbiguousController, typeList, Environment.NewLine);
}
