Clean Architecture in ASP.NET Core is a software architectural pattern that promotes separation of concerns and maintainability in application development. It provides a structured approach to designing and organizing the codebase, making it easier to understand, test, and modify.

At its core, Clean Architecture emphasizes the independence of the business logic from external dependencies like frameworks, databases, or user interfaces. It achieves this through the use of layers, each with its own specific responsibility.These layers are basically UI , Business Logic Layer, and Data Access Layer. 

1. Domain Layer: This layer represents the core business logic and contains entities, value objects, and business rules. It should be independent of any infrastructure or framework.

2. The Application Core holds the business model, which includes entities, services, and interfaces. These interfaces include abstractions for operations that will be performed using Infrastructure, such as data access, file system access, network calls, etc. Sometimes services or interfaces defined at this layer will need to work with non-entity types that have no dependencies on UI or Infrastructure. These can be defined as simple Data Transfer Objects (DTOs).


Application Core types

1. Entities (business model classes that are persisted)

2. Aggregates (groups of entities)

3. Interfaces

4. Domain Services

5. Specifications

6. Custom Exceptions and Guard Clauses
7. Domain Events and Handlers




3. Infrastructure Layer: This layer handles external concerns such as databases, frameworks, or external services. It provides implementations for interfaces defined in the application layer, enabling communication with external systems.

Infrastructure type

1. EF Core types (DbContext, Migration)

2. Data access implementation types (Repositories)

3.I:nfrastructure-specific services (for example, FileLogger or SmtpNotifier)



4.UI Layer:The user interface layer in an ASP.NET Core MVC application is the entry point for the application. This project should reference the Application Core project, and its types should interact with infrastructure strictly through interfaces defined in Application Core. No direct instantiation of or static calls to the Infrastructure layer types should be allowed in the UI layer.



UI Layer types

1. Controllers

2. Custom Filters

3. Custom Middleware

4. Views

5. ViewModels

6. Startup






https://github.com/ardalis/CleanArchitecture/tree/main/src/Clean.Architecture.Web



https://github.com/dotnet-architecture/eShopOnWeb



https://github.com/jasontaylordev/CleanArchitecture

Tools
Visual studio 2022
SQL server
SQL management studio

My explanation in more simpler form instead of using MVC . All the code are separated as follows.


Domain layer
Application core
Infrastructure layer
UI layer

For more knowledge for advance ASP.NET 6,7 and 8 u have to master the following to build enterprise code using clean codes EF Core, SQL, MediatR, WebAPI, Blazor,CQRS,DDD using clean architecture.


By mastering these technologies and concepts, professional developers can build enterprise-grade code that is scalable, maintainable and adheres to best practices in software development. It enables the development of robust applications that can handle complex business requirements efficiently.