ASP.NET Core 6 WebAPI, invalid model does not reach the action method, instead instantly returns with HTTP 400

I've created a WebAPI project in VS 2022, using .NET 6
I've annotated my model's Customer class CustomerId property with [MaxLength(5)] and [MinLength(5)] attributes.

[Route("api/[controller]")]
[ApiController]
public class CustomerController : ControllerBase
{
    private readonly NorthwindContext _ctx;
    // ...
    [HttpPost]
    public Customer Insert(Customer customer)
    {
        // Method never called. Somewhere the pipeline instantly 
        // sends the HTTP 400 response with the correct error message.
        if (!ModelState.IsValid)
        {

        }

If I call the API with invalid data, say 4 or 6 lenght CustomerId, then the Insert method never called. Somewhere the pipeline instantly sends the HTTP 400 response with the correct validation error message

Question

It is not clear, then when will be the ModelState.IsValid false? Can I configure the pipeline to allow the method to be called?

> It is not clear, then when will be the ModelState.IsValid false?

Well, in a nutshell, in MVC controller; if you haven't set any annotation on property by default its required means not null. So if you don't pass the value your ModelState.IsValid will always be false. Usually Model state represents errors that come from two subsystems.

For instances, model binding and model validation which means request firstly goes to the model validator once it meet the condition then it route to the specific controller other than, controller doesn't get hitted.

Thus, your ModelState.IsValid would always be false when any property you would set required and that's value wouldn't be passed while you submitting request for your scenario Insert. So, yes any property without nullable ? would require to pass during request submission, other than your ModelState.IsValid would always be false.

Let's consider, your Customer Class you have set few validation constrains on CustomerId if this is not null; it will firstly reach to model binding and if it doesn't meet your condition it will throw validation message from there and it wouldn't hit controller.

So if you don't pass the value for non nullable property or your property violate any condition it will restrict you from submitting request.

> Why then your ModelState.IsValid doesn't reach?

As you are using Web API controller and in Web API controllers don't have to check ModelState.IsValid if they have the ApiController attribute. In that case, an automatic HTTP 400 response containing error details is returned when model state is invalid.

> Can I configure the pipeline to allow the method to be called?

Of course you can. In that scenario, you have to disable the automatic 400 behavior. You might know ConfigureApiBehaviorOptions within builder.Services.AddControllers and you will get a property called SuppressModelStateInvalidFilter we have to set this property to true. Please have a look on following code snippet:

builder.Services.AddControllers()
    .ConfigureApiBehaviorOptions(options =>
    {
        options.SuppressModelStateInvalidFilter = true;
    });

Output:

Note:

If you would like to know more details on Model state Validation and automatic 400 response you could check our official document here.

With the nullability in .Net 6/.Net 7, the data you send to the Web API has to match the model or this will happen.

public class MyModel
{
	public int SomeId { get; set; }
	public int? ForeignId { get; set; }
	public string? SomeName { get; set; }
	public string RequiredName{ get; set; }
}

MyModel myData = new() 
{
 SomeId = 5,
 ForeignId = 9,
 SomeName = "Test",
 RequiredName = null
}

var myResult = MyWebAPICall(myData);

Since the RequiredName is defined as not nullable, the Web API will reject it and send back the 400.

You have to go through the models / DTO's and make sure what you defined matches your data source (database, etc.) so it will save properly and focus on what fields need to allow nulls. The nullability really forces you to go through everything.