ASP.
NET Core Routing
Routing in [Link] Core
What is Routing?
Routing is the process of matching an incoming HTTP request URL to a specific endpoint
(controller action or minimal API endpoint).
When a client sends a request like
GET /api/accounts/1001
[Link] Core determines which controller and action method should execute.
Without routing, the application cannot determine where to send the request.
Request Flow
Browser/Postman
│
▼
HTTP Request
│
▼
Kestrel Server
│
▼
Middleware Pipeline
│
▼
Routing Middleware
│
▼
Controller Action
│
▼
Business Logic
│
▼
Database
│
▼
Response
Why Routing is Important
Routing
Maps URLs to Controllers
Maps URLs to Actions
Extracts Parameters
Supports REST APIs
Enables Clean URLs
Improves API Readability
Supports Versioning
Supports Constraints
Routing Example
Suppose a finance application has these URLs.
GET /api/accounts
Returns all accounts.
GET /api/accounts/1001
Returns account with ID 1001.
POST /api/accounts
Creates a new account.
PUT /api/accounts/1001
Updates account 1001.
DELETE /api/accounts/1001
Deletes account 1001.
Types of Routing
[Link] Core mainly supports
1. Conventional Routing
2. Attribute Routing
3. Endpoint Routing
Conventional Routing
Definition
Conventional routing defines URL patterns centrally inside [Link].
Instead of decorating every controller, a common route template is used.
Example Route
{controller=Home}/{action=Index}/{id?}
Meaning
Controller → Home (default)
Action → Index (default)
id → optional
URL Examples
/
Maps to
HomeController
Index()
/Employee/List
Maps to
EmployeeController
List()
/Employee/Details/5
Maps to
EmployeeController
Details(int id)
Advantages
✔ Easy
✔ Centralized
✔ Less configuration
✔ Good for MVC applications
Disadvantages
Not suitable for large REST APIs.
Conventional Routing in [Link]
Example
[Link](
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
Pattern Breakdown
{controller}
Controller name.
{action}
Method name.
{id?}
Optional parameter.
Attribute Routing
Definition
Attribute routing defines routes directly on controllers and action methods.
Example
[Route("api/accounts")]
Instead of defining routes centrally, each controller decides its own route.
Example
[ApiController]
[Route("api/accounts")]
public class AccountsController : ControllerBase
{
}
Action Example
[HttpGet]
public IActionResult GetAll()
URL
GET /api/accounts
Example
[HttpGet("{id}")]
public IActionResult GetById(int id)
URL
GET /api/accounts/10
Advantages
✔ Best for Web APIs
✔ Easy to understand
✔ Highly flexible
✔ REST-friendly
✔ Easy maintenance
Route Parameters
Definition
Route parameters are values embedded inside the URL.
Example
/api/accounts/1001
Here
1001
is the route parameter.
Controller
[HttpGet("{id}")]
public IActionResult Get(int id)
When
GET /api/accounts/15
is called
id = 15
Multiple Parameters
/api/accounts/1001/transactions
[HttpGet("{id}/transactions")]
Another Example
/api/customers/10/accounts/50
Controller
[HttpGet("{customerId}/accounts/{accountId}")]
Values
customerId = 10
accountId = 50
Route Constraints
Definition
Route constraints restrict acceptable values.
Example
{id:int}
Only integers are allowed.
Example
[HttpGet("{id:int}")]
Valid
/accounts/10
Invalid
/accounts/abc
Returns
404 Not Found
Common Constraints
Integer
{id:int}
Long
{id:long}
Guid
{id:guid}
Bool
{status:bool}
Decimal
{price:decimal}
DateTime
{date:datetime}
Alpha
Only letters.
{name:alpha}
Length
Exactly 5 characters.
{code:length(5)}
Min Length
{name:minlength(3)}
Max Length
{name:maxlength(10)}
Range
{id:range(1,100)}
Regex
{code:regex(^[A-Z]{3}$)}
Multiple Constraints
{id:int:min(1)}
Meaning
Integer
AND
Greater than or equal to 1
Optional Parameters
{id?}
Example
GET /api/accounts
or
GET /api/accounts/100
Both work.
Query String Routing
Definition
Query strings pass data after the question mark (?) in the URL. Unlike route parameters, they are
not part of the route template.
Example
/api/accounts?type=Savings
Multiple Query Strings
/api/accounts?type=Savings&status=Active
Controller
[HttpGet]
public IActionResult GetAccounts(string type)
When
GET /api/accounts?type=Current
Then
type = Current
Multiple Query Parameters
[HttpGet]
public IActionResult Search(
string accountType,
string city,
bool active)
URL
GET /api/accounts?accountType=Savings&city=Pune&active=true
Advantages
Good for filtering
Good for searching
Supports optional values
Keeps route templates simple
Route Parameter vs Query String
Route Parameter Query String
Part of URL path Appears after ?
Usually identifies a resource Usually filters or modifies results
Required in many cases Often optional
Example: /accounts/10 Example: /accounts?status=active
Endpoint Routing
Definition
Endpoint Routing is the routing system introduced in [Link] Core 3.0 and used in current
versions of [Link] Core. It builds a list of endpoints during application startup and matches
incoming requests efficiently.
Flow
Incoming Request
│
▼
UseRouting()
│
▼
Route Matching
│
▼
Selected Endpoint
│
▼
Controller Action
Example in [Link]
[Link]();
This maps all controllers that use attribute routing.
Advantages
Faster route matching
Unified routing model
Works with controllers, minimal APIs, Razor Pages, and SignalR
Easier integration with middleware
API Versioning Basics
Why Version an API?
As APIs evolve, changes can break existing clients. Versioning allows new functionality to be
introduced while keeping older versions available.
Benefits:
Backward compatibility
Easier maintenance
Gradual migration for clients
Support for multiple API versions simultaneously
Common Versioning Approaches
1. URL Path Versioning (Most Common)
/api/v1/accounts
/api/v2/accounts
2. Query String Versioning
/api/accounts?api-version=1.0
3. Header Versioning
api-version: 1.0
4. Media Type Versioning
Accept: application/json;version=1.0
Example Controller Using URL Versioning
[ApiController]
[Route("api/v1/accounts")]
public class AccountsV1Controller : ControllerBase
{
}
[ApiController]
[Route("api/v2/accounts")]
public class AccountsV2Controller : ControllerBase
{
}
Best Practices
Use Attribute Routing for Web APIs.
Keep URLs meaningful and resource-oriented.
Use nouns (e.g., /accounts) instead of verbs.
Apply route constraints to validate parameters.
Use query strings for filtering, sorting, and paging.
Version APIs before introducing breaking changes.
Keep routing consistent across all controllers.
Test routes thoroughly using Swagger or Postman.
Summary
Topic Purpose
Routing Maps incoming requests to controller actions
Conventional Routing Centralized route templates, common in MVC
Attribute Routing Routes defined directly on controllers/actions; preferred for Web APIs
Route Parameters Capture values from the URL path
Route Constraints Restrict acceptable route parameter values
Query String Routing Pass optional filtering, sorting, or paging values
Endpoint Routing Modern routing infrastructure used by [Link] Core
API Versioning Supports multiple API versions without breaking existing clients