ASP.NET Core Documentation

Controllers and Razor Pages in ASP.NET Core

ASP.NET Core offers two primary approaches for building web user interfaces: MVC (Model-View-Controller) and Razor Pages. Both are built on the same core ASP.NET Core infrastructure and share many common components like middleware, dependency injection, and configuration. Understanding their differences and when to use each is key to effective web development.

What are Controllers and Views? (MVC)

The MVC pattern separates an application into three interconnected components:

• Models: Represent the data and business logic of the application.
• Views: Present the data to the user. They are typically HTML files with embedded Razor syntax.
• Controllers: Handle incoming HTTP requests, interact with the Models to retrieve or update data, and select the appropriate View to render the response.

In an MVC application, a request is routed to a specific controller action. The controller then processes the request, possibly interacting with a model, and returns a result, often a view. Views in MVC are typically located in the Views folder, organized by controller name.

Example: A Simple MVC Controller

// Pages/Controllers/HomeController.cs
using Microsoft.AspNetCore.Mvc;

public class HomeController : Controller
{
    public IActionResult Index()
    {
        // Assuming a model here, for simplicity just passing a string
        ViewData["Message"] = "Welcome to the MVC App!";
        return View(); // Renders Views/Home/Index.cshtml
    }

    public IActionResult About()
    {
        ViewData["Title"] = "About Us";
        return View(); // Renders Views/Home/About.cshtml
    }
}
            

Example: Corresponding View (Index.cshtml)

@{
    ViewData["Title"] = "Home Page";
}

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>@ViewData["Message"]</p>
</div>
            

What are Razor Pages?

Razor Pages provide a page-centric model that simplifies building web UI with ASP.NET Core. Instead of pairing controllers and views, each Razor Page consists of a single Razor file (.cshtml) and an optional code-behind class (.cshtml.cs) that handles page logic. This approach is ideal for scenarios where you have a distinct UI for each discrete feature or page.

Razor Pages are located in the Pages folder by default. The file path within the Pages folder determines the URL. For example, a file at Pages/About.cshtml would be accessible at the /About URL.

Example: A Simple Razor Page

// Pages/Index.cshtml.cs
using Microsoft.AspNetCore.Mvc.RazorPages;

public class IndexModel : PageModel
{
    public string WelcomeMessage { get; set; }

    public void OnGet()
    {
        WelcomeMessage = "Hello from Razor Pages!";
    }
}
            

Example: Corresponding Razor Page (Index.cshtml)

@page
@model IndexModel
@{
    ViewData["Title"] = "Home Page";
}

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>@Model.WelcomeMessage</p>
</div>
            

When to Use Which?

Use MVC when:

• You need a clear separation of concerns for complex applications.
• You have shared logic across multiple pages that can be encapsulated in controllers or services.
• You are building large, feature-rich applications where a structured, component-based approach is beneficial.

Use Razor Pages when:

• You are building simpler pages or forms with less complex interactions.
• You want a more direct mapping between a URL and a page.
• You are migrating an older ASP.NET Web Forms application and want a more page-based development model.
• You prefer a more file-based organization for your UI.

Shared Concepts

Both MVC and Razor Pages in ASP.NET Core benefit from:

• Tag Helpers: Server-side code that can be used in HTML to create dynamic HTML elements.
• View Components: Reusable UI components that can be invoked from Razor files.
• Dependency Injection: A powerful mechanism for managing service lifetimes and dependencies.
• Model Binding: Automatically mapping incoming request data to model properties.
• Validation: Built-in support for data validation.

Conclusion

Controllers and Razor Pages are both powerful tools in the ASP.NET Core ecosystem. MVC provides a robust, structured pattern for complex applications, while Razor Pages offer a simpler, page-centric approach suitable for a wide range of web UI development tasks. Choosing the right pattern depends on the specific requirements and complexity of your project.