Complete ASP.NET Core and Entity Framework Development

Dotnet is a runtime for C# apps powered by the CLR, with Visual Basic and F# support, and dotnet eight enables cross-platform development with ASP.NET Core.

Explore ASP.NET Core, a cross-platform, open-source web framework for dotnet, covering model-view-controller, razor pages, APIs, and Blazor in a hands-on journey across server-side and client-side architectures.

Discover core topics in this course, including ASP.NET Core MVC and Razor pages, authentication and authorization, and Entity Framework with code-first, plus Visual Studio and C Sharp Dev Kit guidance.

See how the leave management system progresses from concept to deployment, starting with admin login and logout, and building features for leaf types, allocation to employees, and period setup.

Explore setting up the development environment for ASP.NET Core and Entity Framework by installing the .NET SDK and C# Dev Kit extension, and reviewing Visual Studio Code options.

Install Visual Studio 2026 insiders edition and select workloads for ASP.NET web development, Maui, Azure, and desktop development. Experience a UI with GitHub Copilot chat and settings migration from 2022.

Download and install dotnet sdk, choose dotnet eight, verify with dotnet --info, and set up Visual Studio Code on OS for ASP.NET core web apps with C sharp dev kit.

Explore the Visual Studio Code UI, including the explorer and navigation pane, and learn to set up dotnet projects with the C sharp dev kit, launch.json, and debugging with GitHub.

Discover JetBrains Rider as a cross-platform, free-for-non-commercial use alternative to Visual Studio and Visual Studio Code for .NET development, with required account sign-in to download.

Set up your dotnet development environment by exploring Visual Studio installation, Visual Studio Code, the dotnet SDK, and the CLI on Windows or another OS.

Explore the project setup for an ASP.NET Core web MVC application, learn the MVC pattern with models, views, and controllers, and review debugging methods and essential files.

Create an ASP.NET Core MVC web project in Visual Studio 2022 by selecting the MVC template, naming the project leave management system dot web, and choosing individual accounts with https.

Create an ASP.NET Core MVC web project in Visual Studio Code using the dev kit extension. Select individual accounts and dotnet eight, then explore the solution through the solution explorer.

Explore the MVC pattern, splitting the app into models, views, and controllers to boost maintainability and collaboration. In ASP.NET Core MVC, views present content via the user interface.

Explore how views render dynamic content with cshtml files in the views folder, using the razor engine to embed C# in HTML and share a layout skeleton.

Test a web project with Visual Studio or Visual Studio Code, using F5 or Ctrl+F5. Observe how layouts stay consistent as views render dynamic titles via view data.

Controllers handle user requests, coordinate with the model, run business logic, and return a view with the relevant data, using convention-based routing to map URLs to actions.

Explore how controllers handle web requests in an ASP.NET Core app, create actions returning views, and rely on default routing to render index and privacy pages.

Models are C# classes with properties that supply data to views. A controller builds a view model, a view-specific subset of the model, and uses model binding to pass data.

Learn how the home controller's error action creates an error view model with a request ID and passes it to a strongly typed Razor view in the shared folder.

Explore the core startup files of an ASP.NET Core app, including Program.cs, appsettings.json, wwwroot (dub dub dub route), and LaunchSettings.json, detailing services, middleware, environment overrides, and debugging configurations.

Examine launch settings, profiles, and environment variables in an ASP.NET Core project, including http/https ports, browser launch, appsettings.json, and logs for debugging.

Create a test controller with an index action and a razor view. Bind a test view model to the view to show the name and optionally display date of birth.

Adopt consistent naming conventions by naming controllers with the root name plus 'controller', ensure a matching view for each action, and organize files into dedicated folders for controllers and models.

Review the key takeaways from a standard asp.net core web project, including the mvc pattern, how requests are handled, and debugging in Visual Studio and Visual Studio Code.

Explore source control management with Git and GitHub, set up a GitHub account, sync your project, and apply commits, pushes, and pulls with best practices.

