How do I get WebAPI to validate my JSON with JsonProperty(Required = Required.Always)?

Question

public class MyModel
{
    [JsonProperty(PropertyName = "foo", Required = Required.Always)]
    public String Bar;
}

public class MyController : ApiController
{
    public String PostVersion1([FromBody] MyModel myModel)
    {
        if (ModelState.IsValid)
        {
            if (myModel.Bar == null)
                return "What?!";
            else
                return "Input is valid.";
        }
        else
        {
            return "Input is invalid.";
        }
    }
}

Results:

Input              |Output
-------------------|------
{ "bad" : "test" } | What?!
{ "Bar" : "test" } | What?!
{ "foo" : "test" } | Input is valid.

JsonPropertyAttribute is clearly supported because I am able to set the PropertyName and have it take effect. However, I would expect the ModelState.IsValid to be false for the first two example inputs because the Required JsonProprty parameter was set to Always.

If I just run it through JsonConvert:

JsonConvert.DeserializeObject<MyModel>(@"{'bad':'test'}");

an exception is thrown during deserialization as expected:

Result Message: Newtonsoft.Json.JsonSerializationException : Required property 'foo' not found in JSON. Path '', line 1, position 14.

Solution 1

In order to solve this I ended up creating my own custom JSON.NET MediaTypeFormatter. My formatter allows the JSON.NET deserialization exceptions bubble out which results in the exception information being returned to the caller.

Here is the MediaTypeFormatter I built:

public class JsonMediaFormatter : MediaTypeFormatter
{
    private readonly JsonSerializer _jsonSerializer = new JsonSerializer();

    public JsonMediaFormatter()
    {
        SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
    }

    public override Boolean CanReadType(Type type)
    {
        if (type == null)
            return false;

        return true;
    }

    public override Boolean CanWriteType(Type type)
    {
        if (type == null)
            return false;

        return true;
    }

    public override Task<Object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
    {
        return Task.FromResult(Deserialize(readStream, type));
    }

    public override Task WriteToStreamAsync(Type type, Object value, Stream writeStream, HttpContent content, TransportContext transportContext, CancellationToken cancellationToken)
    {
        Serialize(writeStream, value);
        return Task.FromResult(0);
    }

    private Object Deserialize(Stream readStream, Type type)
    {
        var streamReader = new StreamReader(readStream);
        return _jsonSerializer.Deserialize(streamReader, type);
    }

    private void Serialize(Stream writeStream, Object value)
    {
        var streamWriter = new StreamWriter(writeStream);
        _jsonSerializer.Serialize(streamWriter, value);
        streamWriter.Flush();
    }
}

In order to use this formatter over the built-in one, I added this line to my WebApiConfig:

config.Formatters.Insert(0, new Formatters.JsonMediaFormatter());

By inserting it at index 0, it takes precedence over the built-in formatter. If you care, you could remove the built-in JSON formatter.

In this scenario, the ModelState is always valid in the action because an exception is thrown back to the user before the action is ever fired if deserialization fails. More work would need to be done in order to still execute the action with a null FromBody parameter.

Solution 2

The default JsonMediaTypeFormatter does not rely on on he JsonProperty to decide whether model fields are required or not. It does rely however on the RequiredAttribute

If you want to do this then implement a new IRequiredMemberSelector and set it to MediaTypeFormatter.RequiredMemberSelector.

In your implementation of IRequiredMemberSelector you will be passed a MemberInfo. You can use that to evaluate if model members have the JsonProperty attribute and if the required flag is set, and finally return true or false. This will be propagated to the ModelState.IsValid property (it will not use the JSON.NET error message though, but the DataAnnotations/WebApi one.

If you do this, then I suggest you also keep the default behavior.

Solution 3

I know this is an old question but I solved it like this:

var formatter = new JsonMediaTypeFormatter {
    SerializerSettings = {
        ContractResolver = new DefaultContractResolver(true)
    }
};
configuration.Formatters.Insert(0, formatter);

The parsing errors will then be included in ModelState

Solution 4

If you only want to support JSON, then you can do this:

public String PostVersion1([FromBody] JObject json)
{
  if(json == null) {
    // Invalid JSON or wrong Content-Type
    throw new HttpResponseException(HttpStatusCode.BadRequest);
  }

  MyModel model;
  try
  {
    model = json.ToObject<MyModel>();
  }
  catch(JsonSerializationException e)
  {
    // Serialization failed
    throw new HttpResponseException(HttpStatusCode.BadRequest);
  }
}

But you don't want to do this in every request handler. This is one of multiple flaws of the [FromBody] attribute. See here for more details: https://stackoverflow.com/a/52877955/2279059

View more solutions