Pass multiple complex objects to a post/put Web API method

In the current version of Web API, the usage of multiple complex objects (like your Content and Config complex objects) within the Web API method signature is not allowed. I'm betting good money that config (your second parameter) is always coming back as NULL. This is because only one complex object can be parsed from the body for one request. For performance reasons, the Web API request body is only allowed to be accessed and parsed once. So after the scan and parsing occurs of the request body for the "content" parameter, all subsequent body parses will end in "NULL". So basically:

• Only one item can be attributed with [FromBody].
• Any number of items can be attributed with [FromUri].

Below is a useful extract from Mike Stall's excellent blog article (oldie but goldie!). You'll want to pay attention to item 4:

Here are the basic rules to determine whether a parameter is read with model binding or a formatter:

1. If the parameter has no attribute on it, then the decision is made purely on the parameter's .NET type. "Simple types" use model binding. Complex types use the formatters. A "simple type" includes: primitives, TimeSpan, DateTime, Guid, Decimal, String, or something with a TypeConverter that converts from strings.
2. You can use a [FromBody] attribute to specify that a parameter should be from the body.
3. You can use a [ModelBinder] attribute on the parameter or the parameter's type to specify that a parameter should be model bound. This attribute also lets you configure the model binder. [FromUri] is a derived instance of [ModelBinder] that specifically configures a model binder to only look in the URI.
4. The body can only be read once. So if you have 2 complex types in the signature, at least one of them must have a [ModelBinder] attribute on it.

It was a key design goal for these rules to be static and predictable.

A key difference between MVC and Web API is that MVC buffers the content (e.g. request body). This means that MVC's parameter binding can repeatedly search through the body to look for pieces of the parameters. Whereas in Web API, the request body (an HttpContent) may be a read-only, infinite, non-buffered, non-rewindable stream.

You can read the rest of this incredibly useful article on your own so, to cut a long story short, what you're trying to do is not currently possible in that way (meaning, you have to get creative). What follows is not a solution, but a workaround and only one possibility; there are other ways.

Solution/Workaround

(Disclaimer: I've not used it myself, I'm just aware of the theory!)

One possible "solution" is to use the JObject object. This objects provides a concrete type specifically designed for working with JSON.

You simply need to adjust the signature to accept just one complex object from the body, the JObject, let's call it stuff. Then, you manually need to parse properties of the JSON object and use generics to hydrate the concrete types.

For example, below is a quick'n'dirty example to give you an idea:

public void StartProcessiong([FromBody]JObject stuff){  // Extract your concrete objects from the json object.  var content = stuff["content"].ToObject<Content>();  var config = stuff["config"].ToObject<Config>();  . . . // Now do your thing!}

I did say there are other ways, for example you can simply wrap your two objects in a super-object of your own creation and pass that to your action method. Or you can simply eliminate the need for two complex parameters in the request body by supplying one of them in the URI. Or ... well, you get the point.

Let me just reiterate I've not tried any of this myself, although it should all work in theory.

As @djikay mentioned, you cannot pass multiple FromBody parameters.

One workaround I have is to define a CompositeObject,

public class CompositeObject{    public Content Content { get; set; }    public Config Config { get; set; }}

and have your WebAPI takes this CompositeObject as the parameter instead.

public void StartProcessiong([FromBody] CompositeObject composite){ ... }

You could try posting multipart content from the client like this:

 using (var httpClient = new HttpClient()){    var uri = new Uri("http://example.com/api/controller"));    using (var formData = new MultipartFormDataContent())    {        //add content to form data        formData.Add(new StringContent(JsonConvert.SerializeObject(content)), "Content");        //add config to form data        formData.Add(new StringContent(JsonConvert.SerializeObject(config)), "Config");        var response = httpClient.PostAsync(uri, formData);        response.Wait();        if (!response.Result.IsSuccessStatusCode)        {            //error handling code goes here        }    }}

On the server side you could read the the content like this:

public async Task<HttpResponseMessage> Post(){    //make sure the post we have contains multi-part data    if (!Request.Content.IsMimeMultipartContent())    {        throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);    }    //read data    var provider = new MultipartMemoryStreamProvider();    await Request.Content.ReadAsMultipartAsync(provider);    //declare backup file summary and file data vars    var content = new Content();    var config = new Config();    //iterate over contents to get Content and Config    foreach (var requestContents in provider.Contents)    {        if (requestContents.Headers.ContentDisposition.Name == "Content")        {            content = JsonConvert.DeserializeObject<Content>(requestContents.ReadAsStringAsync().Result);        }        else if (requestContents.Headers.ContentDisposition.Name == "Config")        {            config = JsonConvert.DeserializeObject<Config>(requestContents.ReadAsStringAsync().Result);        }    }    //do something here with the content and config and set success flag    var success = true;    //indicate to caller if this was successful    HttpResponseMessage result = Request.CreateResponse(success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError, success);    return result;}

}