ASP.NET Core Razor Pages The Complete Guide (.NET 6)

Create a category model for a code-first EF Core setup, defining an identity primary key, a name, and a display order in a new model folder for SQL Server.

Explore how data annotations configure primary keys, identity columns, and required fields in Entity Framework Core, and set up a SQL Server connection string with EF Core packages.

Add a connection string in appsettings.json under connectionStrings, using the dot as server name for the AP database and trusted; then configure the db context and EF Core.

Install entity framework core and sql server packages, then create an application dbcontext and a category dbset. Configure the connection string in appsettings.json to connect to your database.

Configure the application to use a SQL Server DbContext by registering it as a service in program.cs, retrieving the default connection string from appsettings.json and wiring it through dependency injection.

Display all categories on the Razor page by looping model.categories in index.cshtml. Present them in a Bootstrap-styled table with name and display order, using Razor runtime compilation.

Create a new razor page under the categories folder to build a create category form with name and display order, submitted via post.

Bind a form to a category model in a Razor Pages create page using tag helpers and asp-for to bind name and display order, then post to process submitted data.

Create a post handler in Razor pages to add a category. Use bind property and class-level bind properties to streamline category input and binding to the UI.

Apply Bootswatch themes to customize Bootstrap styling, update the CSS and layout, and enable dark navigation and icons. Add input validations to prevent null values and avoid exceptions.

Learn server-side validations in asp.net core razor pages by validating category model on create using model state and is valid, and show errors via asp-validation-for for name and display order.

Implement server-side custom validations in ASP.NET Core Razor Pages by comparing category name and display order, adding a model error with ModelState.AddModelError, and displaying a validation summary.

Learn how to customize field names with the display attribute and enforce value ranges with the range data annotation in Razor Pages, including custom error messages for display order.

Learn to enable client side validations in ASP.NET Core Razor Pages using a shared validation script partial, a scripts section, and partial tag helper to bind errors to a property.

Create and reuse a razor page for editing a category by renaming the model and retrieving the category by id. Update it with the db set update method.

Implement delete category functionality in asp.net core razor pages by locating the category by id, removing it from the database, saving changes, and redirecting to index with disabled fields.

Discover how to use TempData in ASP.NET Core Razor Pages to show one-request alerts on the index page after create, edit, or delete actions.

Add toaster notifications to a Razor Pages app by including toaster CSS and JS, wiring jQuery, and triggering toaster.success with temp data for success and error messages.

Move alert code into a partial view to avoid duplicating code, call it from pages, and optionally render it in the shared layout for consistency across all pages.

Divide your ASP.NET Core Razor Pages solution into data access, models, and utilities by creating three class library projects, moving data, and updating to .NET 6 RC1.

Fixing IIS Express errors by correcting using statements and references in an n-tier architecture, creating a fresh database via EF Core migrations, and updating packages to .NET 6.

Organize admin and customer pages by creating folders, moving categories into admin, and updating namespaces in page models and views; restart Visual Studio to refresh navigation and test a category.

Add a dropdown in the navbar under admin to manage categories, applying the Lux light theme in underscore layout and converting the dark navigation to primary.

practice CRUD for a new food type model with id and name in an n-tier asp.net core razor pages project, with client and server side validations and copied views.

Create and integrate a food type model in an ASP.NET Core Razor Pages app, add a DbSet, remove display order, run migrations, and implement CRUD across food type pages.

Implement a generic repository in ASP.NET Core Razor Pages by wiring the application db context, binding a db set, and adding, removing, and querying all or first-or-default records.

Register the category repository in the dependency injection container in program.cs for ASP.NET Core Razor Pages, explain service lifetimes (singleton, scoped, transient) and use ICategoryRepository for database access.

Explore implementing a category repository with dependency injection, replacing direct db context usage with repository methods like add and get all, and introduce a unit of work to encapsulate saves.

Implement a unit of work that implements IDisposable to wrap all repositories, exposing a category repository and a save method, using a DbContext with dependency injection.

Create the food type repository interface and implementation, configure it in the unit of work, and update pages to use the unit of work instead of the application db context.

Create a menu item model with ID, name, description, image URL, and price validated between 1 and 1000; implement foreign keys to food type and category with navigation properties.

Create a menu item table by adding a migration, configuring a db set in the app db context, and pushing changes with foreign key constraints and indices.

Configure the menu item repository and update the unit of work to include the new menu item, aligning updates to only change provided properties and preserving existing image when null.

Build a menu item upsert page with a Razor Pages get handler, enabling create and update flows, and handling image uploads with multipart form data using a unit of work.

