Pass multiple complex objects to a post put Web API method

Question

Can some please help me to know how to pass multiple objects from a C  console app to Web API controller as shown below   using  var httpClient   new System Net Http HttpClient          httpClient BaseAddress   new Uri ConfigurationManager AppSettings  Url         httpClient DefaultRequestHeaders Accept Clear        httpClient DefaultRequestHeaders Accept Add new MediaTypeWithQualityHeaderValue  application json             var response   httpClient PutAsync  api process StartProcessiong   objectA  objectB       My Web API method is like this   public void StartProcessiong  FromBody Content content   FromBody Config config

User · Answer

Here I found a workaround to pass multiple generic objects (as json) from jquery to a WEB API using JObject, and then cast back to your required specific object type in api controller. This objects provides a concrete type specifically designed for working with JSON.

var combinedObj = {}; 
combinedObj["obj1"] = [your json object 1]; 
combinedObj["obj2"] = [your json object 2];

$http({
       method: 'POST',
       url: 'api/PostGenericObjects/',
       data: JSON.stringify(combinedObj)
    }).then(function successCallback(response) {
         // this callback will be called asynchronously
         // when the response is available
         alert("Saved Successfully !!!");
    }, function errorCallback(response) {
         // called asynchronously if an error occurs
         // or server returns response with an error status.
         alert("Error : " + response.data.ExceptionMessage);
});

and then you can get this object in your controller

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public [OBJECT] PostGenericObjects(object obj)
    {
        string[] str = GeneralMethods.UnWrapObjects(obj);
        var item1 = JsonConvert.DeserializeObject<ObjectType1>(str[0]);
        var item2 = JsonConvert.DeserializeObject<ObjectType2>(str[1]);

        return *something*;
    }

I have made a generic function to unwrap the complex object, so there is no limitation of number of objects while sending and unwrapping. We can even send more than two objects

public class GeneralMethods
{
    public static string[] UnWrapObjects(object obj)
    {
        JObject o = JObject.Parse(obj.ToString());

        string[] str = new string[o.Count];

        for (int i = 0; i < o.Count; i++)
        {
            string var = "obj" + (i + 1).ToString();
            str[i] = o[var].ToString(); 
        }

        return str;
    }

}

I have posted the solution to my blog with a little more description with simpler code to integrate easily.

Pass multiple complex objects to Web API

I hope it would help someone. I would be interested to hear from the experts here regarding the pros and cons of using this methodology.

User · Answer

Best way to pass multiple complex object to webapi services is by using tuple other than dynamic  json string  custom class   HttpClient PostAsJsonAsync  http   Server WebService Controller ServiceMethod number     number     amp name    name  Tuple Create args1  args2  args3  args4      HttpPost   Route  ServiceMethod     ResponseType typeof void    public IHttpActionResult ServiceMethod int number  string name  Tuple lt Class1  Class2  Class3  Class4 gt  args        Class1 c1    Class1 args Item1      Class2 c2    Class2 args Item2      Class3 c3    Class3 args Item3      Class4 c4    Class4 args Item4         do your actions        return Ok        No need to serialize and deserialize passing object while using tuple  If you want to send more than seven complex object create internal tuple object for last tuple argument

User · Answer

Create a Composite object  public class CollectiveObject lt X  Y gt        public X FirstObj       public Y SecondObj     initialize a composite object with any two objects which you willing to send   CollectiveObject lt myobject1  myobject2 gt  collectiveobj                      new CollectiveObject lt myobject1  myobject2 gt                 collectiveobj FirstObj   myobj1              collectiveobj SecondObj   myobj2   Do serialization    var req   JSONHelper JsonSerializer  lt CollectiveObject lt myobject1   myobject2 gt  gt  collectiveobj       your API must be like      Route  quot Add quot      public List lt APIAvailibilityDetails gt  Add  FromBody CollectiveObject lt myobject1  myobject2 gt  collectiveobj          to do

User · Answer