Learn what source control management is, focusing on Git to track code changes, support collaboration, and back up projects on remote, fault-tolerant platforms.

Explore git, a distributed version control system that tracks file versions for fast collaboration. Learn GitHub, a cloud-based repository platform owned by Microsoft for hosting code and open source projects.

Create a GitHub account, verify email, choose a username, and learn to browse public repositories, share your portfolio, collaborate, and synchronize your project with GitHub.

Learn how to synchronize a local Visual Studio project with a remote GitHub repository using git, commit, and push, and understand the master branch, git changes, and remote backup.

Install git, initialize a local repository in Visual Studio Code, publish to GitHub, and commit, push, and sync changes to private or public repo.

Log changes with commits, keep them local, and push to the remote repository. Pull changes, resolve conflicts with Visual Studio and Visual Studio Code tools, and write concise commit messages.

Explore git and GitHub basics, create a GitHub account, and learn to synchronize local code with a remote repository to back up projects and boost fault tolerance.

Explore GitHub Copilot in Visual Studio Code by using agent mode, context, and planning with MCP servers to implement a modern leaf management system homepage using existing CSS and JS.

Discover built-in GitHub Copilot chat in Visual Studio 2026, using references, agent and modernize modes, and hashtags to update pages and outline EF models.

Review the layout file, examine static assets and references, and ensure correct file references; explore the bootstrap framework and see how layout changes shape the application's look and feel.

Discover how the layout file provides the site-wide html template, maintains a uniform look, and uses dynamic sections for per-page assets like scripts and multiple layouts for different pages.

Organize static files in root and lib folders, reference css, js, and images with tilde paths; use Libman to manage libraries and ensure app serves assets via static files middleware.

Bootstrap is a free, open source CSS framework that enables responsive, mobile-first front-end web development with HTML, CSS, and JavaScript templates for common UI components.

Modify the layout file to update the header, nav bar, and footer using Bootstrap. Change to a dark nav bar with light text, and enable a container for centered content.

Review modified files in the git changes panel, compare with the original, undo if needed, and commit and push changes such as adding a dark nav bar to layout.

Review the layout file and static assets, showing how to reference libraries and organize files in the root folder. Examine bootstrap five integration for consistent layouts across pages.

Explore EF Core and database setup, learn what EF Core is and why it's used, review key packages, connection strings, and how to execute a migration to connect a database.

Entity Framework Core is an open source ORM for .NET that simplifies database interaction. It supports code first and database first patterns with migrations and maps data models to tables.

Master EF Core package management in Visual Studio and Visual Studio Code with NuGet and dotnet add package, including SQL Server and PostgreSQL adapters, and run migrations and updates.

Examine the application db context and identity db context in an ASP.NET Core project, learn how prebuilt user tables integrate with Entity Framework Core, and preview configuring the connection string.

Learn how connection strings locate databases and supply credentials for SQL Server and SQLite. Define them in appsettings.json, secure them in production, and reference them in Program.cs to configure DbContext.

Explore migrations as a version control and backup mechanism for code-first databases, tracking changes with a history table and generated migration files, using EF Core tools or .NET CLI.

Add and review a migration for the identity schema in ASP.NET Core, examine the Up and Down methods, and see how default identity tables like roles and users are created.

Create a database from a migration by running update-database, which builds the database, applies migrations, and outputs SQL for verification for the course Complete ASP.NET Core and Entity Framework Development.

Pull the Microsoft SQL Server image, run it in a Docker container with an SA password and port mapping, then connect via Azure Data Studio or SQL Server Management Studio.

Apply best practices for EF Core migrations, naming conventions, and key relationships, including descriptive migration names, db context suffix, primary and foreign key naming, and using EF Core commands.

Review the core concepts of EF Core, including required packages, migration basics, and connection strings, and learn how ASP.NET Core registers the database context at startup.

