The complete ASP.NET Core 9 course for busy developers

Apply data annotations to model properties to define keys and required, ensuring non-null values with Entity Framework Core. Explore nullable and non-nullable strings and default DateTime values.

Install and configure Microsoft SQL Server Express and SQL Server Management Studio, create a local SQL server and a diary entry database, and update AppSettings.json with the connection string.

Configure the appsettings.json connection string to connect your ASP.NET Core 9 app to a SQL Server database, including server name, diary database, and trusted settings.

Install entity framework core and related packages via NuGet, including pre-releases for dotnet nine. Then add SQL server and tools to enable migrations and set up the app database context.

Create and register an application db context for entity framework core. Connect to sql server using the default connection string from appsettings.json in program.cs.

Learn to create a database table in asp.net core by defining a model, adding a db set, and applying migrations with add-migration and update-database to generate the diary entries table.

ASP.NET controllers process user input, route requests, and return views, JSON, or redirects, while using dependency injection, filters, and attribute routing for flexible URLs.

Create an ASP.NET Core 9 diary entries controller and associated index view to enable create, read, update, and delete operations, with proper view folders.

Seed the diary entries table by configuring on model creating with the model builder's has data to add diary entry objects, then create a migration and update the database.

Discover why seeding data matters in ASP.NET Core 9, ensuring consistent environments and reliable testing across development, staging, and production, while providing a ready baseline for CRUD operations.

Prepare a responsive Bootstrap table in the diary entries HTML, map it to a diary entry model, and render rows for each entry with title, content, and created date.

Learn how get retrieves data via the URL while post sends data in the body to create or update resources, with notes on idempotence, safety, and status codes.

Learn how crud operations create, read, update, and delete data using http methods post, get, put/patch, and delete, with practical examples and authentication, authorization, and validation security in mind.

Apply a bootswatch journal theme to your site, override bootstrap CSS, and update layout, header, and nav styling with bg-primary and text-light, adding a diary icon or svg.

Learn how RESTful endpoints enable client-server communication using HTTP methods and data formats like JSON or XML, with authentication, versioning, error handling, and documentation.

Create an action named create and its corresponding view in an ASP.NET Core 9 project, returning a simple view and testing by navigating to /create.

Navigate between pages using ASP.NET Core MVC tag helpers, including the anchor tag helper, to route to actions like index and create from a shared layout.

Master asp validation by adding a red validation summary and per-field messages with validation-for, data annotations, and client-side validation, guiding users to enter valid title, content, and date.

Enable server side validation to reinforce client side checks, using model state to add errors and only saving entries to the database when valid.

Implement the edit view and edit action in the diary entries controller, loading the selected diary entry by id from the database and populating the form with its data.

Implement the edit post request to update a diary entry in the database, save changes, and redirect, illustrating the edit workflow within ASP.NET Core CRUD.

Create the delete get action and its razor delete view by adapting the edit code, passing the id, and prepare the post delete action for the next video.

Explore the RESTful API foundation, including stateless client–server architecture, cacheable resources and representations, and the uniform interface, while comparing REST with SOAP, GraphQL, and RPC and outlining real-world use cases.

Build a RESTful ASP.NET Core web API by implementing crud (create, read, update, delete) in a diary entries controller using DbContext and Swagger testing.

Create an ASP.NET Core 9 web API project in Visual Studio and explore its default weather forecast endpoint with Swagger, curl requests, and JSON responses.

Explore the default ASP.NET Core 9 web API template, enable swagger with Swashbuckle, configure API explorer and swagger UI, and implement a weather forecast controller and model for testing.

Explore default weather forecast api controller, its route and api controller attributes, and how it returns a read-only list of weather forecasts including the model with date, temperature, and summary.

Explore how ASP.NET Core Web API uses the controller base class, attribute routing, and model binding to build robust APIs with validation, error handling, and appropriate status codes.

Discover how Swagger simplifies designing, building, documenting, and testing restful APIs with interactive documentation and automatic client SDKs, and learn to integrate Swashbuckle in ASP.NET Core.

Build an api diary entries controller in ASP.NET Core 9, expose a http get endpoint to return all diary entries via the application db context, demonstrated with swagger.

Explore the IEnumerable interface as a generic, powerful grandparent for list types. Use it to treat lists and arrays uniformly, enabling polymorphism and reusable, maintainable code.

Explore IActionResult in ASP.NET Core, returning various responses like ok, not found, and bad request; learn ActionResult, ActionResult<T>, and best practices for consistent, type-safe results.

Make diary data reads asynchronous with async and await to prevent blocking the main thread and boost API performance. Return action results that may deliver diary entries or error responses.

Implement a get diary entry by id endpoint in an ASP.NET Core 9 API, using action result, not found handling, and asynchronous find and await for efficient data retrieval.

Create a diary entry via HTTP post, ensure the id is zero for auto generation, and return a 201 created response with the resource URL.

Uses http put to update a diary entry by id, binding from body, marking as modified in EF Core and saving changes; handles 400, 404, 204 and tests with swagger.

Implement the http delete action to remove a diary entry by id, handle not found, save changes, and return a 204 no content response, tested via Swagger.

Build an ASP.NET Core 9 app that teaches identity system with registration, login, roles, and seeding users, using a repository pattern with Entity Framework for data access and job postings.

Install and configure asp.net core identity by adding identity packages, including identity, identity ui, and entity framework core, create a default user context, and register identity in program.cs.