Basically you can send complex object without doing any extra fancy thing  Or without making changes to Web-Api  I mean why would we have to make changes to Web-Api  while the fault is in our code that s calling the Web-Api   All you have to do use NewtonSoft s Json library as following   string jsonObjectA   JsonConvert SerializeObject objectA   string jsonObjectB   JsonConvert SerializeObject objectB   string jSoNToPost   string Format    content     0    config      1     jsonObjectA   jsonObjectB      wrap it around in object container notation jSoNToPost   string Concat      jSoNToPost            convert it to JSON acceptible content HttpContent content   new StringContent jSoNToPost   Encoding UTF8   application json      var response   httpClient PutAsync  api process StartProcessiong   content

User · Answer

Late answer  but you can take advantage of the fact that you can deserialize multiple objects from one JSON string  as long as the objects don t share any common property names       public async Task lt HttpResponseMessage gt  Post HttpRequestMessage request                var jsonString   await request Content ReadAsStringAsync            var content    JsonConvert DeserializeObject lt Content  gt  jsonString           var config    JsonConvert DeserializeObject lt Config gt  jsonString

User · Answer

Here s another pattern that may be useful to you  It s for a Get but the same principle and code applies for a Post Put but in reverse  It essentially works on the principle of converting objects down to this ObjectWrapper class which persists the Type s name to the other side   using Newtonsoft Json  using System  using System Collections Generic   namespace WebAPI       public class ObjectWrapper                region Public Properties         public string RecordJson   get  set            public string TypeFullName   get  set             endregion           region Constructors          public ObjectWrapper     this null  null                               public ObjectWrapper object objectForWrapping    this objectForWrapping  null                               public ObjectWrapper object objectForWrapping  string typeFullName                        if  typeFullName    null  amp  amp  objectForWrapping    null                                TypeFullName   objectForWrapping GetType   FullName                            else                               TypeFullName   typeFullName                             RecordJson   JsonConvert SerializeObject objectForWrapping                      endregion           region Public Methods         public object ToObject                         var type   Type GetType TypeFullName               return JsonConvert DeserializeObject RecordJson  type                      endregion           region Public Static Methods         public static List lt ObjectWrapper gt  WrapObjects List lt object gt  records                        var retVal   new List lt ObjectWrapper gt                 records ForEach              item   gt                                retVal Add                                       new ObjectWrapper item                                                               return retVal                     public static List lt object gt  UnwrapObjects IEnumerable lt ObjectWrapper gt  objectWrappers                        var retVal   new List lt object gt                  foreach var item in objectWrappers                                retVal Add                                       item ToObject                                                 return retVal                     endregion           In the REST code    HttpGet  public IEnumerable lt ObjectWrapper gt  Get         var records   new List lt object gt         records Add new TestRecord1         records Add new TestRecord2         var wrappedObjects   ObjectWrapper WrapObjects records       return wrappedObjects      This is the code on the client side  UWP  using a REST client library  The client library just uses the Newtonsoft Json serialization library - nothing fancy   private static async Task lt List lt object gt  gt  Getobjects         var result   await REST Get lt List lt ObjectWrapper gt  gt   http   localhost 50623 api values        var wrappedObjects    IEnumerable lt ObjectWrapper gt   result Data      var unwrappedObjects    ObjectWrapper UnwrapObjects wrappedObjects       return unwrappedObjects

User · Answer