Populate category and food type dropdowns on menu item upsert page using a get handler and unit of work, binding to the page model and rendering via select tag helpers.

Integrate a rich text editor using TinyMCE in an ASP.NET Razor Pages app, wiring in the script, API key, and a textarea with validation for create and upsert flows.

Learn to implement a menu item post handler: upload an image to wwwroot/images/menu items, generate a unique file name, and persist the item with unit of work save.

Add an api endpoint in the Razor project to fetch all menu items as json via a controller, and display category and food type names on the index page.

Use include to load category and food type in EF Core. Extend the repository to accept comma-separated include properties and display results in a data table.

Include data tables in the project by adding CSS and JavaScript and wiring a dt_load table with data tables. Load data via the API endpoint with sorting, pagination, and search.

Render edit and delete buttons in a data table using the menu item ID to navigate to the admin menu items absurd page for editing, with Bootstrap styles and icons.

Learn how the menu item edit get handler loads item details from the database, populates dropdowns, and switches the form to update mode with image display for existing items.

Implement the update flow for a menu item in asp.net core razor pages, including fetch, optional image replacement with old image deletion, and saving changes.

Implement an http delete endpoint for menu items with sweet alerts approval, remove the item via unit of work, save changes, and delete its image from the web root.

Display all menu items on the home page with a bootstrap card layout and a get handler. Use dependency injection and a unit of work to fetch items and categories.

Display home page renders categories and their menu items by looping through category list and filtering menu items with a where clause. It shows price, image, and HTML raw descriptions.

Extend the repository with include properties, nullable includes, and a shared filter for get all and get first or default, plus a configurable order by.

Navigate to the details page using the item id, load the menu item via the unit of work, and display category, food type, price, bound count, and client-side validation.

Scaffold identity into an existing dotnet core web project, override the identity files, and connect to the application db context, ensuring all nuget package versions align.

Extend the registration flow to create an application user with first name, last name, and phone number, replacing identity user and updating the input model.

Configure and seed multiple roles in ASP.NET Core Razor Pages by defining role constants, creating roles with the role manager, and assigning selected roles to new users during registration.

Create a shopping cart repository by adapting the existing category repository, updating the interface, removing the update logic, and wiring it into the unit of work for later extension.

Bind a shopping cart object on the details page with the menu item, count, and user ID, and create a cart entry when the add to cart button is pressed.

Explore how authorization restricts access in ASP.NET Core Razor Pages using the authorize attribute at the page model level and configure custom login, logout, and access denied paths.

Implement add to cart on ASP.NET Core Razor Pages by capturing menu item id, user id from claims, and quantity, validating model state, and saving to the shopping cart.

Increment the shopping cart count for an existing item instead of creating duplicates. Implement repository methods to increment and decrement counts, with unit of work handling updates.

Create a shopping cart page in ASP.NET Core Razor Pages with a get handler that displays all carts for the logged-in user using unit of work, claims identity, and authorization.

Learn to implement a shopping cart in asp.net core razor pages, display items with image, name, category, price, and quantity, and fix data population for authorized users.

Learn how to load navigation properties for a shopping cart in ASP.NET Core Razor Pages using include properties and then include to load menu item, category, and food type.

Implement three post handlers (plus, minus, remove) for the shopping cart using asp-page-handler tag helper and a cart ID; fetch the cart, adjust the count, and redirect to index page.

Implement remove and decrement logic for shopping cart items in a Razor Pages app, saving with unit of work and showing 'please add items to the shopping cart' when empty.

Build a cart summary UI with Razor Pages, capture name, phone, pickup date and instructions, display the order items, and redirect to Stripe for payment.

Create the order header model with id, user id, date, total, pickup time, and status. Add data annotations for validation and currency formatting, and map dates for ef core.

Create the order details model with an order header id as a foreign key, a navigation property, and include required menu item id, count, and price to preserve price.

Implement order header and order details storage by adding corresponding database tables, configuring repository and unit of work for both headers and details, and implementing a generic update method.

Implement order header and order detail repositories in ASP.NET Core Razor Pages, configure the db context with migrations, and set up unit of work to manage header and detail updates.

Build and refine the order summary UI in ASP.NET Core Razor Pages by binding inputs with tag helpers and looping through cart items to display totals.

Add client-side validations with ASP validation and span tags for pickup name, phone, date, and time; create the order header with pending status and process Stripe payments.

Refine the Razor Pages workflow by moving the save outside the foreach loop to batch update order details, reducing database calls with entity framework core, and prepare Stripe payments integration.