URL Routing & Deployment in ASP.NET Core: Concepts, Techniques & Real-World Setup

Core Concepts: What is URL Routing?

URL routing determines how incoming HTTP requests map to controllers and actions in ASP.NET Core. It converts a URL like /products/123 into a method call like ProductsController.GetProduct(123).

How Routing Works

1. Route Template: A pattern (e.g., products/{id}) that matches URLs.
2. Route Data: Extracted values (e.g., id = 123) passed to the controller.
3. Route Constraints: Rules to validate route parameters (e.g., {id:int} ensures id is numeric).

flowchart TD
    A["HTTP Request\n(e.g., GET /orders/456)"] --> B["Route Matcher"]
    B --> C["Route Template\n(orders/{id:int})"]
    C --> D["Extract Parameters\n(id = 456)"]
    D --> E["Invoke Controller\nOrdersController.GetOrder(456)"]
    E --> F["Return Response\n(HTML/JSON)"]

Types of Routing in ASP.NET Core

Real-World Example: Daraz’s Order System

Daraz uses attribute routing to handle URLs like:

• /orders/{orderId}/status → OrdersController.GetStatus(orderId)
• /products/{category}/search?q={query} → ProductsController.Search(category, query)

Why?

• Scalability: Route constraints (e.g., {category:alpha}) validate inputs before processing.
• SEO-Friendly: Clean URLs (e.g., /electronics/laptops) rank better in search engines.

Deployment: Getting Your App Live

Deployment moves your ASP.NET Core app from development to a production server (IIS, Linux, Azure, etc.). Key steps:

1. Publishing the App

Use the dotnet publish command to create a deployable folder:

dotnet publish -c Release -o ./publish

Output Structure:

publish/
├── app.dll          # Main app assembly
├── web.config       # IIS configuration (if using Windows)
└── wwwroot/         # Static files (CSS, JS, images)

2. Deployment Targets

Step-by-Step: Deploying to IIS (Windows)

1. Publish the App:

   dotnet publish -c Release -o C:\inetpub\wwwroot\MyApp
   

2. Configure IIS:
   • Open IIS Manager → Add Application Pool (target .NET CLR version).
   • Set the Default Document to index.html (or index.cshtml for Razor).
3. Test:
   • Access http://localhost/MyApp in a browser.

Worked Example: Ncell’s Billing Portal Ncell’s portal uses IIS deployment for:

• URL Routing: /bills/{customerId} → BillsController.GetBill(customerId).
• Static Files: CSS/JS served from wwwroot for fast loading.
• Security: HTTPS enforced via IIS binding.

Advanced: Custom Route Constraints

Constraints validate route parameters. Common types:

• {id:int}: Only integers (e.g., /orders/123).
• {name:minlength(3)}: Strings ≥3 chars (e.g., /users/john).
• {year:regex(^\d{4}$)}: 4-digit years (e.g., /reports/2023).

Example: eSewa’s Payment Links eSewa uses {transactionId:guid} to ensure only valid UUIDs (e.g., /payments/550e8400-e29b-41d4-a716-446655440000) are processed.

[Route("payments/{transactionId:guid}")]
public IActionResult ConfirmPayment(string transactionId) { ... }

Common Deployment Pitfalls & Fixes

In the Real World

1. eSewa’s Payment Gateway

   • Routing: Uses [Route("pay/{id:guid}")] to validate transaction IDs securely.
   • Deployment: Hosted on Linux (Nginx) for scalability during Diwali sales.

2. Daraz’s Order Queue

   • Routing: /orders/{status} maps to OrdersController.FilterByStatus(status).
   • Deployment: Docker containers auto-scale during sales events.

3. NTC’s Service Portal

   • Routing: /bills/{customerId:int} ensures only numeric IDs are processed.
   • Deployment: IIS on Windows Server for internal team access.

Exam Tip

1. Define Key Terms:

   • Route Template: Pattern matching URLs (e.g., products/{id}).
   • Attribute Routing: [Route] attributes on controller actions.
   • Deployment: Process of publishing code to a live server (IIS/Linux/Docker).

2. Common Exam Questions:

   • "Explain how MapControllerRoute works." → Cover route templates, defaults, and constraints.
   • "Deploy an ASP.NET Core app to IIS." → Steps: publish → IIS app pool → test.
   • "What’s the difference between conventional and attribute routing?" → Use the comparison table above.

3. Practical Tip:

   • Always test routes locally with dotnet run before deploying.
   • Use dotnet publish -c Release to catch missing files early.

Visual Summary:

mindmap
  root((URL Routing & Deployment))
    Concepts
      Route Template
      Attribute Routing
      Constraints
    Deployment
      IIS (Windows)
      Linux (Nginx)
      Docker
      Azure
    Real-World
      eSewa (Linux/Nginx)
      Daraz (Docker)
      NTC (IIS)