I know this is an old question  but I had the same issue and here is what I came up with and hopefully will be useful to someone   This will allow passing JSON formatted parameters individually in request URL  GET   as one single JSON object after    GET  or within single JSON body object  POST    My goal was RPC-style functionality   Created a custom attribute and parameter binding  inheriting from HttpParameterBinding      public class JSONParamBindingAttribute   Attribute       public class JSONParamBinding   HttpParameterBinding        private static JsonSerializer  serializer   JsonSerializer Create new JsonSerializerSettings                 DateTimeZoneHandling   DateTimeZoneHandling Utc               public JSONParamBinding HttpParameterDescriptor descriptor            base descriptor                   public override Task ExecuteBindingAsync ModelMetadataProvider metadataProvider                                                  HttpActionContext actionContext                                                  CancellationToken cancellationToken                JObject jobj   GetJSONParameters actionContext Request            object value   null           JToken jTokenVal   null          if   jobj TryGetValue Descriptor ParameterName  out jTokenVal                         if  Descriptor IsOptional                  value   Descriptor DefaultValue              else                 throw new MissingFieldException  Missing parameter       Descriptor ParameterName                     else                       try                               value   jTokenVal ToObject Descriptor ParameterType   serializer                             catch  Newtonsoft Json JsonException e                                throw new HttpParseException String Join      Unable to parse parameter     Descriptor ParameterName     Type     Descriptor ParameterType ToString                                          Set the binding result here         SetValue actionContext  value               now  we can return a completed task with no result         TaskCompletionSource lt AsyncVoid gt  tcs   new TaskCompletionSource lt AsyncVoid gt             tcs SetResult default AsyncVoid            return tcs Task             public static HttpParameterBinding HookupParameterBinding HttpParameterDescriptor descriptor                if  descriptor ActionDescriptor ControllerDescriptor GetCustomAttributes lt JSONParamBindingAttribute gt    Count    0               amp  amp  descriptor ActionDescriptor GetCustomAttributes lt JSONParamBindingAttribute gt    Count    0              return null           var supportedMethods   descriptor ActionDescriptor SupportedHttpMethods           if  supportedMethods Contains HttpMethod Post     supportedMethods Contains HttpMethod Get                         return new JSONParamBinding descriptor                      return null             private JObject GetJSONParameters HttpRequestMessage request                JObject jobj   null          object result   null          if   request Properties TryGetValue  ParamsJSObject   out result                         if  request Method    HttpMethod Post                                jobj   JObject Parse request Content ReadAsStringAsync   Result                             else if  request RequestUri Query StartsWith    7B                                  jobj   JObject Parse HttpUtility UrlDecode request RequestUri Query  TrimStart                                  else                               jobj   new JObject                    foreach  var kvp in request GetQueryNameValuePairs                                          jobj Add kvp Key  JToken Parse kvp Value                                                request Properties Add  ParamsJSObject   jobj                     else                       jobj    JObject result                     return jobj               private struct AsyncVoid                 Inject binding rule inside WebApiConfig cs s Register method              public static void Register HttpConfiguration config                           Web API configuration and services                 Web API routes             config MapHttpAttributeRoutes                 config ParameterBindingRules Insert 0  JSONParamBinding HookupParameterBinding                config Routes MapHttpRoute              name   DefaultApi               routeTemplate    controller   action   id                defaults  new   id   RouteParameter Optional                          This allows for controller actions with default parameter values and mixed complexity  as such    JSONParamBinding       HttpPost  HttpGet      public Widget DoWidgetStuff Widget widget  int stockCount  string comment  no comment                     do stuff  return Widget object         example post body           widget               a   1            b    string             c      other    things                  stockCount   42        comment    sample code       or GET single param  needs URL encoding   controllerPath DoWidgetStuff   widget        comment   test   stockCount  42    or GET multiple param  needs URL encoding   controllerPath DoWidgetStuff widget      amp comment  test  amp stockCount 42

User · Answer

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

User · Answer

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  quot content quot  parameter  all subsequent body parses will end in  quot NULL quot   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   If the parameter has no attribute on it  then the decision is made purely on the parameter s  NET type   quot Simple types quot  use model binding  Complex types use the formatters  A  quot simple type quot  includes  primitives  TimeSpan  DateTime  Guid  Decimal  String  or something with a TypeConverter that converts from strings  You can use a  FromBody  attribute to specify that a parameter should be from the body  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  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  quot solution quot  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  quot content quot   ToObject lt Content gt       var config   stuff  quot config quot   ToObject lt Config gt                 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

User · Answer

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 lt HttpResponseMessage gt  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 lt Content gt  requestContents ReadAsStringAsync   Result                     else if  requestContents Headers ContentDisposition Name     Config                         config   JsonConvert DeserializeObject lt Config gt  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

User · Answer

Create one complex object to combine Content and Config  in it as others mentioned  use dynamic and just do a  ToObject    as    HttpPost  public void StartProcessiong  FromBody  dynamic obj       var complexObj  obj ToObject lt ComplexObj gt        var content   complexObj Content     var config   complexObj Config

[c#] Pass multiple complex objects to a post/put Web API method

Examples related to c#

Examples related to asp.net

Examples related to asp.net-web-api

Examples related to asp.net-web-api2

Examples related to dotnet-httpclient