Register and configure your application db context with Entity Framework Core SQL Server, register AddDbContext in Program.cs, and read the connection string from appsettings.json using GetConnectionString('database').

Configure a default identity and scaffold an identity login page using entity framework stores, identity user and role, with development-friendly sign-in options and razor page mapping.

Explain how razor pages differ from views, highlighting the page model and code-behind pair, then demonstrate scaffolding and modifying identity pages with map razor pages for login and registration.

Seed user roles programmatically at startup using the role manager in asp.net core identity; create a scope in program.cs, resolve services, and use the role manager to create identity roles.

Seed the admin role only if it does not exist, using role exists async and create async to add an identity role in the ASP.NET core app.

Introduce a static constants class for admin, job seeker, and employer roles. Refactor seeding into a dedicated role seeder using the role manager and constants.

Seed roles with the role manager, then seed user accounts with a dedicated user seeder class using the user manager to create admin, job seeker, and employer identities in ASP.NET Core 9.

Seed a user with an admin role by checking for existing accounts by email, creating the user with email and username, and assigning the admin role.

Assigns a new user to a role based on the UI toggle during registration, using the user manager to create the account and assign the job seeker or employer role.

Define the job posting model as the core entity with id as primary key, required title, description, company, location, timestamp, is approved, and a foreign key to the creating user.

Define the job posting model with a UTC posted date and is approved defaulting to false, plus a required user id linked via a foreign key to the identity user.

Implement a unit test in the asp.net core 9 course to add a job posting via the repository and verify it with single or default, asserting title and description.

Unit tests for the job posting repository demonstrate async add and get by id methods, including a key not found exception, using an isolated Entity Framework context.

Develop and verify a GetAllAsync unit test by seeding two job postings, using add async and add range async with a repository to ensure the method returns exactly two postings.

Develop and validate a delete async unit test for the job posting repository using Entity Framework and DbContext, ensuring the post is removed and the load returns null.

Create a job postings controller with actions to list and create postings, wire views, route, and attach the creator via the user manager with authorization.

Create and view job postings by implementing index and create actions in the job postings controller, wiring a create view and a post endpoint to submit data via a repository.

Modify the navigation in an ASP.NET Core 9 app by updating the shared layout to use the job postings controller and add all jobs and create job links.

Build a bootstrap-styled job posting form with model binding, posting to a create action via http post, then redirect to the index page.

Bind the job posting form fields title, description, company, location to the model with asp-for, while EF auto-assigns id and UTC posted date, and user id is calculated in controller.

Validate a new job posting with data annotations and model state, then save via a repository; use a view model to ensure validation and set the current user ID.

Create a job posting view model to customize validation without manipulating model state. Bind a four-property view model (title, description, company, location) using data annotations for the create view.

Map the validated job posting view model to a new job posting, set title, description, company, location, user id, and post date, then save via the repository.

Master handling invalid forms in ASP.NET Core 9 by returning to the create page with input and showing validation messages via data annotations and the shared validation scripts partial.

Display all job postings by binding the repository data to the index view, render dynamic list group entries with Bootstrap, and show title, description, company, location, and posted date.

Apply authorize and allow anonymous attributes in asp.net core 9 to control access, enforcing admin and employer roles for creating or deleting job postings.

Implement an http delete endpoint protected by admin and employer roles to remove job postings, and add a role based delete button in index view connected to jQuery ajax call.

Add a JavaScript function to delete a job posting, wire it to the button with the posting id via onclick, show a confirmation, and prepare a jQuery Ajax delete call.

Send an HTTP delete request with Ajax to a job postings endpoint, configure the URL and type, and remove the item on success to keep front-end and back-end in sync.

Visually delete a job posting by building a dynamic id, locating it with jQuery using #id, and issuing an Ajax delete request to the endpoint.

Filter job postings by role so employers see only their own postings, while job seekers and admins see all. Use the current user id and a where clause to filter.

Extend the navigation bar to show login, register, and logout based on authentication using the identity system in shared layout. Demonstrate role-based access and job posting creation in the menu.

Explore the blazer apps chapter by building interactive client-side apps, covering lifecycles, built-in components, data binding, event handling, forms and validation, layouts, css isolation, and multilingual support with language switching.

Compare Blazer and Razor, explain Razor as a C# HTML templating approach, and show how Blazer renders single page applications with reusable Razor components.

Explore Blazor hosting models, compare server-side and WebAssembly deployments, and build a Blazor WebAssembly app in Visual Studio with Razor components, routing, and sample data.

Build your first blazer app by creating a reusable shopping list component, routing, and a grocery model. Bind inputs, add items, display the list, and calculate the total.

Explore one-way, two-way, and event binding in Blazor, connecting UI elements with application logic and showing how bind and on input events enable real-time updates.

Learn Blazer event handling by building a reusable item component and a shopping list, using asynchronous event callbacks to update totals when prices increase.

Demonstrate forms and validations with the Blazar framework using a grocery item form, data annotations, and validation summary to handle valid and invalid submits.

Register the http client in the startup program with a base url via dependency injection, then fetch data to return weather forecasts with date, Celsius, Fahrenheit, and summary.

learn to upload multiple files to a blazor server app using an input file component, an async upload method, and a file upload service with dependency injection.

Learn to add a progress bar to the upload page in the ASP.NET Core 9 course, showing real-time progress for multiple files and image previews before upload.

Explore JavaScript interoperability in Blazor, learning how to call JavaScript from .NET and vice versa, use invokeAsync and promise-based results to integrate JS libraries and browser APIs.