- Learning how to design modular applications will help you become a better engineer. Designing modular applications is the holy grail of software architecture, it is hard to find engineers experienced in designing applications which allows adding new features at a steady speed.
- .NET Core brings a sweet development environment, an extensible and cross-platform framework. We will explore the benefits of it in the infrastructure layer and we will reduce its importance in the application and domain layers. The same rule is applied for modern C# language syntax.
The general idea behind Hexagonal architecture style is that the dependencies (Adapters) required by the software to run are used behind an interface (Port).
The software is divided into Application and Infrastructure in which the adapters are interchangeable components developed and tested in isolation. The Application is loosely coupled to the Adapters and their implementation details.
Interfaces like ICustomerRepository, IOutputPort and IUnitOfWork are ports required by the application.
The interface implementations, they are specific to a technology and bring external capabilities. For instance the CustomerRepository inside the EntityFrameworkDataAccess folder provides capabilities to consume an SQL Server database.
Primary Actors are usually the user interface or the Test Suit.
The Secondary Actors are usually Databases, Cloud Services or other systems.
Very similar to Ports and Adapters, I would add that data objects cross boundaries as simple data structures. For instance, when the controller execute a use case it passes an immutable Input message. When the use cases calls a Presenter it gives an Output message (Data Transfer Objects if you like).
The Clean Architecture style focus on a loosely coupled implementation of use cases and it is summarized as:
- It is an architecture style that the Use Cases are the central organizing structure.
- Follows the Ports and Adapters pattern.
- The implementation is guided by tests (TDD Outside-In).
- Decoupled from technology details.
- Follows lots of principles (Stable Abstractions Principle, Stable Dependencies Principle, SOLID and so on).
Relation and dependency between projects:
Layer Domain or Entities
Layer Application or Use Cases
Layer Application with Services to Mapper and Convertion Objects
Layer Infra
Layer Infra.Data
Layer Domain X Infra.Data
Layer Infra.IoC
Layer Web.UI
- Adicionar ao projeto CleanArchMvc.Infra.Data as referências:
<PackageReference Include="Microsoft.AspNetCore.Identity" Version="2.2.0" />
<PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="5.0.17" />
- Criar a classe ApplicationUser que herda de IdentityUser
public class ApplicationUser :IdentityUser { }
- Alterar a herança da classe ApplicationDbContext para: public class ApplicationUser :IdentityUser { }
public class ApplicationDbContext : IdentityDbContext<ApplicationUser> { ... }
- Acessar o Nuget Packeg Console, irá criar o arquivo de migration referente ao Identity
$ add-migration AddIdentityTables- Nuget Packeg Console, rodar o comando abaixo para aplicar a migration criada acima para refletir no DB.
$ update-database
Todos os créditos são do professor @Macorrati | Feito com ❤️ por Douglas Lima
Entre em contato!