Attribute routing is a way to define routes directly on your controller actions using attributes. This approach provides more control and clarity over the routing configuration compared to conventional routing, allowing developers to specify the exact URL patterns that should map to specific actions. Attribute routing is particularly useful for creating RESTful APIs, where the URL structure often reflects the resource hierarchy.

Key Features of Attribute Routing

• Clarity: Routes are defined alongside the action methods, making it easier to understand the routing logic at a glance.
• Flexibility: You can define complex routing patterns, including route parameters, constraints, and defaults, directly on the action methods.
• RESTful Design: Attribute routing aligns well with RESTful API design principles, allowing for intuitive URL structures that represent resources.

Implementing Attribute Routing in ASP.NET Core

To implement attribute routing in an ASP.NET Core application, follow these steps:

Step 1: Create a Controller

First, create a controller class and decorate it with the [ApiController] attribute and a [Route] attribute to define the base route for the controller.

        
        using Microsoft.AspNetCore.Mvc;

        [ApiController]
        [Route("api/[controller]")]
        public class ProductsController : ControllerBase
        {
            // Action methods will go here
        }
            

Step 2: Define Action Methods with Route Attributes

Next, define action methods within the controller and use route attributes to specify the URL patterns for each action. Below is an example of a controller with various action methods using attribute routing.

        
        [HttpGet]
        public IActionResult GetAll()
        {
            return Ok("Returning all products.");
        }

        [HttpGet("{id}")]
        public IActionResult GetById(int id)
        {
            return Ok($"Returning product with ID: {id}");
        }

        [HttpPost]
        public IActionResult Create([FromBody] string product)
        {
            return CreatedAtAction(nameof(GetById), new { id = 1 }, product);
        }

        [HttpPut("{id}")]
        public IActionResult Update(int id, [FromBody] string product)
        {
            return Ok($"Updated product with ID: {id}");
        }

        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            return Ok($"Deleted product with ID: {id}");
        }
            

Explanation of the Sample Code

In the sample code above:

• Base Route: The [Route("api/[controller]")] attribute specifies that the base route for this controller is api/products, where [controller] is replaced by the controller name without the "Controller" suffix.
• GetAll Action: The [HttpGet] attribute indicates that this action responds to GET requests at the base route api/products.
• GetById Action: The [HttpGet("{id}")] attribute specifies that this action responds to GET requests at api/products/{id}, where {id} is a route parameter.
• Create Action: The [HttpPost] attribute indicates that this action responds to POST requests at api/products.
• Update Action: The [HttpPut("{id}")] attribute specifies that this action responds to PUT requests at api/products/{id}.
• Delete Action: The [HttpDelete("{id}")] attribute specifies that this action responds to DELETE requests at api/products/{id}.

Route Constraints and Defaults

You can also use route constraints and defaults in attribute routing. For example, you can specify that a route parameter must be an integer:

        
        [HttpGet("products/{id:int}")]
        public IActionResult GetProductById(int id)
        {
            return Ok($"Returning product with ID: {id}");
        }
            

In this example, the route will only match if the id parameter is an integer, ensuring that invalid requests are not processed by this action.

Conclusion

Attribute routing in ASP.NET Core provides a powerful and flexible way to define routes directly on controller actions. By using attributes, developers can create clear and maintainable routing configurations that align with RESTful principles. This approach enhances the readability of the code and allows for more intuitive URL structures, making it easier to develop and maintain web APIs.