Why does POST parameter type have to be generic Object type?

Question

Using asp.net web api v2, I have a working POST method that I am able to POST a custom type from a different application, and by using JSONConvert I am able to deserialize it and use it in my POST method body.

However, the parameter to my POST must be of type "object" or else the parameter is not found (null).

Why does this happen? I would ideally have the custom type as the parameter type, so that my API Documentation can populate with the proper request info, since it auto-generates the API docs based on the parameter type used (don't see a way to override that -- would be great if that was possible).

See my code below -- if "incomingInformation" is of type "RemoteFileInfo" rather than type "object", a null exception is thrown when I try to .toString() it.

[Route("api/xx/uploadfiletoalfresco/")]
    [HttpPost()]
    public ResultStruct UploadFileToAlfresco(object incomingInformation)
    {
        JObject deserializedJObject = (JObject)JsonConvert.DeserializeObject(incomingInformation.ToString());
        SA.Services.RemoteFileInfo convertedRemoteFileInfo = deserializedJObject.ToObject<SA.Services.RemoteFileInfo>();
...

Here is my sample code on the sending application (vb.net) - the content type is set as application/json and is serialized before sending

Dim req As WebRequest = WebRequest.Create(_restEndpointURL & "/uploadfiletoalfresco/")
    req.ContentType = "application/json"
    req.Method = "POST"
    Using sw As New StreamWriter(req.GetRequestStream())
        Dim ser As New JavaScriptSerializer
        Dim serJSON = ser.Serialize(JsonConvert.SerializeObject(remoteFileInfo))
        sw.Write(serJSON)
        sw.Flush()
        sw.Close()
    End Using

Below is my remoteFileInfo type, it is declared this way on both the receiving app and sending app. It is converted to JSON string before sending by the method JsonConvert.SerializeObject

Partial Public Class RemoteFileInfo
    Public CategoryID As Integer
    Public FileName As String
    Public Length As Long
    Public Note As String
    Public SFSubmissionID As String
    Public SourceInstance As String
    Public Subject As String
    Public UserID As Integer
    Public Visibility As Boolean
    Public riskID As Integer
    Public fileByteArray As Byte()
End Class

Receiving app definition:

 public class RemoteFileInfo
{

    public int CategoryID;
    public string FileName;
    public long Length;
    public string Note;
    public string SFSubmissionID;
    public string SourceInstance;
    public string Subject;
    public int UserID;
    public bool Visibility;
    public int riskID;
    public Byte[] fileByteArray;
}

Sample JSON from the sending application:

"{"CategoryID":2,"FileName":"Scrum postponed until this afternoon .msg","Length":62976,"Note":"asdf","SFSubmissionID":"006E000000OuYxP","SourceInstance":"Addin","Subject":"Scrum postponed until this afternoon ","UserID":0,"Visibility":true,"riskID":0,"fileByteArray":"VERY LONG STRING"}"

Full JSON from fiddler:

POST http://yyyy/api/xxx/uploadfiletoalfresco/ HTTP/1.1
Content-Type: application/json
Host: yyyyy
Content-Length: 84273
Expect: 100-continue
Connection: Keep-Alive

"{\"CategoryID\":2,\"FileName\":\"Scrum postponed until this afternoon .msg\",\"Length\":62976,\"Note\":\"asdf\",\"SFSubmissionID\":\"006E000000OuYxP\",\"SourceInstance\":\"Addin\",\"Subject\":\"Scrum postponed until this afternoon \",\"UserID\":0,\"Visibility\":true,\"riskID\":0,\"fileByteArray\":\"VERY LONG STRING - user edited this is not how it looks in fiddler!\"}"

Answer 1

The reason for a such behaviour is that your parameters must be transportable via the request string. In your Route attribute you are saying that the request for your method should be like this: api/xx/uploadfiletoalfresco/. And there is no way the browser will be available to create a string representation for your object in a query string - this can be done only for a strings or value types such as integers.

So you have two choices: let the things stay as they are or use the WCF services, where you can provide a WSDL for your types.

Answer 2

I just tested this with WebAPI 2 using the data you supplied in your post, and using string for fileByteArray and declaring the model as RemoteFileInfo works just fine for me.

 public class RemoteFileInfo
    {

        public int CategoryID;
        public string FileName;
        public long Length;
        public string Note;
        public string SFSubmissionID;
        public string SourceInstance;
        public string Subject;
        public int UserID;
        public bool Visibility;
        public int riskID;
        public string fileByteArray;
    }


    public class ValuesController : ApiController
    {
        [HttpPost]
        public string Test(object incomingInformation)
        {
            JObject deserializedJObject = (JObject)JsonConvert.DeserializeObject(incomingInformation.ToString());
            var convertedRemoteFileInfo = deserializedJObject.ToObject<RemoteFileInfo>();
            return convertedRemoteFileInfo.fileByteArray;
        }
    }

No manual deserialisation required to bind the model

Actually if you do use string then the Web API model binder will do all of the work for you:

 [HttpPost]
 public string Test(RemoteFileInfo incomingInformation)
 {
      return incomingInformation.fileByteArray; //or whatever
 }

But, you will need to do some conversion from RemoteFileInfo (which is just a DTO and therefore should really never leave the API Controller) to another class if you really need fileByteArray to be an array of Byte[] before you process it.

You could write a custom model binder but I think it's simpler to accept the simpler model and convert explicitly.

Update

I think there may be a bit of confusion about my answer so I'll attempt to clarify my thinking and what I think is going on in this case.

1. WebAPI Model Binder is looking at the POST data and then trying to see if it can fit it into the parameter type declared on the Action method. In the case that this is object then that will work and so that allows it to supply a non-null object instance to the method in the form of incomingInformation

2. Your code is manually handling serialisation and obviously JsonConvert is able to handle converting a string to a Byte[]

3. The reason why you are seeing failure when trying to declare incomingInformation as type RemoteFileInfo is because the default WebAPI Model Binder is not able to handle a conversion of string->Byte[] and therefore gives up trying to serialise the incoming POST Data into an instance of RemoteFileInfo and instead passes null to the method's incomingInformation parameter.

4. At that point of course any attempt to refer to or perform any action on incomingInformation will fail with NullReferenceException and so on.

5. The only way to get the Web API Model binder to sucessfully bind that model is a)change fileByteArray to a string (because it is a string on the wire) in which case my second code sample should just work, or b) write a custom Model Binder (personally, not a fan)

I could of course be totally wrong but since your code works fine for me using Fiddler with the chanes I mentioned, I suspect that the points above are the situation or that there is some other factor you haven't included here.

Answer 3

Thanks to all who commented. It turns out the problem was something to do with using the JsonConvert.SerializeObject. Although in Fiddler the json string looked perfect, when on a whim I switched serialization methods to JavaScriptSerializer().Serialize, the RemoteFileInfo object is successfully passed and received (with full byte array in tact!)

Here is the final code of my request, which will allow the receiving app to have the RemoteFileInfo as the parameter type. Still not sure why the JsonConvert.Serialize won't work; the Newstonsoft package was installed on both the client and receiving app.

var httpWebRequest = (HttpWebRequest)WebRequest.Create(@"http://yyyy/api/xxx/uploadfiletoalfresco/");
            httpWebRequest.ContentType = "application/json";
            httpWebRequest.Method = "POST";

            using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
            {
                string json = new JavaScriptSerializer().Serialize(remoteFileInfo);
                streamWriter.Write(json);
            }

            var response = (HttpWebResponse)httpWebRequest.GetResponse();
            using (var streamReader = new StreamReader(response.GetResponseStream()))
            {
                var result = streamReader.ReadToEnd();
            }