Do not create Web API controllers by deriving from the Controller class. Controller is derived from ControllerBase and adds support for views, so it is used to process Web pages, not Web API requests. There is one exception to this rule: if you intend to use the same Controller for your view and Web API, derive the Controller from the Controller.

The ControllerBase class provides a number of properties and methods for handling HTTP requests.

For example, ControllerBase. CreatedAtAction return 201 status code:

Here are some more examples of the methods ControllerBase provides.

Compatibility version 2.2 or higher is required to use the Problem Details for Error Status Codes feature. You must have compatibility version 2.1 or higher to use other features.

If the compatibility version is set to 2.2 or higher, the [ApiController] property can be applied to an assembly. Annotating in this way applies web API behavior to all controllers in the assembly. The opt-out operation cannot be performed for a single controller. Apply assembly-level properties to namespace declarations on either side of the Startup class:

[assembly: ApiController]
namespace WebApiSample
{
    public class Startup{... }}Copy the code

The [ApiController] property causes model validation errors to automatically trigger HTTP 400 responses. Therefore, the following code is not required in the action method:

if(! ModelState.IsValid) {return BadRequest(ModelState);
}
Copy the code

ASP.NET Core MVC uses the ModelStateInvalidFilter action filter to perform the above checks.

See how to automatically respond to 400 Model validation error logs (aspnet/ aspnetcore.docs #12157).

The binding source property defines where the value of the action parameter can be found. The following binding source features exist:

Without an [ApiController] attribute or a binding source attribute such as [FromQuery], ASP.NET Core runtime tries to use a complex object model binder. The complex object model binder pulls data from the value provider in a defined order.

In the following example, the [FromQuery] feature indicates that discontinuedOnly values are provided in the query string of the request URL:

[HttpGet]
public ActionResult<List<Product>> Get(
    [FromQuery] bool discontinuedOnly = false)
{
    List<Product> products = null;

    if (discontinuedOnly)
    {
        products = _productsInMemoryStore.Where(p => p.IsDiscontinued).ToList();
    }
    else
    {
        products = _productsInMemoryStore;
    }

    return products;
}
Copy the code

The [ApiController] property applies inference rules to the default data source for action parameters. These rules eliminate the need to manually identify binding sources by applying properties to action parameters. Binding source inference rules behave as follows:

• [FromBody]Make inferences for complex type parameters.[FromBody]Does not apply to any complex built-in type with special meaning, such asIFormCollection 和 CancellationToken. The binding source inference code ignores these special types.
• [FromForm]forIFormFile 和 IFormFileCollectionType operation parameters to be inferred. This feature does not infer for any simple or user-defined type.
• [FromRoute]Infer any operation parameter names that match the parameters in the routing template. When multiple routes match an operation parameter, any route value is considered[FromRoute].
• [FromQuery]Extrapolate for any other operational parameters.

If you want to disable the binding source reasoning, please put SuppressInferBindingSourcesForParameters set to true. In the Startup. ConfigureServices to add the following code:

services.AddControllers()
    .ConfigureApiBehaviorOptions(options =>
    {
        options.SuppressConsumesConstraintForFormFileParameters = true;
        options.SuppressInferBindingSourcesForParameters = true;
        options.SuppressModelStateInvalidFilter = true;
        options.SuppressMapClientErrors = true;
        options.ClientErrorMapping[404].Link =
            "https://httpstatuses.com/404";
    });
Copy the code

By default, the operation supports all available request content types. For example, if the application is configured to support both JSON and XML input formatters, the operation supports multiple content types, including Application/JSON and Application/XML.

Using the [Consumes] attribute, the operation limits the types of content for requests that are supported. Applies the [Consumes] property to an operation or controller and specifies one or more content types:

[HttpPost]
[Consumes("application/xml")]
public IActionResult CreateProduct(Product product)
Copy the code

In the above code, the CreateProduct operation specifies the content type Application/XML. Requests routed to this operation must specify the Application/XML content-Type header. If the request does not specify an application/ XML content-type header, a media Type response not supported by 415 is generated.

Using the [Consumes] property, an operation can apply type constraints to affect the selection of an incoming request based on the content type. Take a look at the following example:

[ApiController]
[Route("api/[controller]")]
public class ConsumesController : ControllerBase{[HttpPost]
    [Consumes("application/json")]
    public IActionResult PostJson(IEnumerable<int> values) =>
        Ok(new { Consumes = "application/json", Values = values });

    [HttpPost]
    [Consumes("application/x-www-form-urlencoded")]
    public IActionResult PostForm([FromForm] IEnumerable<int> values) =>
        Ok(new { Consumes = "application/x-www-form-urlencoded", Values = values });
}
Copy the code

In the code above, ConsumesController configured to process request sent to the https://localhost:5001/api/Consumes URL. Both operations on the controller (PostJson and PostForm) use the same URL to process POST requests. If the [Consumes] property does not apply type constraints, it throws an ambiguous match exception.

The [Consumes] property applies to two operations. The PostJson operation handles content-type hair requests using application/ JSON. The PostForm operation handles requests for Content-type hair sent using Application/X-www-form-urlencoded.