ASP.NET Core - SOLID and Clean Architecture

Explore separation of concerns and the single responsibility principle to create modular, maintainable code. Split functionality into dedicated classes to avoid bloated, hard-to-maintain classes.

Apply the dry principle to avoid repetition, establishing a single implementation point that supports maintainability, aligns with the single responsibility and open/closed principles, and underpins dependency inversion in SOLID.

Discover how dependency inversion promotes loose coupling by abstracting dependencies with interfaces and injecting them into classes, with asp.net core’s built-in ioc container enabling maintainable, reusable code.

Explore common software architectures and learn how clean architecture improves testability and loose coupling. See how the application core, infrastructure, and user interface interact in API-driven ASP.NET Core projects.

Tour the ASP.NET Core app, tracing its move from a 3.1 all-in-one design to layered and emerging clean architecture, with refactoring from fat controllers and code smells toward maintainability.

Explore development environment in Visual Studio 2022 for building a restful api with dot net seven and dot net six compatibility, applying clean architecture, SOLID principles, and Entity Framework Core.

We set up a blank solution, rename it to air dot leave management dot clean, and organize folders for api, core, infrastructure, ui, and tests to enforce separation of concerns.

Map the solution folders to the clean architecture diagram, placing domain entities and application interfaces in the core, while outlining infrastructure, API, tests, and UI folders.

Set up the application course at the center, with the core containing domain entities and application interfaces to implement. Start with the domain project, then move along.

Create the domain project inside the core folder as a class library for the leaf management domain, defining leaf type, leaf allocation, and leave request.

Implement a cqrs get leave types query and handler with mediator, map leave type domain objects to dto, query the repository, and return a dto list to the api.

Develop the update leaf type command and its handler returning unit, and implement the delete leaf type command with a handler using repository get by ID and remove.

Explore how to add custom exceptions to control application flow, define not found exception and bad request exception, and tailor messages with a name and key for clear error handling.

Learn to implement fluent validation in ASP.NET Core, creating validators with rules for required fields, max length, and async checks, including database uniqueness via a repository.

We set up the application core by defining domain and application projects, hosting domain entities, persistence contracts, and data types for business logic, using mediator, auto mapper, and fluid validation.

Create db context with Entity Framework Core; map leaf types, leave allocations, leave requests. Override save changes for audit fields; apply configurations from assembly; register SQL Server via configuration.

Implement generic and specific repositories in the persistence layer. Inject the db context, create CRUD methods, and register scoped services for leave type, leave allocation, and leave requests.

Create the leave management infrastructure project to host contract implementations, set up a public static infrastructure services class with a service collection method, and prepare to integrate the email service.

Implement a cloud-based email service with SendGrid, defining the email sender contract and models for email message. Configure IOptions and register the email service with the API key.

Review section milestones by setting up the persistence project, implementing repositories, creating the infrastructure project for third-party services, configuring email and logging with strongly typed options, and reviewing source control.

Configure the api project by wiring extension-based services from application, infrastructure, and persistence, wiring app settings for email and connection strings, and enabling a course policy for external requests.

Scaffold a database by installing core tools, setting the correct startup project, adding an initial migration for leave types, leave allocations, and leave requests, then update the database.

Implement a thin api controller for leave types using MediatR, sending a get leave types query to its handler and returning a leave type dto, with Swagger OpenAPI support.

Implement and test a MediatR-based controller for leave types, covering get by id, create, update, and delete, with validation, AutoMapper mappings, Swagger documentation, and robust error handling.

Implement the complete leave request feature with queries and commands, including list and detail views, create update delete, cancel, and change approval workflows, plus shared validation and base leave request.

Implement a global exception middleware for an ASP.NET Core app to map exceptions to appropriate HTTP status codes and return custom validation problem details.

Explore how solid principles improve testability by authoring unit and integration tests with xUnit and mock frameworks, enabling fluent assertions and regression testing to preserve existing functionality.

Set up a mock leaf type repository to unit test the leaf types handler, using dependency injection and mocked GetAsync to validate known outcomes.

Evaluate integration testing with Entity Framework Core using an in-memory database to ensure create and update operations set date created and date modified, validating third-party data access through xUnit tests.

Validate that code operates as expected with automated tests, using mocks for dependencies in clean, modular designs. Distinguish unit and integration tests and write more tests.

Add UI for an ASP.NET core app using Blazar, generate code for API integration with Swagger Studio, configure JWT security with admin and employee roles, and build leave management interface.

Create a Blazor WebAssembly UI project within an ASP.NET Core solution, exploring project setup, templates, and core structure, including wwwroot, pages, components, and HTTP client integration with an API.

Add a typed http client for the api, set the base address from the api uri, and create contracts and implementations for leaf type, leave allocation, and leave request services.

Set up identity services in ASP.NET Core, configure identity core, and secure API and frontend interactions with administrative and employee roles using JWT authentication.

Review the segment on blazer web assembly for a single page app, code generation with Nswc Studio, custom components, and identity with JWT security for API communication.

Create leave request and leave type view models and a create page in a blazer app. Load leaf types from API, validate inputs, submit via the service, and navigate back.

Create an admin leave request view in asp.net core, exposing leave requests with employee details and IDs, and enable status updates via API, UI, and mapping logic.

Set up the details page for leave requests, implement approve and reject flows with update approval, handle UI state changes, and navigate back to the list after admin approval.

Review a working asp.net core leave application built on clean architecture, featuring admin approvals, employee cancellations, and token-based security across UI and API.