Creating and Using Controllers in ASP.NET Core

In ASP.NET Core, controllers are a vital component of the MVC (Model-View-Controller) pattern, responsible for handling user requests and returning appropriate views or data. In this tutorial, we’ll explore in depth how to create and use controllers—illustrating their significance and practical usage through real-world examples.

1. Basic Structure of a Controller

In ASP.NET Core, a controller is typically a class that inherits from the Controller base class. Each public method within a controller is commonly referred to as an action, and these actions handle incoming requests from views or APIs. By convention, controller class names end with “Controller” so the MVC framework can recognize them automatically.

Example Code

using Microsoft.AspNetCore.Mvc;

namespace MyApp.Controllers
{
    public class HomeController : Controller
    {
        // GET: /Home/
        public IActionResult Index()
        {
            return View();
        }

        // GET: /Home/About
        public IActionResult About()
        {
            return View();
        }
    }
}

In this simple example, we define a controller named HomeController, containing two actions: Index and About. Each action returns a corresponding view.

2. Routing for Controllers

In ASP.NET Core, the routing system maps incoming HTTP requests to specific controllers and actions. Route configuration is typically performed in the Startup.cs file.

Configuring Routes

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

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

Here, the default route pattern {controller=Home}/{action=Index}/{id?} is configured. This means that when a user navigates to /Home, the Index action of HomeController is invoked.

3. Interaction Between Controllers and Views

Controllers do more than just process requests—they also interact with views. Specifically, controllers can pass data to views via models (or other mechanisms) for rendering.

Passing Data to a View

public IActionResult About()
{
    ViewData["Message"] = "Your application description page.";
    return View();
}

In the About action above, we use the ViewData dictionary to pass a message to the view. ViewData is a dynamic object designed to facilitate data transfer between controllers and views.

4. Using Views

Views returned by controllers must be placed in the Views folder. By convention, a view’s filename matches the name of its corresponding action. For instance, the About action expects a view named About.cshtml located under Views/Home.

Example: About.cshtml

@{
    ViewData["Title"] = "About";
}

<h2>@ViewData["Message"]</h2>

This view displays the message passed from the About action.

5. Route Parameters and Controllers

Controller actions can accept parameters—often bound directly from the URL. This enables access to specific resources—for example, retrieving an item by its identifier.

Example Code

public IActionResult Details(int id)
{
    // Assume we fetch data using the provided ID
    var item = GetItemById(id);
    return View(item);
}

Here, we define a Details action accepting an integer parameter id. We then retrieve a specific item (e.g., from a database) using that id and pass it to the view.

Route Configuration for Parameters

To ensure the id parameter is correctly captured from the URL, you must configure an appropriate route—for example:

endpoints.MapControllerRoute(
    name: "details",
    pattern: "Home/Details/{id}",
    defaults: new { controller = "Home", action = "Details" });

6. Summary

In this tutorial, we focused on creating and using controllers—the central orchestrators of the MVC pattern. Controllers handle incoming requests, prepare and pass data to views, and return responses (e.g., rendered HTML or JSON). Through concrete code examples, we demonstrated how to define controllers, configure routing, and exchange data with views.

In the next tutorial, we’ll delve deeper into creating and using views, exploring best practices for presenting data and building intuitive user interfaces.

By completing this series, you’ll have acquired foundational skills for web development using the ASP.NET Core framework. Stay tuned—we look forward to continuing this journey with you in the next article!