Session 0: Controllers, Routing, and Return Types

📝 Overview

In this session, we’ll cover the following concepts:

MVC pattern in ASP.NET Core
Controllers and their structure
Default and attribute-based routing
Handling various HTTP requests (GET, POST, DELETE)
Return types from controllers
Building a real-world Product flow
Mini project assignment

📚 Topics Covered

✅ MVC Architecture

Learn how the Model-View-Controller (MVC) architecture separates concerns in a web application.
🔗 Microsoft Docs - MVC Pattern

✅ Controllers and Actions

Understand how to create controllers and action methods, follow naming conventions, and return data to views.
🔗 w3schools - MVC Controllers

✅ Routing in ASP.NET Core

Understand how ASP.NET Core maps incoming requests to the appropriate controller and action using default and custom routing.
🔗 Microsoft Docs - Routing

✅ HTTP Methods in MVC

Learn how to respond to different types of HTTP requests using attributes like [HttpGet], [HttpPost].
🔗 HTTP Methods - MDN

✅ Return Types

Explore different return types like ViewResult, JsonResult, and more, and know when to use each one.
🔗 Action Results in ASP.NET Core

📌 Notes

Collected from various sources including W3Schools, Microsoft Docs, and ChatGPT

1. Start with the Basics: Understanding MVC Architecture

Goal: Give a quick overview of the MVC pattern, focusing on the role of controllers.

✅ Explain MVC:
- Model: Manages data and business logic.
- View: Handles UI.
- Controller: Acts as the intermediary, processing requests and returning responses.
✅ Controller’s Role:
Handles incoming HTTP requests, decides which logic to execute, and returns the appropriate result (usually a view or data).
✅ Activity:
Create a “Hello World” ASP.NET Core MVC app and show the default routing behavior (HomeController with Index action).

2. Controllers: Structure, Naming, and Basics

Goal: Help students understand how to structure and create controllers, and introduce them to actions.

✅ Creating a Simple Controller:
- Use Visual Studio to add a new controller.
- Controller classes must:
  - Be public
  - Inherit from Controller
  - Have Controller as a suffix in their name (e.g., ProductController).
✅ Basic Action Methods:
- Action methods must be public.
- Default return type is usually IActionResult.

public class ProductController : Controller {
    public IActionResult Index() {
        return View();
    }
 
    public IActionResult Details(int id) {
        var product = new Product { Id = id, Name = "Sample Product", Price = 25.00m };
        return View(product);
    }
}
 
- ✅ **Activity**:
    Create your own `CustomerController` with an `Index` and a `Details` action.
 
 
---
 
### **3. Routing Basics: Default Routing and Attribute-Based Routing**
 
**Goal**: Teach students how routing works in ASP.NET Core, from default routing to custom attribute routing.
 
- ✅ **Default Route Configuration**:
    Defined in `Program.cs`:
 
 
```csharp
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

{controller=Home}: Default controller
{action=Index}: Default action
{id?}: Optional parameter
✅ Customizing Routes:
- You can modify the pattern in Program.cs.
- Example: Use "{controller=Product}/{action=List}/{id?}" to change defaults.
✅ Attribute-Based Routing:
- Useful for APIs or when you want specific paths.

[Route("product")]
public class ProductController : Controller {
    [HttpGet("list")]
    public IActionResult List() {
        return View();
    }
 
    [HttpGet("{id:int}")]
    public IActionResult Details(int id) {
        return View();
    }
}

🔲 Activity:
Add routes to your CustomerController:
- [HttpGet("all")] to show all customers
- [HttpGet("{id}")] to show customer details

4. Controllers and Actions: Handling Different HTTP Requests

Goal: Show how controllers handle various HTTP methods.

✅ HTTP Verbs:
- GET: Retrieve data
- POST: Submit data
- PUT: Update data
- DELETE: Remove data
✅ HTTP-Specific Attributes:
- Use [HttpGet], [HttpPost], [HttpPut], [HttpDelete] to restrict access.

public class ProductController : Controller {
    [HttpGet]
    public IActionResult List() { return View(); }
 
    [HttpPost]
    public IActionResult Create(Product product) {
        // Save to DB
        return RedirectToAction("List");
    }
 
    [HttpDelete("{id}")]
    public IActionResult Delete(int id) {
        // Remove from DB
        return NoContent();
    }
}

🔲 Activity:
Add full CRUD actions to CustomerController, using appropriate HTTP verbs and routing.

5. Return Types: Exploring Different Return Options in Controllers

Goal: Familiarize students with different return types in ASP.NET Core.

✅ Basic Return Types:
- ViewResult → return View();
- JsonResult → return Json(data);
- ContentResult → return Content("Text");
✅ When to Use:
- Use View() when rendering pages.
- Use Json() for APIs or AJAX.
- Use Content() for simple text/plain responses.

public class ProductController : Controller {
    public IActionResult Index() => View();
 
    public JsonResult GetProductJson(int id) => Json(new { id, name = "Product" });
 
    public ContentResult GetMessage() => Content("This is a simple text message.");
}

✅ Advanced Return Types:
- RedirectToAction("Index"): Navigate to another action.
- StatusCode(404): Return HTTP status codes.
- File(): Return downloadable content (e.g., PDF, image).
🔲 Activity:
Add:
- One action returning JSON
- One returning text
- One redirecting to another action

6. Real-World Application: Creating a Full Flow

Goal: Connect controllers, models, and views to build something meaningful.

✅ Create a Model:

public class Product {
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

✅ Controller-Model Interaction:

public IActionResult Details(int id) {
    var product = new Product {
        Id = id,
        Name = "Laptop",
        Price = 1200.00m
    };
    return View(product);
}

✅ Pass Data to View:
- Use a strongly typed view (@model Product)
- Display @Model.Name, @Model.Price, etc.
🔲 Activity:
- Create Product model
- Create Details and List actions
- Create strongly-typed Razor views

7. Practice and Review: Small Project Assignment

Goal: Reinforce everything learned.

✅ Project: Product Management App
- CRUD: Create, Read, Update, Delete products
- Use default and attribute routing
- Return different types (View, JSON, Redirect)
- Include HTTP verb handling
✅ Suggested Workflow:
1. Create the Product model
2. Build controller actions
3. Set up routing
4. Implement Razor views
5. Test everything end-to-end
✅ Encourage Discussion:
- Why return JSON instead of HTML?
- When to use attribute routing?
- What’s the benefit of redirecting?

🧪 Practice

Create a basic MVC Hello World app
Add ProductController with sample actions
Use [Route] and [HttpGet] in CustomerController
Implement full CRUD for customers or products
Add JSON, Content, and Redirect examples
Build a simple Product Detail View
Complete mini-project: Product Management App

🙏 Acknowledgments

Sources:

w3schools.com
Microsoft Learn
ChatGPT conversations (2025 sessions)

ASP.NET

Explorer

Session00 Notes