Home
Clean Architecture is a software architecture intended to keep the code under control without all tidiness that spooks anyone from touching a code after the release. The main concept of Clean Architecture is the application code/logic which is very unlikely to change, has to be written without any direct dependencies. So it means that if I change my framework, database, or UI, the core of the system(Business Rules/ Domain) should not be changed. It means external dependencies are completely replaceable.
There are four layers of clean architecture,
In Clean architecture, the Domain and Application layers remain at the center of the design which is known as the Core of the system.
The Domain layer contains enterprise logic, entities, enums, models, exceptions, interfaces. Enterprise logic can be shared across many systems. Note that this layer will never depend on anything else.
The Application layer contains business logic, interfaces, CQRS features and types. The business logic will typically only be used within the system.
Core should not be dependent on data access and other infrastructure concerns so those dependencies are inverted. This is achieved by adding interfaces or abstractions within Core that are implemented by layers outside of Core. For example, if you wanted to implement the Repository pattern you would do so by adding an interface within Core and adding the implementation within Infrastructure. This is also known and DIP or Dependency Inversion Principle.
All dependencies flow inwards and Core has no dependency on any other layer. Infrastructure and Presentation depend on Core, but not on one another.
The Infrastructure layer contains classes for accessing external resources such as file systems, web services, SMTP, and so on. These classes should be based on interfaces defined within the Application layer. Whenever there is a requirement to communicate with an external source, we implement it on the Infrastructure Layer. For example, Database or other Services will be included here.
The WebUI layer represents the Presentation layer, where you would put in the project that the user can interact with. This project is a SPA (single page app) based on ASP.NET Core. This layer depends on both the Application and Infrastructure layers. The dependency on Infrastructure is only to support dependency injection. Therefore Startup.cs should include the only reference to Infrastructure.
The key concept of Clean Architecture is that the inner layer should not know about the outer layer but the outer layer should know about the inner layer. So, Core will have no project reference. But, infrastructure will know about Core. And, API will know about all three layers.