Razor Pages in ASP.NET Core

Example

• Pages/About.cshtml → /About

• Pages/Products/Details.cshtml → /Products/Details

However, you can customize routes using the @page directive:

@page "/custom-route"

You can also define route parameters:

@page "/products/{id:int}"

Details.cshtml.cs

public class DetailsModel : PageModel
{
    public int ProductId { get; private set; }

    public void OnGet(int id)
    {
        ProductId = id;
    }
}

Visiting /products/10 binds 10 to the id parameter automatically.

Using Model Binding and Validation

Razor Pages simplifies form handling using model binding and data annotations for validation.

Example. Registration Form

Register.cshtml

@page
@model RazorPagesDemo.Pages.RegisterModel
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

<h2>User Registration</h2>
<form method="post">
    <div>
        <label asp-for="User.Name"></label>
        <input asp-for="User.Name" />
        <span asp-validation-for="User.Name"></span>
    </div>

    <div>
        <label asp-for="User.Email"></label>
        <input asp-for="User.Email" />
        <span asp-validation-for="User.Email"></span>
    </div>

    <button type="submit">Register</button>
</form>

@section Scripts {
    <partial name="_ValidationScriptsPartial" />
}

Register.cshtml.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using System.ComponentModel.DataAnnotations;

namespace RazorPagesDemo.Pages
{
    public class RegisterModel : PageModel
    {
        [BindProperty]
        public UserModel User { get; set; }

        public string Message { get; private set; }

        public void OnGet() { }

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

            Message = $"User {User.Name} registered successfully!";
            return RedirectToPage("/Success");
        }

        public class UserModel
        {
            [Required]
            [StringLength(50)]
            public string Name { get; set; }

            [Required]
            [EmailAddress]
            public string Email { get; set; }
        }
    }
}

Here:

• The [Required] and [EmailAddress] attributes perform server-side validation.

• The asp-validation-for tag helper shows validation messages dynamically.

• Client-side validation is automatically enabled using jQuery Unobtrusive Validation.

Dependency Injection in Razor Pages

Razor Pages fully supports dependency injection (DI) through the PageModel constructor.

Example: Injecting a Service

public interface IMessageService
{
    string GetWelcomeMessage();
}

public class MessageService : IMessageService
{
    public string GetWelcomeMessage() => "Hello from injected service!";
}

public class IndexModel : PageModel
{
    private readonly IMessageService _messageService;
    public string Message { get; private set; }

    public IndexModel(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public void OnGet()
    {
        Message = _messageService.GetWelcomeMessage();
    }
}

In Program.cs:

builder.Services.AddScoped<IMessageService, MessageService>();

This demonstrates how business logic can be separated cleanly from the UI layer.

Layouts and Partial Views

Razor Pages supports Layouts, Partial Views, and Tag Helpers just like MVC.

• _Layout.cshtml defines common site structure (header, footer, navigation).

• Partial views like _LoginPartial.cshtml can be reused across pages.

Example Layout usage

@{
    Layout = "_Layout";
}

Razor Syntax Overview

Razor syntax blends C# and HTML seamlessly:

@{
    var name = "Dinesh";
    var date = DateTime.Now;
}
<p>Hello, @name! Today’s date is @date.ToShortDateString().</p>

@if (date.DayOfWeek == DayOfWeek.Sunday)
{
    <p>It’s Sunday! Enjoy your weekend!</p>
}

The @ symbol tells the compiler to switch from HTML to C# context, making Razor concise and expressive.

Advantages of Razor Pages

1. Simplicity – Easier for beginners compared to MVC.

2. Separation of concerns – UI and backend logic are in separate files.

3. Better organization – Each page handles its own functionality.

4. Lightweight and fast – Less boilerplate code than MVC controllers.

5. Built-in security – Works seamlessly with ASP.NET Core Identity and CSRF protection.

6. Testability – PageModel classes are easy to test with unit tests.

Real-world Use Cases

Razor Pages is ideal for:

• Content-driven websites (blogs, portfolios, company sites)

• CRUD applications

• Admin dashboards

• Internal business tools

• Prototypes and small-scale SaaS frontends

Conclusion

Razor Pages in ASP.NET Core represents the evolution of web development in .NET — simpler, cleaner, and more maintainable than traditional MVC for many use cases.

It allows developers to focus on page-level functionality, reduces complexity, and integrates seamlessly with other ASP.NET Core features such as dependency injection, routing, model binding, and validation.

Whether you are a beginner or an experienced developer, Razor Pages provides a powerful and efficient way to build fast, secure, and scalable web applications in the modern .NET ecosystem.