Mvc-style parameter binding in Web Api 2?

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 (e.g. {\"name\":\"value\"}) into type 'System.Net.Http.Formatting.FormDataCollection' because the type requires a JSON array (e.g. [1,2,3]) to deserialize correctly.\r\nTo fix this error either change the JSON to a JSON array (e.g. [1,2,3]) or change the deserialized type so that it is a normal .NET type (e.g. 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.

Show the use case that the binder is suppose to satisfy. What would the Controller.Action look like — Nkosi
– Nkosi, Commented Apr 27, 2016 at 14:59
@Nkosi I updated the OP to include the controller action, etc. — BBauer42
– BBauer42, Commented Apr 27, 2016 at 15:07
Given that the creditLimit should be populated based on your details, if the accountId parameter in the url is expected to be the same in the incoming model (request) then why not set it in the body of the action itself. i.e: request.AccountId = accountId;. I'm assuming that you want that property populated in the model without having to put it in the body of the PUT request — Nkosi
– Nkosi, Commented Apr 27, 2016 at 15:29
Thats what I'm doing now but its cumbersome. Some of my endpoints look like this: api/accounts/{id:int}/contacts/{cId:int}/notification/{nId:int}. Now in the action body I would have to remember to assign those three properties. This is a large project with hundreds of endpoints. I don't want to have to remember to assign all of these properties in every action. I need a binder to do it automatically. — BBauer42
– BBauer42, Commented Apr 27, 2016 at 15:34
And you believe including it in the request body and url to be redundant? Have you reviewed the following article already? asp.net/web-api/overview/formats-and-model-binding/… — Nkosi
– Nkosi, Commented Apr 27, 2016 at 15:36

Ermiar · Accepted Answer · 2019-02-14 15:28:00Z

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.

Vivek N · Accepted Answer · 2016-04-27 17:27:29Z

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

Collectives™ on Stack Overflow

Mvc-style parameter binding in Web Api 2?

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related