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);
}
// Creates wrapping tracers for all HttpParameterBindings
HttpActionBinding IActionValueBinder.GetBinding(HttpActionDescriptor actionDescriptor)
{
HttpActionBinding actionBinding = _innerBinder.GetBinding(actionDescriptor);
if (actionBinding == null)
{
return(null);
}
HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
HttpParameterBinding[] newParameterBindings = new HttpParameterBinding[parameterBindings.Length];
for (int i = 0; i < newParameterBindings.Length; i++)
{
HttpParameterBinding parameterBinding = parameterBindings[i];
// Intercept FormatterParameterBinding to replace its formatters
FormatterParameterBinding formatterParameterBinding = parameterBinding as FormatterParameterBinding;
newParameterBindings[i] = formatterParameterBinding != null
? (HttpParameterBinding) new FormatterParameterBindingTracer(formatterParameterBinding, _traceWriter)
: (HttpParameterBinding) new HttpParameterBindingTracer(parameterBinding, _traceWriter);
}
// Replace the inner HttpActionBinding's parameter bindings with our tracing versions.
// This allows each individual parameter binding to trace.
actionBinding.ParameterBindings = newParameterBindings;
// Then create an HttpActionBindingTracer to wrap the actual HttpActionBinding
if (!(actionBinding is HttpActionBindingTracer))
{
return(new HttpActionBindingTracer(actionBinding, _traceWriter));
}
return(actionBinding);
}
public void GetBinding_Wraps_FormatterParameterBinding(bool tracingEnabled)
{
// Arrange
HttpConfiguration config = new HttpConfiguration();
config.Services.Replace(
typeof(IAssembliesResolver),
new TestAssemblyResolver(new MockAssembly(typeof(PerRequestActionValueBinderTestSampleController))));
if (tracingEnabled)
{
config.Services.Replace(typeof(ITraceWriter), new Mock <ITraceWriter>().Object);
ITraceManager traceManager = config.Services.GetTraceManager();
traceManager.Initialize(config);
}
IHttpControllerSelector controllerSelector = config.Services.GetHttpControllerSelector();
IHttpActionSelector actionSelector = config.Services.GetActionSelector();
HttpControllerDescriptor controllerDescriptor = controllerSelector.GetControllerMapping()["PerRequestActionValueBinderTestSample"];
HttpActionDescriptor actionDescriptor = actionSelector.GetActionMapping(controllerDescriptor)["Post"].Single();
PerRequestActionValueBinder binder = new PerRequestActionValueBinder(new DefaultActionValueBinder());
// Act
HttpActionBinding binding = binder.GetBinding(actionDescriptor);
// Assert
HttpParameterBinding parameterBinding = binding.ParameterBindings.Where(p => p.Descriptor.ParameterName == "customer").Single();
Assert.True(parameterBinding is PerRequestParameterBinding);
}
public HttpActionBindingTracerTest()
{
_mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
_mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
_mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection <HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
_mockParameterDescriptor = new Mock <HttpParameterDescriptor>()
{
CallBase = true
};
_mockParameterBinding = new Mock <HttpParameterBinding>(_mockParameterDescriptor.Object)
{
CallBase = true
};
_actionBinding = new HttpActionBinding(_mockActionDescriptor.Object, new HttpParameterBinding[] { _mockParameterBinding.Object });
_controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));
_controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
_controllerContext.ControllerDescriptor = _controllerDescriptor;
_actionContext = ContextUtil.CreateActionContext(_controllerContext, actionDescriptor: _mockActionDescriptor.Object);
}
private IList <ApiParameterDescription> CreateParameterDescriptions(HttpActionDescriptor actionDescriptor, HttpParsedRoute parsedRoute, IDictionary <string, object> routeDefaults)
{
IList <ApiParameterDescription> parameterDescriptions = new List <ApiParameterDescription>();
HttpActionBinding actionBinding = GetActionBinding(actionDescriptor);
// try get parameter binding information if available
if (actionBinding != null)
{
HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
if (parameterBindings != null)
{
foreach (HttpParameterBinding parameter in parameterBindings)
{
parameterDescriptions.Add(CreateParameterDescriptionFromBinding(parameter));
}
}
}
else
{
Collection <HttpParameterDescriptor> parameters = actionDescriptor.GetParameters();
if (parameters != null)
{
foreach (HttpParameterDescriptor parameter in parameters)
{
parameterDescriptions.Add(CreateParameterDescriptionFromDescriptor(parameter));
}
}
}
// Adding route parameters not declared on the action. We're doing this because route parameters may or
// may not be part of the action parameters and we want to have them in the description.
AddUndeclaredRouteParameters(parsedRoute, routeDefaults, parameterDescriptions);
return(parameterDescriptions);
}
private void Bind(string methodName)
{
//创建FormatterParameterBinding对象
MethodInfo method = typeof(ContactsController).GetMethod(methodName);
HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(this.ControllerContext.ControllerDescriptor, method);
HttpParameterDescriptor parameterDescriptor = actionDescriptor.GetParameters().First();
MediaTypeFormatter[] formatters = new MediaTypeFormatter[] { new JsonMediaTypeFormatter() };
FormatterParameterBinding parameterBinding = new FormatterParameterBinding(parameterDescriptor, formatters, null);
//创建HttpActionBinding并执行
HttpActionBinding actionBinding = new HttpActionBinding(actionDescriptor, new FormatterParameterBinding[] { parameterBinding });
HttpActionContext actionContext = new HttpActionContext(this.ControllerContext, actionDescriptor);
try
{
actionBinding.ExecuteBindingAsync(actionContext, CancellationToken.None).Wait();
//获取绑定参数对象并打印相关数据
Contact contact = (Contact)actionContext.ActionArguments["contact"];
Console.WriteLine("{0,-12}: {1}", "Name", contact.Name);
Console.WriteLine("{0,-12}: {1}", "Phone No.", contact.PhoneNo);
Console.WriteLine("{0,-12}: {1}", "EmailAddress", contact.EmailAddress);
Console.WriteLine("{0,-12}: {1}", "Address", contact.Address);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Update actionBinding to enforce there is at most 1 body parameter.
/// If there are multiple, convert them all to <see cref="ErrorParameterBinding"/>
/// </summary>
private static void EnsureOneBodyParameter(HttpActionBinding actionBinding)
{
IList <HttpParameterDescriptor> parameters = actionBinding.ActionDescriptor.GetParameters();
int idxFromBody = -1;
for (int i = 0; i < actionBinding.ParameterBindings.Length; i++)
{
if (actionBinding.ParameterBindings[i].WillReadBody)
{
if (idxFromBody >= 0)
{
// This is the 2nd parameter to read from the body. Flag an error.
string name1 = parameters[idxFromBody].ParameterName;
string name2 = parameters[i].ParameterName;
string message = Error.Format(SRResources.ParameterBindingCantHaveMultipleBodyParameters, name1, name2);
actionBinding.ParameterBindings[i] = new ErrorParameterBinding(parameters[i], message);
actionBinding.ParameterBindings[idxFromBody] = new ErrorParameterBinding(parameters[idxFromBody], message);
}
else
{
idxFromBody = i;
}
}
}
}
private IList <ApiParameterDescription> CreateParameterDescription(HttpActionBinding actionBinding, HttpActionDescriptor actionDescriptor)
{
IList <ApiParameterDescription> parameterDescriptions = new List <ApiParameterDescription>();
// try get parameter binding information if available
if (actionBinding != null)
{
HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
if (parameterBindings != null)
{
foreach (HttpParameterBinding parameter in parameterBindings)
{
parameterDescriptions.Add(CreateParameterDescriptionFromBinding(parameter));
}
}
}
else
{
Collection <HttpParameterDescriptor> parameters = actionDescriptor.GetParameters();
if (parameters != null)
{
foreach (HttpParameterDescriptor parameter in parameters)
{
parameterDescriptions.Add(CreateParameterDescriptionFromDescriptor(parameter));
}
}
}
return(parameterDescriptions);
}
public void GetBinding_DoesNotWrapHttpActionBindingTracer()
{
// Arrange
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
Mock <HttpParameterDescriptor> mockParameterDescriptor = new Mock <HttpParameterDescriptor>()
{
CallBase = true
};
Mock <FormatterParameterBinding> mockParameterBinding = new Mock <FormatterParameterBinding>(mockParameterDescriptor.Object, new MediaTypeFormatterCollection(), null)
{
CallBase = true
};
HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object });
ITraceWriter traceWriter = new TestTraceWriter();
HttpActionBindingTracer actionBindingTracer = new HttpActionBindingTracer(actionBinding, traceWriter);
Mock <IActionValueBinder> mockBinder = new Mock <IActionValueBinder>()
{
CallBase = true
};
mockBinder.Setup(b => b.GetBinding(It.IsAny <HttpActionDescriptor>())).Returns(actionBindingTracer);
ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, traceWriter);
// Act
HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object);
// Assert
Assert.Same(actionBindingTracer, actualBinding);
}
public HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
{
var binders = actionDescriptor.GetParameters().Select(GetParameterBinding).ToArray();
var actionBinding = new HttpActionBinding(actionDescriptor, binders);
_ensureOneBodyParameter(actionBinding);
return(actionBinding);
}
private void AssertIsError(HttpActionBinding binding, int paramIdx)
{
HttpParameterBinding p = binding.ParameterBindings[paramIdx];
Assert.NotNull(p);
Assert.False(p.IsValid);
Assert.False(p.WillReadBody);
}
private void AssertIsCustomBinder <T>(HttpActionBinding binding, int paramIdx)
{
HttpParameterBinding p = binding.ParameterBindings[paramIdx];
Assert.NotNull(p);
Assert.IsType <T>(p);
Assert.True(p.IsValid);
Assert.False(p.WillReadBody);
}
private bool RequiredValidationsIsIgnored(HttpActionBinding actionBinding)
{
bool ignore;
if (!_ignoreRequiredValidationByActionBindingCache.TryGetValue(actionBinding, out ignore))
{
_ignoreRequiredValidationByActionBindingCache.TryAdd(actionBinding, ignore = RequiredValidationsIsIgnored(actionBinding.ActionDescriptor as ReflectedHttpActionDescriptor));
}
return(ignore);
}
private ValidateHandler GetValidateHandler(HttpActionBinding actionBinding)
{
ValidateHandler validateAction;
if (!_validateActionByActionBinding.TryGetValue(actionBinding, out validateAction))
{
_validateActionByActionBinding.TryAdd(actionBinding, validateAction = CreateValidateHandler(actionBinding));
}
return(validateAction);
}
public void Inner_Property_On_HttpActionBindingTracer_Returns_HttpActionBinding()
{
// Arrange
HttpActionBinding expectedInner = new HttpActionBinding();
HttpActionBindingTracer productUnderTest = new HttpActionBindingTracer(expectedInner, new TestTraceWriter());
// Act
HttpActionBinding actualInner = productUnderTest.Inner;
// Assert
Assert.Same(expectedInner, actualInner);
}
public new HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
{
if (actionDescriptor.GetParameters().Any(p => p.ParameterName.Equals("values", StringComparison
.InvariantCultureIgnoreCase)))
{
var bindings = Array.ConvertAll(actionDescriptor.GetParameters().ToArray(), new Converter <HttpParameterDescriptor, HttpParameterBinding>(GetCustomParameterBinding));
var actionBinding = new HttpActionBinding(actionDescriptor, bindings);
return(actionBinding);
}
return(base.GetBinding(actionDescriptor));
}
public void Decorator_GetInner_On_HttpActionBindingTracer_Returns_HttpActionBinding()
{
// Arrange
HttpActionBinding expectedInner = new HttpActionBinding();
HttpActionBindingTracer productUnderTest = new HttpActionBindingTracer(expectedInner, new TestTraceWriter());
// Act
HttpActionBinding actualInner = Decorator.GetInner(productUnderTest as HttpActionBinding);
// Assert
Assert.Same(expectedInner, actualInner);
}
private async Task <HttpResponseMessage> ExecuteAction(HttpActionBinding actionBinding, HttpActionContext actionContext,
CancellationToken cancellationToken, IEnumerable <IActionFilter> actionFilters, ServicesContainer controllerServices)
{
cancellationToken.ThrowIfCancellationRequested();
await actionBinding.ExecuteBindingAsync(actionContext, cancellationToken);
_modelState = actionContext.ModelState;
cancellationToken.ThrowIfCancellationRequested();
return(await InvokeActionWithActionFilters(actionContext, cancellationToken, actionFilters, () =>
{
return controllerServices.GetActionInvoker().InvokeActionAsync(actionContext, cancellationToken);
})());
}
public virtual Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
if (_request != null)
{
// if user has registered a controller factory which produces the same controller instance, we should throw here
throw Error.InvalidOperation(SRResources.CannotSupportSingletonInstance, typeof(ApiController).Name, typeof(IHttpControllerActivator).Name);
}
Initialize(controllerContext);
// We can't be reused, and we know we're disposable, so make sure we go away when
// the request has been completed.
if (_request != null)
{
_request.RegisterForDispose(this);
}
HttpControllerDescriptor controllerDescriptor = controllerContext.ControllerDescriptor;
ServicesContainer controllerServices = controllerDescriptor.Configuration.Services;
HttpActionDescriptor actionDescriptor = controllerServices.GetActionSelector().SelectAction(controllerContext);
HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);
IEnumerable <FilterInfo> filters = actionDescriptor.GetFilterPipeline();
FilterGrouping filterGrouping = new FilterGrouping(filters);
IEnumerable <IActionFilter> actionFilters = filterGrouping.ActionFilters;
IEnumerable <IAuthorizationFilter> authorizationFilters = filterGrouping.AuthorizationFilters;
IEnumerable <IExceptionFilter> exceptionFilters = filterGrouping.ExceptionFilters;
// Func<Task<HttpResponseMessage>>
Task <HttpResponseMessage> result = InvokeActionWithAuthorizationFilters(actionContext, cancellationToken, authorizationFilters, () =>
{
HttpActionBinding actionBinding = actionDescriptor.ActionBinding;
Task bindTask = actionBinding.ExecuteBindingAsync(actionContext, cancellationToken);
return(bindTask.Then <HttpResponseMessage>(() =>
{
_modelState = actionContext.ModelState;
Func <Task <HttpResponseMessage> > invokeFunc = InvokeActionWithActionFilters(actionContext, cancellationToken, actionFilters, () =>
{
return controllerServices.GetActionInvoker().InvokeActionAsync(actionContext, cancellationToken);
});
return invokeFunc();
}));
})();
result = InvokeActionWithExceptionFilters(result, actionContext, cancellationToken, exceptionFilters);
return(result);
}
private static HttpActionBinding GetActionBinding(HttpActionDescriptor actionDescriptor)
{
HttpControllerDescriptor controllerDescriptor = actionDescriptor.ControllerDescriptor;
if (controllerDescriptor == null)
{
return(null);
}
IActionValueBinder actionValueBinder = controllerDescriptor.ActionValueBinder;
HttpActionBinding actionBinding = actionValueBinder != null?actionValueBinder.GetBinding(actionDescriptor) : null;
return(actionBinding);
}
static void Main(string[] args)
{
HttpConfiguration configuration = new HttpConfiguration();
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(configuration, "demo", typeof(DemoController));
IHttpActionSelector actionSelector = configuration.Services.GetActionSelector();
HttpActionDescriptor actionDescriptor = actionSelector.GetActionMapping(controllerDescriptor)["DemoAction"].First();
IActionValueBinder actionValueBinder = configuration.Services.GetActionValueBinder();
HttpActionBinding actionBinding = actionValueBinder.GetBinding(actionDescriptor);
Console.WriteLine("{0,-18}{1}", "Parameter", "HttpParameterBinding");
foreach (HttpParameterBinding parameterBinding in actionBinding.ParameterBindings)
{
Console.WriteLine("{0,-18}{1}", parameterBinding.Descriptor.ParameterName, parameterBinding.GetType().Name);
}
}
private static HttpActionBinding GetActionBinding(HttpActionDescriptor actionDescriptor)
{
HttpControllerDescriptor controllerDescriptor = actionDescriptor.ControllerDescriptor;
if (controllerDescriptor == null)
{
return(null);
}
ServicesContainer controllerServices = controllerDescriptor.Configuration.Services;
IActionValueBinder actionValueBinder = controllerServices.GetActionValueBinder();
HttpActionBinding actionBinding = actionValueBinder != null?actionValueBinder.GetBinding(actionDescriptor) : null;
return(actionBinding);
}
/// <summary>
/// Implementation of <see cref="IActionValueBinder"/>, Primary entry point for binding parameters for an action.
/// </summary>
public virtual HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
{
if (actionDescriptor == null)
{
throw Error.ArgumentNull("actionDescriptor");
}
HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
HttpParameterBinding[] binders = Array.ConvertAll(parameters, GetParameterBinding);
HttpActionBinding actionBinding = new HttpActionBinding(actionDescriptor, binders);
EnsureOneBodyParameter(actionBinding);
return(actionBinding);
}
private Collection <ApiDescription> InitializeApiDescriptions()
{
Collection <ApiDescription> apiDescriptions = new Collection <ApiDescription>();
//webapi
foreach (var item in base.ApiDescriptions)
{
apiDescriptions.Add(item);
}
//dynamic api
var dynamicapiinfos = DynamicApiControllerManager.GetAll();
foreach (var dynamicapiinfo in dynamicapiinfos)
{
foreach (var item in dynamicapiinfo.Actions)
{
ApiDescription api = new ApiDescription();
var httpaction = new HttpControllerDescriptor();
httpaction.Configuration = _config;
httpaction.ControllerType = dynamicapiinfo.ServiceInterfaceType;
httpaction.ControllerName = dynamicapiinfo.ServiceName;
var action = new DynamicHttpActionDescriptor(_abpWebApiConfiguration, httpaction, item.Value);
api.ActionDescriptor = action;
api.HttpMethod = GetMethod(item.Value.Verb);
IActionValueBinder actionValueBinder = _config.Services.GetActionValueBinder();
HttpActionBinding actionBinding = actionValueBinder.GetBinding(action);
//parameter
IList <ApiParameterDescription> parameterDescriptions = CreateParameterDescription(actionBinding, action);
//using refletions to internal set
var prop = typeof(ApiDescription).GetProperties().Where(p => p.Name == "ParameterDescriptions").SingleOrDefault();
prop.SetValue(api, new Collection <ApiParameterDescription>(parameterDescriptions));
//resopnse
ResponseDescription responseDescription = CreateResponseDescription(action);
var prop2 = typeof(ApiDescription).GetProperties().Where(p => p.Name == "ResponseDescription").SingleOrDefault();
prop2.SetValue(api, responseDescription);
api.RelativePath = "api/services/" + dynamicapiinfo.ServiceName + "/" + item.Value.ActionName;
apiDescriptions.Add(api);
}
}
return(apiDescriptions);
}
public HttpActionBindingTracer(HttpActionBinding innerBinding, ITraceWriter traceWriter)
{
_innerBinding = innerBinding;
_traceWriter = traceWriter;
// Properties that cannot be delegated to the inner must be replicated.
// They must also avoid an ArgumentNullException for null values.
if (_innerBinding.ParameterBindings != null)
{
ParameterBindings = _innerBinding.ParameterBindings;
}
if (_innerBinding.ActionDescriptor != null)
{
ActionDescriptor = _innerBinding.ActionDescriptor;
}
}
public override async Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
{
HttpActionBinding binding = actionContext.ActionDescriptor.ActionBinding;
if (binding.ParameterBindings.Length > 1 || actionContext.Request.Method == HttpMethod.Get)
{
return;
}
string stringResult = await actionContext.Request.Content.ReadAsStringAsync();
JsonSerializerSettings settings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
};
dynamic param = JsonConvert.DeserializeObject(stringResult, settings);
SetValue(actionContext, param);
}
private ValidateHandler CreateValidateHandler(HttpActionBinding actionBinding)
{
ValidateHandler handler = new ValidateHandler(c => { });
var parameters = actionBinding.ParameterBindings;
for (int i = 0; i < parameters.Length; i++)
{
var parameterDescriptor = (ReflectedHttpParameterDescriptor)parameters[i].Descriptor;
var attribute = parameterDescriptor.ParameterInfo.GetCustomAttribute <RequiredAttribute>(true);
if (attribute != null)
{
handler += CreateValidateHandler(attribute, parameterDescriptor.ParameterName);
}
}
return(handler);
}
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);
_actionDescriptors = new ReflectedHttpActionDescriptor[validMethods.Length];
for (int i = 0; i < validMethods.Length; i++)
{
MethodInfo method = validMethods[i];
ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(_controllerDescriptor, method);
_actionDescriptors[i] = 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 &&
binding.WillReadUri()
)
.SelectMany(SelectActionParameterNames)
.Distinct(StringComparer.OrdinalIgnoreCase).ToArray());
}
_actionNameMapping = _actionDescriptors.ToLookup(actionDesc => actionDesc.ActionName, StringComparer.OrdinalIgnoreCase);
// Bucket the action descriptors by common verbs.
int len = _cacheListVerbKinds.Length;
_cacheListVerbs = new ReflectedHttpActionDescriptor[len][];
for (int i = 0; i < len; i++)
{
_cacheListVerbs[i] = FindActionsForVerbWorker(_cacheListVerbKinds[i]);
}
}
public HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
{
if (actionDescriptor == null)
{
throw Error.ArgumentNull("actionDescriptor");
}
HttpActionBinding binding = _innerActionValueBinder.GetBinding(actionDescriptor);
if (binding == null)
{
return(null);
}
HttpParameterBinding[] parameterBindings = binding.ParameterBindings;
if (parameterBindings != null)
{
for (int i = 0; i < binding.ParameterBindings.Length; i++)
{
HttpParameterBinding parameterBinding = binding.ParameterBindings[i];
// Replace the formatter parameter binding with one that will attach the request.
// Note that we do not replace any other types, including derived types, as we do not have a way to
// decorate/compose these instances; there is no way we can add request attachment behavior to an
// arbitrary implementation of HttpParameterBinding. Any custom parameter bindings that do not
// attach the request may fail when using with OData (and the exception retured in that instance
// will explain the necessity of providing this behavior when implementing HttpParameterBinding for
// OData).
if (parameterBinding != null && parameterBinding is FormatterParameterBinding)
{
Contract.Assert(parameterBinding.Descriptor != null);
Contract.Assert(actionDescriptor.Configuration != null);
Contract.Assert(actionDescriptor.Configuration.Formatters != null);
binding.ParameterBindings[i] = new PerRequestParameterBinding(parameterBinding.Descriptor,
actionDescriptor.Configuration.Formatters);
}
}
}
return(binding);
}
public void GetBinding_Returns_HttpActionBindingTracer()
{
// Arrange
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection <HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
Mock <HttpParameterDescriptor> mockParameterDescriptor = new Mock <HttpParameterDescriptor>()
{
CallBase = true
};
Mock <HttpParameterBinding> mockParameterBinding = new Mock <HttpParameterBinding>(mockParameterDescriptor.Object)
{
CallBase = true
};
HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object });
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
controllerContext.ControllerDescriptor = controllerDescriptor;
Mock <IActionValueBinder> mockBinder = new Mock <IActionValueBinder>()
{
CallBase = true
};
mockBinder.Setup(b => b.GetBinding(It.IsAny <HttpActionDescriptor>())).Returns(actionBinding);
ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, new TestTraceWriter());
// Act
HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object);
// Assert
Assert.IsType <HttpActionBindingTracer>(actualBinding);
Assert.Same(mockActionDescriptor.Object, actualBinding.ActionDescriptor);
}
