Modern Web Development with ASP.NET Core Razor
Course Overview
This hands-on course teaches intermediate developers how to build modern, maintainable web applications using ASP.NET Core Razor Pages—without relying on Azure. Through structured lessons and real-world labs, students will master page routing, model binding, database integration with Entity Framework Core, authentication, reusable UI components, secure file uploads, and application configuration. Ideal for developers transitioning from MVC or starting fresh with Razor Pages, this course provides practical experience using familiar databases like AdventureWorks and TailspinToys in a local environment.
Target Audience
Intermediate C# developers using Visual Studio 2022 who want to build robust, database-connected web applications with Razor Pages—without Azure dependencies.
What You'll Learn
This course covers:
Razor Pages architecture and request lifecycle
Forms, model binding, and input validation
Configuration management and EF Core integration
CRUD operations with full user flow
Reusable components with partial views and tag helpers
User authentication and role-based access
Middleware, error handling, and structured logging
File upload functionality and runtime configuration
Hands-On Labs
Each lesson features a self-contained, real-world lab. You'll:
Build responsive page layouts and route navigation
Validate and process forms with complex models
Query AdventureWorks data using EF Core
Implement full CRUD operations on TailspinToys products
Secure pages using ASP.NET Core Identity
Create reusable components for data display
Handle errors and log requests
Upload and serve brochures securely from file system
Why Enroll?
Skip the complexity of MVC and cloud-first projects—this course focuses on what developers need to know to build Razor Pages applications efficiently in traditional enterprise environments. You’ll walk away with ready-to-deploy skills, project-ready code, and the ability to build scalable web apps using the latest ASP.NET Core tools.
🤖 On-Demand + AI Assist Learning Experience
Intelligent Learning Support
AI agents provide 24/7 personalized and expert instruction, adapting to your learning pace and style.
Personalized Practice
Receive customized exercises and scenarios based on your progress and areas for improvement.
Continuous Assessment
Real-time feedback and progress tracking help you stay on track and achieve your learning goals.
Hands-On Labs
This course includes practical, hands-on laboratory exercises to reinforce your learning:
Lesson 1: Introduction to ASP.NET Core & Razor Pages
This lesson introduces the foundational concepts of ASP.NET Core and the Razor Pages development model. Students will explore the request pipeline, compare Razor Pages to MVC, and learn how the page lifecycle works. Key topics include routing conventions, layout usage, and Razor syntax such as directives and expressions. The lab guides learners through building a new Razor Pages site with a shared layout and basic navigation. Additional concepts such as static file hosting and middleware configuration are also introduced to ensure a strong foundation.
Lesson 2: Forms, Model Binding, and Validation
In this lesson, students dive into the form-handling capabilities of Razor Pages. They’ll learn how to use page handlers for GET and POST requests, bind complex models to form input, and implement server-side validation using data annotations. The hands-on lab focuses on building a contact form with robust validation and feedback. Learners will also explore tag helpers, anti-forgery tokens, and options for customizing validation summaries and error messaging.
Lesson 3: Configuration and Database Access with EF Core
This lesson focuses on application configuration and database integration. Students will learn how to read settings from appsettings.json, apply environment-specific configurations, and inject configuration services into their pages. Using Entity Framework Core, they’ll connect to a SQL Server database, define a DbContext, and query data using LINQ. The lab demonstrates how to retrieve and paginate customer data from the AdventureWorks database, setting the stage for building data-driven applications.
Lesson 4: CRUD Operations with Razor Pages
Students learn how to build full Create, Read, Update, and Delete (CRUD) workflows using Razor Pages and Entity Framework Core. This lesson covers form binding with existing data, redirecting with TempData, handling concurrency conflicts, and managing errors gracefully. The lab walks students through building a complete product management system using the TailspinToys product table, including listing, editing, deleting, and sorting records. Best practices for user feedback and error handling are reinforced.
Lesson 5: Reusable UI with Partial Views, Tag Helpers, and Layouts
This lesson introduces techniques for building modular, maintainable UI components. Students will create partial views, use and customize tag helpers, and understand how to structure shared UI using layout nesting. The lab focuses on building a reusable product card display using TailspinToys data. Students will walk away with the ability to build flexible UI elements like filter panels and reusable display components, promoting clean and DRY (Don’t Repeat Yourself) code.
Lesson 6: Authentication and Authorization
Security takes center stage in this lesson. Students will integrate ASP.NET Core Identity into their project to enable user registration, login, and role management. The lab guides learners in securing an admin section of the site that manages customer records, ensuring only authenticated users have access. The lesson also covers role-based and policy-based authorization, user claims, and common identity-related patterns for building secure Razor Pages apps.
Lesson 7: Middleware, Error Handling, and Logging
Students will learn how middleware enables request processing customization and how to log application activity effectively using ILogger<T>. They’ll implement structured error handling using built-in mechanisms like UseExceptionHandler and UseStatusCodePages. In the lab, students will build a custom middleware component to log incoming requests and create friendly error pages for 404 and 500 errors. The lesson also introduces file-based logging and techniques for environment-specific error handling.
Lesson 8: File Uploads, App Settings, and Course Wrap-Up
The final lesson introduces file upload handling, secure static file access, and advanced configuration techniques. Students will learn how to handle file uploads using IFormFile, apply upload limits and validation, and serve uploaded content securely. The lab allows learners to add brochure upload functionality to product records, reading paths and settings from the configuration file. This lesson also ties together concepts such as feature toggling and runtime config binding to conclude the course.
Ready to Get Started?
Join thousands of professionals who have advanced their careers with our training programs.
Join Scheduled Training
Find upcoming sessions for this course and register for instructor-led training with other professionals.
View ScheduleCustom Training Solution
Need training for your team? We'll create a customized program that fits your organization's specific needs.
Get Custom Quote