Web Api 2 中的 Mvc 风格参数绑定？

Question

I am trying to use both FromUri and FromBody in web api 2 to populate an incoming request model. I understand I need to write a custom model binder to do that. Here is the example everyone references . This solution has been incorporated into the WebAPIContrib nuGet pacakge whose source code can be seen here on github .

I'm having trouble getting the MvcActionValueBinder to work with application/json body content. Here is part of the source that is throwing the exception.

class MvcActionBinding : HttpActionBinding
{
    // Read the body upfront , add as a ValueProvider
    public override Task ExecuteBindingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
    {
        HttpRequestMessage request = actionContext.ControllerContext.Request;
        HttpContent content = request.Content;
        if (content != null)
        {
            FormDataCollection fd = content.ReadAsAsync<FormDataCollection>().Result;
            if (fd != null)
            {
                IValueProvider vp = new NameValuePairsValueProvider(fd, CultureInfo.InvariantCulture);
                request.Properties.Add(Key, vp);
            }
        }

        return base.ExecuteBindingAsync(actionContext, cancellationToken);
    }
}

This line is throwing the exception:

FormDataCollection fd = content.ReadAsAsync<FormDataCollection>().Result;

Here is the exception:

System.AggregateException

{"Cannot deserialize the current JSON object (eg {\\"name\\":\\"value\\"}) into type 'System.Net.Http.Formatting.FormDataCollection' because the type requires a JSON array (eg [1,2,3]) to deserialize correctly.\\r\\nTo fix this error either change the JSON to a JSON array (eg [1,2,3]) or change the deserialized type so that it is a normal .NET type (eg not a primitive type like integer, not a collection type like an array or List) that can be deserialized from a JSON object. JsonObjectAttribute can also be added to the type to force it to deserialize from a JSON object.\\r\\nPath 'creditLimit', line 2, position 17."}

How can I get the model binder to work with applciation/json content instead of x-www-form-urlencoded content? Here is a similar question with no answer on the asp.net forums.

Update: Here is the controller method:

[Route("{accountId:int}/creditlimit")]
[HttpPut]
public async Task<IHttpActionResult> UpdateAccountCreditLimit(int accountId, [FromBody] RequestObject request)
{
     // omitted for brevity
}

Here is the RequestObject:

class RequestObject
{
    public int AccountId { get; set; }
    public decimal CreditLimit { get; set; }
}

Here is the postman endpoint to test, its a PUT:

http://localhost/api/accounts/47358/creditlimit

The body I have set to application/json. Here is sample content.

{ "creditLimit": 125000.00 }

And yes, I realize I could change the controller method to do all FromUri or all FromBody instead. I do not have the liberty of doing that. Thanks.

Answer 1

I had the same issue and I think I finally figure this out.

Here is the code :

internal sealed class MvcActionValueBinder : DefaultActionValueBinder
{
    private static readonly Type stringType = typeof(string);

    // Per-request storage, uses the Request.Properties bag. We need a unique key into the bag.
    private const string Key = "5DC187FB-BFA0-462A-AB93-9E8036871EC8";

    private readonly JsonSerializerSettings serializerSettings;

    public MvcActionValueBinder(JsonSerializerSettings serializerSettings)
    {
        this.serializerSettings = serializerSettings;
    }

    public override HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
    {
        var actionBinding = new MvcActionBinding(serializerSettings);

        HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
        HttpParameterBinding[] binders = Array.ConvertAll(parameters, DetermineBinding);

        actionBinding.ParameterBindings = binders;

        return actionBinding;
    }

    private HttpParameterBinding DetermineBinding(HttpParameterDescriptor parameter)
    {
        HttpConfiguration config = parameter.Configuration;
        var attr = new ModelBinderAttribute(); // use default settings

        ModelBinderProvider provider = attr.GetModelBinderProvider(config);
        IModelBinder binder = provider.GetBinder(config, parameter.ParameterType);

        // Alternatively, we could put this ValueProviderFactory in the global config.
        var valueProviderFactories = new List<ValueProviderFactory>(attr.GetValueProviderFactories(config)) { new BodyValueProviderFactory() };
        return new ModelBinderParameterBinding(parameter, binder, valueProviderFactories);
    }

