internal ActionSelectorCacheItem(HttpControllerDescriptor controllerDescriptor)
{
this.controllerDescriptor = controllerDescriptor;
var validMethods = this.controllerDescriptor.ControllerType
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(IsValidActionMethod)
.ToArray();
combinedCandidateActions = new CandidateAction[validMethods.Length];
for (var i = 0; i < validMethods.Length; i++)
{
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, validMethods[i]);
combinedCandidateActions[i] = new CandidateAction(actionDescriptor);
actionParameterNames.Add(
actionDescriptor,
actionDescriptor.ActionBinding.ParameterBindings
.Where(binding => !binding.Descriptor.IsOptional && binding.Descriptor.ParameterType.CanConvertFromString() && binding.WillReadUri())
.Select(binding => binding.Descriptor.Prefix ?? binding.Descriptor.ParameterName).ToArray());
}
combinedActionNameMapping =
combinedCandidateActions
.Select(c => c.ActionDescriptor)
.ToLookup(actionDesc => actionDesc.ActionName, OrdinalIgnoreCase);
}
// If routeData is from an attribute route, get the controller that can handle it.
// Else return null. Throws an exception if multiple controllers match
private static HttpControllerDescriptor GetDirectRouteController(IHttpRouteData routeData)
{
CandidateAction[] candidates = routeData.GetDirectRouteCandidates();
if (candidates != null)
{
// Set the controller descriptor for the first action descriptor
Contract.Assert(candidates.Length > 0);
Contract.Assert(candidates[0].ActionDescriptor != null);
HttpControllerDescriptor controllerDescriptor = candidates[0].ActionDescriptor.ControllerDescriptor;
// Check that all other candidate action descriptors share the same controller descriptor
for (int i = 1; i < candidates.Length; i++)
{
CandidateAction candidate = candidates[i];
if (candidate.ActionDescriptor.ControllerDescriptor != controllerDescriptor)
{
// We've found an ambiguity (multiple controllers matched)
throw CreateDirectRouteAmbiguousControllerException(candidates);
}
}
return(controllerDescriptor);
}
return(null);
}
internal ActionSelectorCacheItem(HttpControllerDescriptor controllerDescriptor)
{
Contract.Requires(controllerDescriptor != null);
this.controllerDescriptor = Decorator.GetInner(controllerDescriptor);
var allMethods = this.controllerDescriptor.ControllerType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
var validMethods = Array.FindAll(allMethods, IsValidActionMethod);
combinedCandidateActions = new CandidateAction[validMethods.Length];
for (var i = 0; i < validMethods.Length; i++)
{
var method = validMethods[i];
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, method);
var actionBinding = actionDescriptor.ActionBinding;
allowedMethods.AddRange(actionDescriptor.SupportedHttpMethods);
combinedCandidateActions[i] = new CandidateAction(actionDescriptor);
actionParameterNames.Add(
actionDescriptor,
actionBinding.ParameterBindings
.Where(binding => !binding.Descriptor.IsOptional && binding.Descriptor.ParameterType.CanConvertFromString() && binding.WillReadUri())
.Select(binding => binding.Descriptor.Prefix ?? binding.Descriptor.ParameterName).ToArray());
}
combinedActionNameMapping =
combinedCandidateActions
.Select(c => c.ActionDescriptor)
.ToLookup(actionDesc => actionDesc.ActionName, OrdinalIgnoreCase);
}
private void ExecuteSelectedAction(object sender, EventArgs e)
{
if (lstCandidateActions.SelectedItem != null)
{
_chosenAction = (CandidateAction)lstCandidateActions.SelectedItem;
}
}
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);
}
private void CandidateActionHighlighted(object sender, EventArgs e)
{
txtCandidateDescription.Text = "";
CandidateAction action = (CandidateAction)lstCandidateActions.SelectedItem;
if (action == null)
{
return;
}
if (action.IsSync)
{
txtCandidateDescription.Text = "Synchronization between\n\n" + action.Process1 + "\n\nand\n\n" + action.Process2;
if (action.IsTau)
{
txtCandidateDescription.Text += "\n\non restricted channel " + action.ToString() + " (tau action)";
}
else
{
txtCandidateDescription.Text += "\n\non channel " + action.ToString();
}
}
else
{
txtCandidateDescription.Text = "Asynchronous action " + action + " by \n\n" + action.Process1;
}
}
private void ExecuteRandomAction(object sender, EventArgs e)
{
if (lstCandidateActions.Items.Count > 0)
{
_chosenAction = (CandidateAction)lstCandidateActions.Items[_rng.Next(lstCandidateActions.Items.Count)];
}
}
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(RouteKeys.ActionKey, out actionName))
{
// We have an explicit {action} value, do traditional binding. Just lookup by actionName
ReflectedHttpActionDescriptor[] actionsFoundByName = _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 = _standardCandidateActions;
}
else
{
// No direct routing or {action} parameter, infer it from the verb.
candidates = FindActionsForVerb(incomingMethod);
}
}
return(candidates);
}
public CandidateActionWithParams(
CandidateAction candidateAction,
ISet <string> parameters,
IHttpRouteData routeDataSource
)
{
CandidateAction = candidateAction;
CombinedParameterNames = parameters;
RouteDataSource = routeDataSource;
}
// This method lazy-initializes the data needed for action selection. This is a safe race-condition. This is
// done because we don't know whether or not an action/controller is attribute routed until after attribute
// routes are added.
private void InitializeStandardActions()
{
if (_standardActions != null)
{
return;
}
StandardActionSelectionCache standardActions = new StandardActionSelectionCache();
if (_controllerDescriptor.IsAttributeRouted())
{
// The controller has an attribute route; no actionsByVerb are accessible via standard routing.
standardActions.StandardCandidateActions = new CandidateAction[0];
}
else
{
// The controller does not have an attribute route; some actionsByVerb may be accessible via standard
// routing.
List <CandidateAction> standardCandidateActions = new List <CandidateAction>();
for (int i = 0; i < _combinedCandidateActions.Length; i++)
{
CandidateAction candidate = _combinedCandidateActions[i];
// We know that this cast is safe before we created all of the action descriptors for standard actions
ReflectedHttpActionDescriptor action = (ReflectedHttpActionDescriptor)candidate.ActionDescriptor;
// Allow standard routes access inherited actionsByVerb or actionsByVerb without Route attributes.
if (action.MethodInfo.DeclaringType != _controllerDescriptor.ControllerType ||
!candidate.ActionDescriptor.IsAttributeRouted())
{
standardCandidateActions.Add(candidate);
}
}
standardActions.StandardCandidateActions = standardCandidateActions.ToArray();
}
standardActions.StandardActionNameMapping =
standardActions.StandardCandidateActions
.Select(c => c.ActionDescriptor)
.ToLookup(actionDesc => actionDesc.ActionName, StringComparer.OrdinalIgnoreCase);
// Bucket the action descriptors by common verbs.
int len = _cacheListVerbKinds.Length;
standardActions.CacheListVerbs = new CandidateAction[len][];
for (int i = 0; i < len; i++)
{
standardActions.CacheListVerbs[i] = FindActionsForVerbWorker(_cacheListVerbKinds[i], standardActions.StandardCandidateActions);
}
_standardActions = standardActions;
}
private CandidateAction[] GetInitialCandidateList(HttpControllerContext controllerContext, bool ignoreVerbs = false)
{
Contract.Requires(controllerContext != null);
Contract.Ensures(Contract.Result <CandidateAction[]>() != null);
var actionName = default(string);
var incomingMethod = controllerContext.Request.Method;
var routeData = controllerContext.RouteData;
var candidates = default(CandidateAction[]);
if (routeData.Values.TryGetValue(RouteValueKeys.Action, out actionName))
{
var actionsFoundByName = standardActions.StandardActionNameMapping[actionName].ToArray();
if (actionsFoundByName.Length == 0)
{
var request = controllerContext.Request;
var versionNeutral = controllerContext.ControllerDescriptor.GetApiVersionModel().IsApiVersionNeutral;
var exceptionFactory = new HttpResponseExceptionFactory(request);
throw exceptionFactory.NewMethodNotAllowedException(versionNeutral, allowedMethods);
}
var candidatesFoundByName = new CandidateAction[actionsFoundByName.Length];
for (var i = 0; i < actionsFoundByName.Length; i++)
{
candidatesFoundByName[i] = new CandidateAction(actionsFoundByName[i]);
}
if (ignoreVerbs)
{
candidates = candidatesFoundByName;
}
else
{
candidates = FilterIncompatibleVerbs(incomingMethod, candidatesFoundByName);
}
}
else
{
if (ignoreVerbs)
{
candidates = standardActions.StandardCandidateActions;
}
else
{
candidates = FindActionsForVerb(incomingMethod, standardActions.CacheListVerbs, standardActions.StandardCandidateActions);
}
}
return(candidates);
}
public void NewState(List <ProcessBase> activeProcs, CandidateAction chosenAction)
{
StringBuilder builder = new StringBuilder();
if (chosenAction != null)
{
UpdateProcessActions(chosenAction.Process1);
if (chosenAction.Process2 != null)
{
UpdateProcessActions(chosenAction.Process2);
}
}
foreach (ProcessBase pb in activeProcs)
{
string name = pb.ToString();
Node proc = GetProcess(name);
RemovePerformedActions(name, ref proc);
builder.Append("\n\n# " + name + ": \n");
if (pb.Parent != null)
{
builder.Append("# Parent chain: ");
ProcessBase parent = pb.Parent;
List <string> parts = new List <string>();
while (parent != null)
{
Node parentProc = GetProcess(parent.ToString());
string oneParent = parent + ": ";
if (parentProc.ChildNodes[0] != null)
{
_formatter.Start(parentProc.ChildNodes[0]);
oneParent += (_formatter.GetFormatted());
}
if (parentProc.ChildNodes[1] != null)
{
_formatter.Start(parentProc.ChildNodes[1]);
oneParent += _formatter.GetFormatted();
}
parts.Add(oneParent);
parent = parent.Parent;
}
parts.Reverse();
builder.Append(string.Join("; ", parts.ToArray()));
builder.Append("\n");
}
_formatter.Start(proc);
builder.Append(FormatProc(_formatter.GetFormatted()));
}
_string = builder.ToString();
}
private CandidateAction[] GetInitialCandidateList(HttpControllerContext controllerContext, bool ignoreVerbs = false)
{
Contract.Requires(controllerContext != null);
Contract.Ensures(Contract.Result <CandidateAction[]>() != null);
var actionName = default(string);
var incomingMethod = controllerContext.Request.Method;
var routeData = controllerContext.RouteData;
var candidates = default(CandidateAction[]);
if (routeData.Values.TryGetValue(RouteValueKeys.Action, out actionName))
{
var actionsFoundByName = standardActions.StandardActionNameMapping[actionName].ToArray();
if (actionsFoundByName.Length == 0)
{
throw new HttpResponseException(CreateActionNotFoundResponse(controllerContext, actionName));
}
var candidatesFoundByName = new CandidateAction[actionsFoundByName.Length];
for (var i = 0; i < actionsFoundByName.Length; i++)
{
candidatesFoundByName[i] = new CandidateAction(actionsFoundByName[i]);
}
if (ignoreVerbs)
{
candidates = candidatesFoundByName;
}
else
{
candidates = FilterIncompatibleVerbs(incomingMethod, candidatesFoundByName);
}
}
else
{
if (ignoreVerbs)
{
candidates = standardActions.StandardCandidateActions;
}
else
{
candidates = FindActionsForVerb(incomingMethod, standardActions.CacheListVerbs, standardActions.StandardCandidateActions);
}
}
return(candidates);
}
private string DebuggerToString()
{
StringBuilder sb = new StringBuilder();
sb.Append(CandidateAction.DebuggerToString());
if (CombinedParameterNames.Count > 0)
{
sb.Append(", Params =");
foreach (string param in CombinedParameterNames)
{
sb.AppendFormat(" {0}", param);
}
}
return(sb.ToString());
}
string DebuggerToString()
{
var sb = new StringBuilder();
sb.Append(CandidateAction.DebuggerToString());
if (CombinedParameterNames.Count < 1)
{
return(sb.ToString());
}
sb.Append(", Params =");
foreach (var param in CombinedParameterNames)
{
sb.Append(' ');
sb.Append(param);
}
return(sb.ToString());
}
private void StartExecution(object sender, EventArgs e)
{
if (_status == RunStatus.Stopped)
{
if (_loadedSystem != null)
{
_visual = new ProcessStateVisualization(_loadedSystem, _parser.Formatter);
}
_status = RunStatus.Running;
ClearAll();
processThreadWorker.RunWorkerAsync();
}
else if (_status == RunStatus.Stepping)
{
_status = RunStatus.Running;
if (lstCandidateActions.Items.Count > 0)
{
_chosenAction = (CandidateAction)lstCandidateActions.Items[_rng.Next(lstCandidateActions.Items.Count)];
}
}
EnableControls();
}
private CandidateAction ChooseActionInterActive(List <CandidateAction> candidates)
{
if (_status == RunStatus.Stepping)
{
UpdateState();
}
_chosenAction = null;
lstCandidateActions.Invoke(new NewCandidateActionsDelegate(NewCandidateActions), candidates);
if (_status == RunStatus.Stepping)
{
while (_chosenAction == null)
{
Thread.Sleep(500); //Wait until user has selected something...
}
return(_chosenAction);
}
else
{
return(candidates[_rng.Next(candidates.Count)]);
}
}
// 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;
}
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.GetCustomAttributes <IHttpRouteInfoProvider>(inherit: false).Any())
{
// 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 (candidate.ActionDescriptor.MethodInfo.DeclaringType != controllerDescriptor.ControllerType ||
!candidate.ActionDescriptor.GetCustomAttributes <IHttpRouteInfoProvider>(inherit: false).Any())
{
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 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;
IHttpRoute route = routeData.Route;
CandidateAction[] candidates;
if (route != null)
{
// Attribute routing gives the action selector an explicit initial candidate list.
candidates = routeData.GetDirectRouteCandidates();
if (candidates != null)
{
actionName = GetActionNameFromDirectRoute(routeData);
if (actionName != null)
{
CandidateAction[] candidatesFoundByName = Array.FindAll(candidates, candidate => candidate.MatchName(actionName));
candidates = GetInitialCandidateListByActionName(controllerContext, candidatesFoundByName, actionName, ignoreVerbs);
}
else if (!ignoreVerbs)
{
candidates = FindActionsForVerbWorker(incomingMethod, candidates);
}
return(candidates);
}
}
if (routeData.Values.TryGetValue(RouteKeys.ActionKey, out actionName))
{
// We have an explicit {action} value, do traditional binding. Just lookup by actionName
ReflectedHttpActionDescriptor[] actionsFoundByName = _standardActionNameMapping[actionName].ToArray();
CandidateAction[] candidatesFoundByName = new CandidateAction[actionsFoundByName.Length];
for (int i = 0; i < actionsFoundByName.Length; i++)
{
candidatesFoundByName[i] = new CandidateAction
{
ActionDescriptor = actionsFoundByName[i]
};
}
candidates = GetInitialCandidateListByActionName(controllerContext, candidatesFoundByName, actionName, ignoreVerbs);
}
else
{
if (ignoreVerbs)
{
candidates = _standardCandidateActions;
}
else
{
// No direct routing or {action} parameter, infer it from the verb.
candidates = FindActionsForVerb(incomingMethod);
}
}
return(candidates);
}
private List <CandidateAction> FindActionUsingRouteAndQueryParameters(HttpControllerContext controllerContext, CandidateAction[] candidatesFound)
{
IDictionary <string, object> routeValues = controllerContext.RouteData.Values;
HashSet <string> routeParameterNames = new HashSet <string>(routeValues.Keys, StringComparer.OrdinalIgnoreCase);
routeParameterNames.Remove(RouteKeys.ControllerKey);
routeParameterNames.Remove(RouteKeys.ActionKey);
HttpRequestMessage request = controllerContext.Request;
Uri requestUri = request.RequestUri;
bool hasQueryParameters = requestUri != null && !String.IsNullOrEmpty(requestUri.Query);
bool hasRouteParameters = routeParameterNames.Count != 0;
List <CandidateAction> matches = new List <CandidateAction>(candidatesFound.Length);
if (hasRouteParameters || hasQueryParameters)
{
var combinedParameterNames = new HashSet <string>(routeParameterNames, StringComparer.OrdinalIgnoreCase);
if (hasQueryParameters)
{
foreach (var queryNameValuePair in request.GetQueryNameValuePairs())
{
combinedParameterNames.Add(queryNameValuePair.Key);
}
}
// action parameters is a subset of route parameters and query parameters
for (int i = 0; i < candidatesFound.Length; i++)
{
CandidateAction candidate = candidatesFound[i];
ReflectedHttpActionDescriptor descriptor = candidate.ActionDescriptor;
if (IsSubset(_actionParameterNames[descriptor], combinedParameterNames))
{
matches.Add(candidate);
}
}
if (matches.Count > 1)
{
// select the results that match the most number of required parameters
matches = matches
.GroupBy(candidate => _actionParameterNames[candidate.ActionDescriptor].Length)
.OrderByDescending(g => g.Key)
.First()
.ToList();
}
}
else
{
// return actions with no parameters
for (int i = 0; i < candidatesFound.Length; i++)
{
CandidateAction candidate = candidatesFound[i];
ReflectedHttpActionDescriptor descriptor = candidate.ActionDescriptor;
if (_actionParameterNames[descriptor].Length == 0)
{
matches.Add(candidate);
}
}
}
return(matches);
}
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 CandidateActionWithParams(CandidateAction candidateAction, ISet<string> parameters, IHttpRouteData routeDataSource)
{
CandidateAction = candidateAction;
CombinedParameterNames = parameters;
RouteDataSource = routeDataSource;
}
// 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 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();
}
// 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();
}