Understanding Routing and Middleware in ASP.NET Core

In the previous tutorial, we created and ran our first ASP.NET Core application, gaining insight into its fundamental architecture and runtime behavior. This chapter delves deeper into the concept of routing, helping you better understand how ASP.NET Core processes incoming HTTP requests.

What Is Routing?

In ASP.NET Core, routing is a mechanism that maps incoming HTTP requests to specific handlers—such as controllers and action methods. It determines how a request URL should be interpreted and directs the request to the appropriate code path.

Routing relies primarily on the following components:

1. Request URL: The address users specify in their browser to request data.
2. Route Template: A pattern defining the expected URL structure, often including variable segments.
3. Endpoints: The final destinations responsible for handling requests—typically corresponding to action methods within controllers.

How Routing Works—A Basic Overview

The typical routing workflow proceeds as follows:

1. An HTTP request is received.
2. The routing system matches the request’s URL against predefined route templates.
3. Upon finding a matching endpoint, the request is forwarded to its associated handler (e.g., a controller action method).
4. The handler executes its logic and returns an HTTP response to the client.

Example: A Simple Routing Scenario

Suppose we have an ASP.NET Core application with a HomeController containing a basic Index method:

using Microsoft.AspNetCore.Mvc;

namespace MyFirstApp.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return Content("Welcome to the home page");
        }
    }
}

Here, the Index method returns a plain-text response. When you navigate to http://localhost:5000/home/index, ASP.NET Core’s routing system matches this URL and invokes the HomeController.Index method to handle the request.

Configuring Routing

In ASP.NET Core, routing is typically configured in the Startup.cs file—specifically within the Configure method. You’ll commonly see code like this:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

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

The endpoints.MapControllerRoute method defines a route with two key properties:

• Name: A unique identifier for the route—in this case, "default".
• Pattern: The URL structure, composed of placeholders such as {controller}, {action}, and the optional {id}.

This means that when a user visits http://localhost:5000/{controller}/{action}/{id}, ASP.NET Core’s router parses the URL and locates the corresponding controller and action method.

Route Parameters

Routing supports parameters, enabling dynamic data to be passed via the URL. For instance, modify your controller action to accept an id parameter:

public IActionResult Details(int id)
{
    return Content($"You are viewing item ID {id}");
}

Then visiting http://localhost:5000/home/details/5 will match the Details action and pass 5 as the id argument.

Summary

This section introduced the fundamentals of routing in ASP.NET Core—including how it works and how to configure basic routes. You should now understand the core concepts behind routing and be able to define simple routing rules. In the next tutorial, we’ll explore middleware—another essential building block of ASP.NET Core applications.