internal static bool WillReadUri( this HttpParameterBinding parameterBinding )
{
if ( parameterBinding is not IValueProviderParameterBinding valueProviderParameterBinding )
{
return false;
}
var valueProviderFactories = valueProviderParameterBinding.ValueProviderFactories;
if ( valueProviderFactories.Any() && valueProviderFactories.All( factory => factory is IUriValueProviderFactory ) )
{
return true;
}
return false;
}
public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
{
var perRequestFormatters = new List <MediaTypeFormatter>();
foreach (MediaTypeFormatter formatter in _formatters)
{
MediaTypeFormatter perRequestFormatter = formatter.GetPerRequestFormatterInstance(Descriptor.ParameterType, actionContext.Request, actionContext.Request.Content.Headers.ContentType);
perRequestFormatters.Add(perRequestFormatter);
}
HttpParameterBinding innerBinding = CreateInnerBinding(perRequestFormatters);
Contract.Assert(innerBinding != null);
return(innerBinding.ExecuteBindingAsync(metadataProvider, actionContext, cancellationToken));
}
private static ApiParameterDescription CreateParameterDescriptionFromBinding(HttpParameterBinding parameterBinding)
{
Contract.Requires(parameterBinding != null);
var parameterDescription = CreateParameterDescriptionFromDescriptor(parameterBinding.Descriptor);
if (parameterBinding.WillReadBody)
{
parameterDescription.Source = ApiParameterSource.FromBody;
}
else if (parameterBinding.WillReadUri())
{
parameterDescription.Source = ApiParameterSource.FromUri;
}
return(parameterDescription);
}
public static bool WillReadUri(this HttpParameterBinding parameterBinding)
{
Contract.Requires(parameterBinding != null);
var valueProviderParameterBinding = parameterBinding as IValueProviderParameterBinding;
if (valueProviderParameterBinding != null)
{
var valueProviderFactories = valueProviderParameterBinding.ValueProviderFactories;
var providerFactories = valueProviderFactories as IList <ValueProviderFactory> ?? valueProviderFactories.ToList();
if (providerFactories.Any() && providerFactories.All(factory => factory is IUriValueProviderFactory))
{
return(true);
}
}
return(false);
}
public void ParameterBindings_Uses_Inners()
{
// Arrange
HttpActionBinding binding = new Mock <HttpActionBinding>()
{
CallBase = true
}.Object;
HttpParameterBinding[] parameterBindings = new HttpParameterBinding[0];
binding.ParameterBindings = parameterBindings;
HttpActionBindingTracer tracer = new HttpActionBindingTracer(
binding,
new TestTraceWriter()
);
// Assert
Assert.Same(parameterBindings, tracer.ParameterBindings);
}
// 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);
}
private ApiParameterDescription CreateParameterDescriptionFromBinding(
HttpParameterBinding parameterBinding
)
{
ApiParameterDescription parameterDescription = CreateParameterDescriptionFromDescriptor(
parameterBinding.Descriptor
);
if (parameterBinding.WillReadBody)
{
parameterDescription.Source = ApiParameterSource.FromBody;
}
else if (parameterBinding.WillReadUri())
{
parameterDescription.Source = ApiParameterSource.FromUri;
}
return(parameterDescription);
}
public static bool WillReadUri(this HttpParameterBinding parameterBinding)
{
if (parameterBinding == null)
{
throw Error.ArgumentNull("parameterBinding");
}
ModelBinderParameterBinding modelParameterBinding = parameterBinding as ModelBinderParameterBinding;
if (modelParameterBinding != null)
{
if (modelParameterBinding.ValueProviderFactories.All(factory => factory is IUriValueProviderFactory))
{
return(true);
}
}
return(false);
}
public void Decorator_GetInner_On_HttpParameterBindingTracer_Returns_HttpParameterBinding()
{
// Arrange
Mock <HttpParameterDescriptor> mockParamDescriptor = new Mock <HttpParameterDescriptor>()
{
CallBase = true
};
mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
HttpParameterBinding expectedInner = new Mock <HttpParameterBinding>(mockParamDescriptor.Object).Object;
HttpParameterBindingTracer productUnderTest = new HttpParameterBindingTracer(expectedInner, new TestTraceWriter());
// Act
HttpParameterBinding actualInner = Decorator.GetInner(productUnderTest as HttpParameterBinding);
// Assert
Assert.Same(expectedInner, actualInner);
}
public void Add_with_type_match()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
HttpParameterBinding mockBinding = new EmptyParameterBinding();
pb.Add(typeof(string), param => mockBinding);
// Act
HttpParameterBinding b1 = pb.LookupBinding(
CreateParameterDescriptor(typeof(string), "first")
);
HttpParameterBinding b2 = pb.LookupBinding(
CreateParameterDescriptor(typeof(int), "first")
);
// Assert
Assert.Equal(mockBinding, b1);
Assert.Null(b2); // doesn't match type, misses.
}
/// <summary>
/// Determines if a parameter will be read from the URI.
/// </summary>
/// <param name="parameterBinding">The parameter binding.</param>
public static bool WillReadUri(this HttpParameterBinding parameterBinding)
{
if (parameterBinding == null)
{
return(false);
}
IValueProviderParameterBinding valueProviderParameterBinding = parameterBinding as IValueProviderParameterBinding;
if (valueProviderParameterBinding != null)
{
IEnumerable <ValueProviderFactory> valueProviderFactories = valueProviderParameterBinding.ValueProviderFactories;
if (valueProviderFactories.Any() && valueProviderFactories.All(factory => factory is QueryStringValueProviderFactory || factory is RouteDataValueProviderFactory))
{
return(true);
}
}
return(false);
}
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 static bool WillReadUri(this HttpParameterBinding parameterBinding)
{
if (parameterBinding == null)
{
throw new ArgumentNullException("parameterBinding");
}
IValueProviderParameterBinding valueProviderParameterBinding = parameterBinding as IValueProviderParameterBinding;
if (valueProviderParameterBinding != null)
{
IEnumerable <ValueProviderFactory> valueProviderFactories = valueProviderParameterBinding.ValueProviderFactories;
if (valueProviderFactories.Any() && valueProviderFactories.All(factory => factory is IUriValueProviderFactory))
{
return(true);
}
}
return(false);
}
ApiParameterDescription CreateParameterDescriptionFromBinding(HttpParameterBinding parameterBinding)
{
Contract.Requires(parameterBinding != null);
Contract.Ensures(Contract.Result <ApiParameterDescription>() != null);
var description = CreateParameterDescription(parameterBinding.Descriptor);
if (parameterBinding.WillReadBody)
{
description.Source = FromBody;
return(description);
}
if (WillReadUri(parameterBinding))
{
description.Source = FromUri;
}
return(description);
}
/// <summary>
/// Wills the read URI.
/// </summary>
/// <param name="parameterBinding">The parameter binding.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static bool WillReadUri(this HttpParameterBinding parameterBinding)
{
if (parameterBinding == null)
{
throw new ArgumentNullException("parameterBinding");
}
var parameterBinding1 = parameterBinding as IValueProviderParameterBinding;
if (parameterBinding1 != null)
{
var providerFactories = parameterBinding1.ValueProviderFactories;
// && providerFactories.All(factory => factory is IUriValueProviderFactory))
if (providerFactories.Any())
{
return(true);
}
}
return(false);
}
internal static bool WillReadUri(this HttpParameterBinding parameterBinding)
{
Contract.Requires(parameterBinding != null);
var valueProviderParameterBinding = parameterBinding as IValueProviderParameterBinding;
if (valueProviderParameterBinding == null)
{
return(false);
}
var valueProviderFactories = valueProviderParameterBinding.ValueProviderFactories;
if (valueProviderFactories.Any() && valueProviderFactories.All(factory => factory is IUriValueProviderFactory))
{
return(true);
}
return(false);
}
// Creates wrapping tracers for all HttpParameterBindings
HttpActionBinding IActionValueBinder.GetBinding(HttpActionDescriptor actionDescriptor)
{
HttpActionBinding actionBinding = _innerBinder.GetBinding(actionDescriptor);
HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
HttpParameterBinding[] newParameterBindings = new HttpParameterBinding[parameterBindings.Length];
for (int i = 0; i < newParameterBindings.Length; i++)
{
HttpParameterBinding parameterBinding = parameterBindings[i];
// Itercept FormatterParameterBinding to replace its formatters
FormatterParameterBinding formatterParameterBinding = parameterBinding as FormatterParameterBinding;
newParameterBindings[i] = formatterParameterBinding != null
? (HttpParameterBinding) new FormatterParameterBindingTracer(formatterParameterBinding, _traceWriter)
: (HttpParameterBinding) new HttpParameterBindingTracer(parameterBinding, _traceWriter);
}
HttpActionBinding newActionBinding = new HttpActionBinding(actionDescriptor, newParameterBindings);
return(newActionBinding);
}
protected HttpParameterBinding GetParameterBinding(HttpParameterDescriptor parameter)
{
if (parameter.ParameterBinderAttribute != null)
{
return(parameter.ParameterBinderAttribute.GetBinding(parameter));
}
HttpParameterBinding binding = parameter.Configuration.ParameterBindingRules.LookupBinding(parameter);
if (binding != null)
{
return(binding);
}
if (parameter.ParameterType.IsPrimitive || parameter.ParameterType == typeof(string))
{
return(parameter.BindWithAttribute(new ModelBinderAttribute()));
}
return(new FromBodyAttribute().GetBinding(parameter));
}
// Determine how a single parameter will get bound.
// This is all sync. We don't need to actually read the body just to determine that we'll bind to the body.
protected virtual HttpParameterBinding GetParameterBinding(
HttpParameterDescriptor parameter
)
{
// Attribute has the highest precedence
// Presence of a model binder attribute overrides.
ParameterBindingAttribute attr = parameter.ParameterBinderAttribute;
if (attr != null)
{
return(attr.GetBinding(parameter));
}
// No attribute, so lookup in global map.
ParameterBindingRulesCollection pb = parameter.Configuration.ParameterBindingRules;
if (pb != null)
{
HttpParameterBinding binding = pb.LookupBinding(parameter);
if (binding != null)
{
return(binding);
}
}
// Not explicitly specified in global map or attribute.
// Use a default policy to determine it. These are catch-all policies.
Type type = parameter.ParameterType;
if (TypeHelper.CanConvertFromString(type))
{
// For simple types, the default is to look in URI. Exactly as if the parameter had a [FromUri] attribute.
return(parameter.BindWithAttribute(new FromUriAttribute()));
}
// Fallback. Must be a complex type. Default is to look in body. Exactly as if this type had a [FromBody] attribute.
attr = new FromBodyAttribute();
return(attr.GetBinding(parameter));
}
public static bool WillReadUri(this HttpParameterBinding parameterBinding)
{
if (parameterBinding == null)
{
throw new ArgumentNullException("parameterBinding");
}
IValueProviderParameterBinding valueProviderParameterBinding = parameterBinding as IValueProviderParameterBinding;
if (valueProviderParameterBinding != null)
{
IEnumerable <ValueProviderFactory> valueProviderFactories = valueProviderParameterBinding.ValueProviderFactories;
// since The interface IUriValueProvderFactory is internal, following line of codes is altered
// if (valueProviderFactories.Any() && valueProviderFactories.All(factory => factory is IUriValueProviderFactory))
if (valueProviderFactories.Any() && valueProviderFactories.All(factory => (factory is QueryStringValueProviderFactory) || (factory is RouteDataValueProviderFactory)))
{
return(true);
}
}
return(false);
}
public void VoidReturnTypeThrows()
{
// Arrange
ODataQueryParameterBindingAttribute attribute = new ODataQueryParameterBindingAttribute();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Customer/?$orderby=Name");
HttpConfiguration config = new HttpConfiguration();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
request.SetConfiguration(config);
HttpControllerContext controllerContext = new HttpControllerContext(config, new HttpRouteData(new HttpRoute()), request);
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "CustomerLowLevel", typeof(CustomerHighLevelController));
MethodInfo methodInfo = typeof(CustomerLowLevelController).GetMethod("GetVoidReturn");
ParameterInfo parameterInfo = methodInfo.GetParameters().First();
HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);
HttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
HttpParameterBinding binding = attribute.GetBinding(parameterDescriptor);
// Act & Assert
Assert.Throws <InvalidOperationException>(
() => binding.ExecuteBindingAsync((ModelMetadataProvider)null, actionContext, CancellationToken.None).Wait(),
"Cannot create an EDM model as the action 'GetVoidReturn' on controller 'CustomerLowLevel' has a void return type.");
}
public void Lookup_is_ordered()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
HttpParameterBinding mockBinding1 = new EmptyParameterBinding();
HttpParameterBinding mockBinding2 = new EmptyParameterBinding();
HttpParameterBinding mockBinding3 = new EmptyParameterBinding();
pb.Add(param => param.ParameterName == "first" ? mockBinding1 : null);
pb.Add(param => param.ParameterName == "first" ? mockBinding2 : null);
pb.Add(param => param.ParameterType == typeof(int) ? mockBinding3 : null);
// Act
HttpParameterBinding b1 = pb.LookupBinding(CreateParameterDescriptor(null, "first"));
HttpParameterBinding b2 = pb.LookupBinding(CreateParameterDescriptor(typeof(string), "none"));
HttpParameterBinding b3 = pb.LookupBinding(CreateParameterDescriptor(typeof(int), "first"));
HttpParameterBinding b4 = pb.LookupBinding(CreateParameterDescriptor(typeof(int), "last"));
// Assert
Assert.Equal(mockBinding1, b1);
Assert.Null(b2);
Assert.Equal(mockBinding1, b3);
Assert.Equal(mockBinding3, b4);
}
public void BadReturnTypeThrows(string methodName)
{
// Arrange
ODataQueryParameterBindingAttribute attribute = new ODataQueryParameterBindingAttribute();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Customer/?$orderby=Name");
HttpConfiguration config = new HttpConfiguration();
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
HttpControllerContext controllerContext = new HttpControllerContext(config, new HttpRouteData(new HttpRoute()), request);
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "CustomerLowLevel", typeof(CustomerHighLevelController));
MethodInfo methodInfo = typeof(CustomerLowLevelController).GetMethod(methodName);
ParameterInfo parameterInfo = methodInfo.GetParameters().First();
HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);
HttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
// Act
HttpParameterBinding binding = attribute.GetBinding(parameterDescriptor);
HttpResponseException responseException = Assert.Throws <HttpResponseException>(() =>
binding.ExecuteBindingAsync((ModelMetadataProvider)null, actionContext, CancellationToken.None).Wait());
Assert.Equal(HttpStatusCode.InternalServerError, responseException.Response.StatusCode);
}
public HttpParameterBindingTracer(HttpParameterBinding innerBinding, ITraceWriter traceWriter) : base(innerBinding.Descriptor)
{
InnerBinding = innerBinding;
TraceWriter = traceWriter;
}
private static List <HttpParameterBinding> BindHandlers(List <HttpOperationHandler> handlers, string operationName, int serviceOperationIndex)
{
Fx.Assert(handlers != null, "The 'handlers' parameter should not be null.");
Fx.Assert(operationName != null, "The 'operationName' parameter should not be null.");
List <HttpParameterBinding> pipelineBindings = new List <HttpParameterBinding>();
for (int inHandlerIndex = handlers.Count - 1; inHandlerIndex >= 1; inHandlerIndex--)
{
HttpOperationHandler inHandler = handlers[inHandlerIndex];
HandlerType inHandlerType = GetHandlerType(inHandlerIndex, serviceOperationIndex);
for (int inParamIndex = 0; inParamIndex < inHandler.InputParameters.Count; inParamIndex++)
{
HttpParameter inParam = inHandler.InputParameters[inParamIndex];
List <HttpParameterBinding> bindings = new List <HttpParameterBinding>();
List <HttpParameterBinding> tentativeBindings = new List <HttpParameterBinding>();
for (int outHandlerIndex = inHandlerIndex - 1; outHandlerIndex >= 0; outHandlerIndex--)
{
HttpOperationHandler outHandler = handlers[outHandlerIndex];
HandlerType outHandlerType = GetHandlerType(outHandlerIndex, serviceOperationIndex);
for (int outParamIndex = 0; outParamIndex < outHandler.OutputParameters.Count; outParamIndex++)
{
HttpParameter outParam = outHandler.OutputParameters[outParamIndex];
if (inParam.IsAssignableFromParameter(outParam.Type))
{
HttpParameterBinding binding = new HttpParameterBinding();
binding.InputHandler = inHandler;
binding.InputHandlerIndex = inHandlerIndex;
binding.InputParameter = inParam;
binding.InputParameterIndex = inParamIndex;
binding.InputHandlerType = inHandlerType;
binding.OutputHandler = outHandler;
binding.OutputHandlerIndex = outHandlerIndex;
binding.OutputParameter = outParam;
binding.OutputParameterIndex = outParamIndex;
binding.OutputHandlerType = outHandlerType;
// If their names match or the input is either HttpRequesMessage,
// HttpResponseMessage, or HttpContent, then go ahead and bind
if (string.Equals(outParam.Name, inParam.Name, StringComparison.OrdinalIgnoreCase) ||
HttpTypeHelper.IsHttp(inParam.Type))
{
bindings.Add(binding);
}
else
{
// Otherwise we will tentatively bind if this is
// not a string conversion assignment
if (outParam.Type != TypeHelper.StringType ||
!inParam.ValueConverter.CanConvertFromString)
{
tentativeBindings.Add(binding);
}
}
}
}
}
if (bindings.Count > 0)
{
pipelineBindings.AddRange(bindings);
}
else if (tentativeBindings.Count == 1)
{
pipelineBindings.AddRange(tentativeBindings);
}
else if (tentativeBindings.Count > 1)
{
ThrowForMulitpleTypeOnlyBindings(tentativeBindings, operationName);
}
else
{
ThrowForUnboundParameter(inHandler, inParam, inHandlerType, operationName);
}
}
}
return(pipelineBindings);
}
public FromUriOrBodyParameterBinding(HttpParameterDescriptor desc)
: base(desc)
{
_defaultUriBinding = new FromUriAttribute().GetBinding(desc);
_defaultFormatterBinding = new FromBodyAttribute().GetBinding(desc);
}
public AllRequestParameterBinding(HttpParameterDescriptor descriptor) : base(descriptor)
{
modelBinding = new ModelBinderAttribute().GetBinding(descriptor);
formatterBinding = new FromBodyAttribute().GetBinding(descriptor);
}
public ODataQueryPackager(HttpParameterBinding binding, HttpActionContext context)
{
_binding = binding;
_context = context;
}
private static List<HttpParameterBinding> BindHandlers(List<HttpOperationHandler> handlers, string operationName, int serviceOperationIndex)
{
Fx.Assert(handlers != null, "The 'handlers' parameter should not be null.");
Fx.Assert(operationName != null, "The 'operationName' parameter should not be null.");
List<HttpParameterBinding> pipelineBindings = new List<HttpParameterBinding>();
for (int inHandlerIndex = handlers.Count - 1; inHandlerIndex >= 1; inHandlerIndex--)
{
HttpOperationHandler inHandler = handlers[inHandlerIndex];
HandlerType inHandlerType = GetHandlerType(inHandlerIndex, serviceOperationIndex);
for (int inParamIndex = 0; inParamIndex < inHandler.InputParameters.Count; inParamIndex++)
{
HttpParameter inParam = inHandler.InputParameters[inParamIndex];
List<HttpParameterBinding> bindings = new List<HttpParameterBinding>();
List<HttpParameterBinding> tentativeBindings = new List<HttpParameterBinding>();
for (int outHandlerIndex = inHandlerIndex - 1; outHandlerIndex >= 0; outHandlerIndex--)
{
HttpOperationHandler outHandler = handlers[outHandlerIndex];
HandlerType outHandlerType = GetHandlerType(outHandlerIndex, serviceOperationIndex);
for (int outParamIndex = 0; outParamIndex < outHandler.OutputParameters.Count; outParamIndex++)
{
HttpParameter outParam = outHandler.OutputParameters[outParamIndex];
if (inParam.IsAssignableFromParameter(outParam.Type))
{
HttpParameterBinding binding = new HttpParameterBinding();
binding.InputHandler = inHandler;
binding.InputHandlerIndex = inHandlerIndex;
binding.InputParameter = inParam;
binding.InputParameterIndex = inParamIndex;
binding.InputHandlerType = inHandlerType;
binding.OutputHandler = outHandler;
binding.OutputHandlerIndex = outHandlerIndex;
binding.OutputParameter = outParam;
binding.OutputParameterIndex = outParamIndex;
binding.OutputHandlerType = outHandlerType;
// If their names match or the input is either HttpRequesMessage,
// HttpResponseMessage, or HttpContent, then go ahead and bind
if (string.Equals(outParam.Name, inParam.Name, StringComparison.OrdinalIgnoreCase) ||
HttpTypeHelper.IsHttp(inParam.Type))
{
bindings.Add(binding);
}
else
{
// Otherwise we will tentatively bind if this is
// not a string conversion assignment
if (outParam.Type != TypeHelper.StringType ||
!inParam.ValueConverter.CanConvertFromString)
{
tentativeBindings.Add(binding);
}
}
}
}
}
if (bindings.Count > 0)
{
pipelineBindings.AddRange(bindings);
}
else if (tentativeBindings.Count == 1)
{
pipelineBindings.AddRange(tentativeBindings);
}
else if (tentativeBindings.Count > 1)
{
ThrowForMulitpleTypeOnlyBindings(tentativeBindings, operationName);
}
else
{
ThrowForUnboundParameter(inHandler, inParam, inHandlerType, operationName);
}
}
}
return pipelineBindings;
}
public UserAwareHttpParameterBinding(HttpParameterDescriptor descriptor) : base(descriptor)
{
_httpParameterDescriptor = descriptor;
_paramaterBinding = new FromBodyAttribute().GetBinding(descriptor);
}
//private readonly HttpParameterBinding _formatterBinding;
public QueryFilterParameterBinding(HttpParameterDescriptor descriptor) : base(descriptor)
{
_modelBinding = new ModelBinderAttribute().GetBinding(descriptor);
//_formatterBinding = new FromBodyAttribute().GetBinding(descriptor);
}
