Understanding Routing in ASP.NET Core MVC: A Technical Guide

Introduction:
Routing is a fundamental feature of ASP.NET Core MVC, responsible for mapping incoming HTTP requests to the appropriate controller actions. The framework provides a powerful and flexible routing system that allows you to define how URLs map to actions and how route data is handled. In this article, we will dive deep into the routing mechanism in ASP.NET Core MVC, explore different types of routes, and provide examples to demonstrate how to configure and customize routing.

---

1. Overview of Routing in ASP.NET Core MVC

In ASP.NET Core MVC, routing is used to define URL patterns and how they map to controller actions. Routing works by matching incoming URLs to predefined patterns and extracting route values from them. These route values are then passed to the controller action, allowing the correct method to be invoked.

ASP.NET Core MVC uses two main types of routing:

• Convention-based routing: Defines routes in the Startup.cs file using UseRouting and MapControllerRoute.
• Attribute-based routing: Applies routing attributes directly to controller actions to define routes.

We’ll explore both methods in detail with examples.

---

2. Convention-Based Routing

Convention-based routing is configured in the Startup.cs file, and it applies globally across the application. To define a convention-based route, you need to configure the routing middleware in the Configure method.

Here’s a basic example of setting up a default route:

Example: Basic Route Setup

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

In this example:

• The pattern {controller=Home}/{action=Index}/{id?} defines a default route for the application. If no controller is specified in the URL, it defaults to the HomeController. Similarly, if no action is specified, it defaults to the Index action.
• The {id?} indicates that the id parameter is optional.

Example: Custom Route with Constraints

You can create custom routes with constraints to enforce specific rules for route parameters. For example, if you want the id parameter to always be an integer, you can use a route constraint:

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "custom",
        pattern: "{controller=Product}/{action=Details}/{id:int?}");
});

In this example:

• The :int constraint ensures that the id parameter is an integer. If a non-integer value is provided in the URL, the route won’t match.

---

3. Attribute-Based Routing

Attribute-based routing allows you to define routes directly on controller actions using attributes. This provides more control and flexibility, as you can apply routes on a per-controller or per-action basis.

Example: Basic Attribute Routing

[Route("products")]
public class ProductController : Controller
{
    [Route("")]
    [Route("index")]
    public IActionResult Index()
    {
        return View();
    }

    [Route("{id}")]
    public IActionResult Details(int id)
    {
        // Fetch product details by id
        return View();
    }
}

In this example:

• The ProductController is assigned a base route of products. Any actions in this controller will be prefixed with this route.
• The Index action is accessible via /products or /products/index.
• The Details action is accessible via /products/{id}, where {id} is a required route parameter.

Example: Route with HTTP Verb Constraints

You can also restrict routes to specific HTTP methods using attributes like [HttpGet], [HttpPost], etc.

[Route("orders")]
public class OrderController : Controller
{
    [HttpGet("{id}")]
    public IActionResult GetOrder(int id)
    {
        // Fetch and return order by id
        return View();
    }

    [HttpPost]
    public IActionResult CreateOrder(OrderModel model)
    {
        // Create new order
        return RedirectToAction("GetOrder", new { id = model.Id });
    }
}

In this example:

• The GetOrder action will only respond to GET requests at the URL /orders/{id}.
• The CreateOrder action will handle POST requests to create new orders.

---

4. Route Constraints and Custom Constraints

ASP.NET Core provides several built-in route constraints to control how routes are matched. Some common constraints include:

• int: Ensures the parameter is an integer.
• bool: Ensures the parameter is a boolean value.
• guid: Ensures the parameter is a valid GUID.
• length(min, max): Ensures the parameter has a length within a specified range.

Example: Using Built-in Constraints

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id:int:min(1)}");
});

This route only matches if the id is an integer greater than or equal to 1.

Custom Route Constraints

You can also create custom constraints by implementing the IRouteConstraint interface.

public class CustomIdConstraint : IRouteConstraint
{
    public bool Match(HttpContext httpContext, IRouter route, string routeKey, RouteValueDictionary values, RouteDirection routeDirection)
    {
        if (values.TryGetValue(routeKey, out var value) && value != null)
        {
            string stringValue = Convert.ToString(value);
            return stringValue.StartsWith("CUST");
        }
        return false;
    }
}

In this example, the CustomIdConstraint ensures that the id parameter starts with “CUST”.

To use this custom constraint, register it in the Startup.cs:

services.AddRouting(options =>
{
    options.ConstraintMap.Add("customId", typeof(CustomIdConstraint));
});

Then, apply it to a route:

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "custom",
        pattern: "{controller=Customer}/{action=Details}/{id:customId}");
});

This ensures that the Details action is only invoked if the id parameter starts with “CUST”.

---

5. Route Parameters and Query Strings

In addition to defining route parameters, you can handle query strings in ASP.NET Core MVC. Query strings don’t need to be explicitly defined in routes but can still be accessed in controller actions.

Example: Accessing Query Strings

public class ProductController : Controller
{
    public IActionResult Search(string query)
    {
        // Handle search logic using query string
        return View();
    }
}

This action can be accessed via /products/search?query=phone, and the query parameter will be available in the action method.

---

6. Generating URLs with Routing Helpers

ASP.NET Core MVC provides helper methods like Url.Action and Html.ActionLink to generate URLs based on routing.

Example: Using Url.Action

<a href="@Url.Action("Details", "Product", new { id = 5 })">View Product</a>

This generates a URL that maps to the ProductController‘s Details action with an id of 5.

Example: Using Html.ActionLink

@Html.ActionLink("View Product", "Details", "Product", new { id = 5 }, null)

This generates an anchor tag (<a>) that links to the Details action of the ProductController.

---

7. Route Priority and Ordering

When defining multiple routes, it’s important to understand that ASP.NET Core MVC matches routes in the order they are registered. More specific routes should be placed before more general routes.

Example: Route Ordering

app.UseEndpoints(endpoints =>
{
    // More specific route
    endpoints.MapControllerRoute(
        name: "specific",
        pattern: "products/details/{id}",
        defaults: new { controller = "Product", action = "Details" });

    // General route
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
});

In this example, the more specific products/details/{id} route is placed before the default route to ensure it is matched first.

---

Conclusion:

Routing in ASP.NET Core MVC is a powerful and flexible mechanism for mapping URLs to controller actions. Whether using convention-based routing or attribute-based routing, developers can define complex URL patterns, enforce constraints, and customize route behavior to suit their application’s needs. Understanding how to configure routes, apply constraints, and generate URLs is essential for building efficient and maintainable ASP.NET Core MVC applications.

By leveraging the routing system effectively, you can create clean, human-readable URLs that provide a great user experience and simplify navigation within your application.