Build ASP.NET Blazor apps with a clean structure

Create a sign in page in a Blazor project by adding the sign in component, its page directive, and username and password inputs with a sign up link.

Explore data binding in Blazor, including one-way and two-way bindings, and see how UI values bind to component properties and update via events.

Explore event handling in Blazor by wiring inputs and buttons to C# logic, update properties on the change event or the input event, and render text with conditional expressions.

learn how to implement event callbacks in blazer components by creating a validation input base and a derived component, enabling the parent to receive text changes through a parameterized event.

Harness two-way binding between parent and child components in Blazor using the bind directive, parameter, and event callback, following the property changed naming convention.

learn to replace native inputs with the input text component, bind values for live validation, and display inline validation messages with cascading context to show red borders on errors.

Create a sign up razor component page routed to /sign up, derived from sign up base, binding a user object with required first name, last name, and phone validation.

Demonstrates using query parameters to pass username, including optional parameters, and reading URL values with the navigation manager to set user data, with sign in and sign up examples.

Define a user manager interface in the contracts folder with try get user async and insert user async methods, then register it as a singleton in Blazor WebAssembly DI container.

Create a test fake project in a Blazor solution, implement a fake user manager from the shared contracts, and switch to development mode by adjusting service configuration.

Explore how dependency injection types—singleton, scoped, and transient—work in Blazor apps, compare server and WebAssembly lifetimes, and explain how registration affects shared resources and per-user isolation.

Demonstrate dependency injection lifetimes in a Blazor app by showing scoped, singleton, and transient interfaces, on-demand service creation, and how registration affects instance numbers.

Build an items list component for a Blazor app that handles multiple item types with titles, subtitles, images, and urls, expanding items to reveal details and child tasks.

Implement the current user service by creating CurrentUserService and its interface ICurrentUserService, register it, and inject it to access the current user.

Override the user’s string method to display a salutation (Mr. or Mrs.) with first and last name in a Blazor app, using test data to verify display.

Bind current user items to a ui container, iterate with a for-each loop, and prepare an item element component with a checkbox, content, and an arrow.

Master fragment styling for a Blazor items list using a flex box layout with content top and bottom, text top and bottom, and item-type colors.

Learn item edit general view styling in an asp.net blazor app by extending bootstrap form-control with a full-width item added input and importing bootstrap files.

Implement a switch-based item editor in Blazor to render type-specific fields, bind text item properties (title, subtitle, digital), and handle input changes and links.

Add and edit child items in a Blazor app by clicking to append a child to a parent, then render and edit each child's title in a Bootstrap-styled Razor component.

Implement INotifyPropertyChanged by creating a notifying object, applying it to the base entity class, and updating entity properties to raise the PropertyChanged event when values change.

Learn how to add an item to a user collection by building UI with a dropdown of item types and an add button that activates when a type is selected.

Create a data access class for items and define a new item data access interface for dependency injection. Implement asynchronous methods for getting all items, inserting, updating, and deleting.

Learn how to reduce update calls by using a timer that triggers updates only after a 500 millisecond interval of inactivity, delaying writes until input changes settle.

Implement the delete process to remove a parent item and its child items, update positions, and persist changes via the item data access layer, with a new settings-triggered delete workflow.