Build the leaf type module by creating the leaf type database table and applying ASP.NET Core scaffolding. Implement CRUD with dependency injection and explore asynchronous programming to power data operations.

Review module requirements for leaf types with allocated days, including sick, vacation, and maternity leaves, ensuring each type has a name and value and supports listing, creating, editing, and deleting.

Define leaf type entity with id, name, and number of days; register it in the data context; create a migration, and update the database to add leaf types table.

Explore scaffolding in mvc with entity framework to auto generate a full crud web interface for an existing database, including controllers and views, using visual studio or the dotnet tool.

Explain the index action in the leaf types controller, fetch data via the application db context with dependency injection, and render a viewable list with edit, details, and delete actions.

Explore dependency injection as a pattern for inversion of control between classes and their dependencies, from controllers to database context, and learn why it prevents manual instantiation and memory leaks.

Learn asynchronous programming with async and await to prevent blocking and keep the UI responsive during database queries, using EF Core async methods like ToListAsync, SingleAsync, FindAsync.

Explore scaffolded create view and action, including asp-action form posting, anti-forgery protection, and bootstrap validation. Learn how model binding updates the entity framework core context and redirects to index.

Explore how ASP.NET Core automatically binds form data to model properties using tag helpers, with controls generated by data types and built-in anti-forgery protection for post requests.

Execute the details action with a nullable id, fetch the leaf type using FirstOrDefault and a lambda via EF Core, and return 404 if not found.

Review the edit action for leaf types: fetch by id via find or firstordefault, use a hidden id field for binding, validate, handle concurrency, update, save, and return to index.

Demonstrate the delete workflow with id validation and a confirmation view. Perform the post delete, remove the record, save changes with anti-forgery validation, and navigate to index.

Explore end to end CRUD testing in an ASP.NET Core and Entity Framework project. Navigate leaf types index and perform create, edit, delete with model binding, validation, and parameterized sql.

Learn to tailor scaffolded ASP.NET Core views by styling action buttons with Bootstrap, reorganizing form layouts, and adding dynamic titles using model data for enhanced leaf type pages.

Commit all changes for the completed leave management module, including new tables and files, with a clear message and push after pulling in a team workflow.

complete the module by setting up a database table with ef core code first, creating a model and migration, scaffolding crud controller and views with asynchronous programming and dependency injection.

Explore viewmodels and mappers, learning to convert between models and view models. Examine data annotations in view models and refactor views and actions to use view models with best practices.

Understand how view models separate view data from database data, applying the single responsibility principle, and shape data to prevent over posting and data exposure.

refactor the index page to use an index vm by mapping the leaf types data model to a view model with linq, and organize files in a models folder.

Compare manual data model to view model mapping with and without mappers, and show how AutoMapper and other libraries like Master streamline real-time type conversions, noting performance trade-offs.

Set up automapper in an ASP.NET Core project, register it in DI, create a profile from the leaf type data model to the index view model, and map with IMapper.

Refactor the details with a leaf type read only vm, deciding between shared versus view-specific vms based on context. Map from leaf type to view model with automapper.

Learn how validations integrate with view models, using validation attributes for required fields and string length, and how client-side and server-side validation interact with model state.

Add a leaf type create vm to the create view, binding only name and number of days, and use automapper to map to the data model while preventing over posting.

Master adding data annotations to the leave type VM, enforcing required, string length, and range, while managing model state and custom server-side errors.

Refactor the edit flow to use a leave type edit VM with id and validations, and enable two-way mapping via reverse map and a new mapping profile.

Refactor view models with a base leaf type VM and inheritance, unify labels via display annotations, and ensure consistent read only, edit, and create views across the UI.

Add a database check to prevent duplicate leaf type names by querying the ef core context with a case-insensitive comparison, asynchronously, for create and edit operations.

Review how view models create a protective abstraction between views and data models, set up automapper for conversions, and enhance validation with data annotations, model state, and custom validation logic.