    // Derive from ActionBinding so that we have a chance to read the body once and then share that with all the parameters.
    private class MvcActionBinding : HttpActionBinding
    {
        private readonly JsonSerializerSettings serializerSettings;

        public MvcActionBinding(JsonSerializerSettings serializerSettings)
        {
            this.serializerSettings = serializerSettings;
        }

        // Read the body upfront, add as a ValueProvider
        public override Task ExecuteBindingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            HttpRequestMessage request = actionContext.ControllerContext.Request;
            HttpContent content = request.Content;
            if (content != null)
            {
                string result = request.Content.ReadAsStringAsync().Result;

                if (!string.IsNullOrEmpty(result))
                {
                    var jsonContent = JObject.Parse(result);
                    var values = new Dictionary<string, object>();

                    foreach (HttpParameterDescriptor parameterDescriptor in actionContext.ActionDescriptor.GetParameters())
                    {
                        object parameterValue = GetParameterValue(jsonContent, parameterDescriptor);
                        values.Add(parameterDescriptor.ParameterName, parameterValue);
                    }

                    IValueProvider valueProvider = new NameValuePairsValueProvider(values, CultureInfo.InvariantCulture);
                    request.Properties.Add(Key, valueProvider);
                }
            }

            return base.ExecuteBindingAsync(actionContext, cancellationToken);
        }

        private object GetParameterValue(JObject jsonContent, HttpParameterDescriptor parameterDescriptor)
        {
            string propertyValue = jsonContent.Property(parameterDescriptor.ParameterName)?.Value.ToString();

            if (IsSimpleParameter(parameterDescriptor))
            {
                // No deserialization needed for value type, a cast is enough
                return Convert.ChangeType(propertyValue, parameterDescriptor.ParameterType);
            }

            return JsonConvert.DeserializeObject(propertyValue, parameterDescriptor.ParameterType, serializerSettings);
        }

        private bool IsSimpleParameter(HttpParameterDescriptor parameterDescriptor)
        {
            return parameterDescriptor.ParameterType.IsValueType || parameterDescriptor.ParameterType == stringType;
        }
    }

    // Get a value provider over the body. This can be shared by all parameters.
    // This gets the values computed in MvcActionBinding.
    private class BodyValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(HttpActionContext actionContext)
        {
            actionContext.Request.Properties.TryGetValue(Key, out object vp);
            return (IValueProvider)vp; // can be null 
        }
    }
}

To explain, the trick is to first read the request content as a string and then loading it into a JObject . For each parameter present in actionContext.ActionDescriptor a dictionnary is populated with the parameter name as key and we use the parameter type to add the object value.

Depending on the parameter type we either do a simple cast or use Json.NET to deserialize the value into the desired type. Please note you may need to add special case for value type to manage for example enumerations or Guid .

In my example, I pass around a JsonSerializerSettings because I have some custom converters that I want to use, be you may not need it.

Answer 2

You should be able to achieve this with the default model binding functionality in Web API 2 itself. First thing you need to do is pass the data as JSON string as following.

data: JSON.stringify({ "creditLimit": 125000.00 })

The accountId will be read from the URL and the default JsonFormatter of the Web API 2 will try to bind your second parameter request from the body. It will find the creditLimit and will create an instance of RequestObject with the creditLimit populated.

You can then, inside the controller, assign the accountId value to the RequestObject other property. That way you don't need to pass the accountId as part of your request body. You only pass that as part of your URL endpoint.

The following link is a good resource for more in-depth detail. http://www.asp.net/web-api/overview/formats-and-model-binding/parameter-binding-in-aspnet-web-api