Lesson 21 of 40 Web Development Intermediate 55 min

Razor Pages Deep Dive

In this lesson, you will learn how Razor Pages organizes markup and page logic together, why it is productive for many web applications, and how forms, model binding, validation, and page handlers work in practice.

← Back to Visual Studio 2026 Tutorial Home

What you will learn

How Razor Pages differs from MVC controller-based design
How page models organize page behavior
How model binding and validation work
How handlers such as OnGet and OnPost fit request flow
How Razor Pages fits CRUD and form-heavy applications

Why this matters: Razor Pages offers a page-focused structure that often feels simpler and more direct than controller-heavy designs, especially for internal systems, admin apps, and data-entry workflows.

Part 1: Page-focused architecture

Razor Pages is designed around the idea that each page is a unit of UI plus request-handling logic. Instead of routing requests to a shared controller containing many actions, each page gets its own model and handler methods.

This is often easier to follow in applications where each page has a clear purpose, such as editing a record, displaying a list, or processing a form submission.

Part 2: Page models and handlers

The page model class contains the logic for the page. Common handlers include OnGet for loading the page and OnPost for handling form submissions.

public class EditModel : PageModel
{
    [BindProperty]
    public Product Product { get; set; }

    public void OnGet()
    {
    }

    public IActionResult OnPost()
    {
        if (!ModelState.IsValid)
            return Page();

        return RedirectToPage("Index");
    }
}
    

This structure keeps the markup and the supporting logic closely related, which often makes maintenance easier.

Part 3: Model binding and validation

Razor Pages binds request data directly to properties on the page model. This is especially useful for forms, because input values can flow naturally into a bound model.

[BindProperty] makes form data easier to work with
Validation attributes help enforce business rules
ModelState.IsValid tells you whether the submitted data passed validation

Common pattern: Bind form data, validate it, and return the same page when there are errors so the user can correct them.

Part 4: Why Razor Pages works well for CRUD

Many business applications revolve around listing, creating, editing, and deleting records. Razor Pages fits this very naturally because each page can represent one of these tasks clearly.

List page for viewing records
Create page for adding new records
Edit page for updating existing records
Details page for viewing one item

This tends to reduce structural overhead and makes navigation patterns easier to understand.

Part 5: Razor Pages vs MVC

Approach	Often stronger for
Razor Pages	Page-focused forms, CRUD workflows, internal business apps
MVC Controllers	Action-heavy routing, larger API-style controller groupings, more custom flow structures

Neither is universally better. The best choice depends on the shape of the application.

A practical Razor Pages workflow

Step 1: Define the purpose of the page clearly

Step 2: Build the page model with focused handlers

Step 3: Bind form or query data carefully

Step 4: Add validation and handle invalid states cleanly

Step 5: Keep page logic readable and not overloaded

Step 6: Refactor repeated logic into shared services

Best practices

Keep each page focused on one responsibility
Use page models to keep logic out of the view
Validate input consistently
Move reusable business logic into services
Do not overload one page with too many actions
Use clear navigation between related pages

Summary

In this lesson, you learned how Razor Pages organizes request handling around individual pages, how page models and handlers work, and why this approach is especially effective for form-heavy and CRUD-driven applications.

In the next lesson, you will explore microservices architecture.