Web API with complex array parameters

Sounds like a good scenario for a custom binder. You can process and detect your incoming data yourself and pass it to your type for use in your controller. No need to fight with built-in types.

See here .

From the page (to keep the answer on SO):

Model links

A more flexible option than a type converter is to create a custom binder model. With a model binder, you access things like the HTTP request, the action description, and the raw values ​​from the route data.

To create a model binder, follow the IModelBinder interface. This interface defines one method, BindModel:

bool BindModel(HttpActionContext actionContext, ModelBindingContext
bindingContext); 

      

        
        
        
      

    

Here is an example of a linking object for GeoPoint objects.

public class GeoPointModelBinder : IModelBinder {
// List of known locations.
private static ConcurrentDictionary<string, GeoPoint> _locations
    = new ConcurrentDictionary<string, GeoPoint>(StringComparer.OrdinalIgnoreCase);

static GeoPointModelBinder()
{
    _locations["redmond"] = new GeoPoint() { Latitude = 47.67856, Longitude = -122.131 };
    _locations["paris"] = new GeoPoint() { Latitude = 48.856930, Longitude = 2.3412 };
    _locations["tokyo"] = new GeoPoint() { Latitude = 35.683208, Longitude = 139.80894 };
}

public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
{
    if (bindingContext.ModelType != typeof(GeoPoint))
    {
        return false;
    }

    ValueProviderResult val = bindingContext.ValueProvider.GetValue(
        bindingContext.ModelName);
    if (val == null)
    {
        return false;
    }

    string key = val.RawValue as string;
    if (key == null)
    {
        bindingContext.ModelState.AddModelError(
            bindingContext.ModelName, "Wrong value type");
        return false;
    }

    GeoPoint result;
    if (_locations.TryGetValue(key, out result) || GeoPoint.TryParse(key, out result))
    {
        bindingContext.Model = result;
        return true;
    }

    bindingContext.ModelState.AddModelError(
        bindingContext.ModelName, "Cannot convert value to Location");
    return false;
} } A model binder gets raw input values from a value provider. This design separates two distinct functions:

      

        
        
        
      

    

The value provider accepts an HTTP request and populates a dictionary of key-value pairs. The model binder uses this vocabulary to populate the model. The Web API Default Provider gets values ​​from route data and query string. For example, if the URI is http: // localhost / api / values ​​/ 1? Location = 48, -122 , the value provider generates the following key-value pairs:

id = "1" location = "48,122" (I accept the default route template, which is "api / {controller} / {id}".)

The parameter name for the binding is stored in the ModelBindingContext.ModelName Property. The model binder searches the dictionary for a key with this value. If the value exists and can be converted to a GeoPoint, the model binding sets the associated value to the ModelBindingContext.Model property.

Note that the model binder is not limited to a simple type conversion. In this example, the model binder first looks in the table from known locations, and if that fails, it uses type conversion.

Setting model binding

There are several ways to set a model binding. First, you can add [ModelBinder] to the parameter.

public HttpResponseMessage
Get([ModelBinder(typeof(GeoPointModelBinder))] GeoPoint location) 

      

        
        
        
      

    

You can also add the [ModelBinder] attribute to the type. The Web API will use the specified binder for all parameters of this type.

[ModelBinder(typeof(GeoPointModelBinder))] public class GeoPoint {
// .... }