Architecture

Principles and Patterns

• Clean Architecture
• Clean Code
• SOLID Principles
• KISS Principle
• DRY Principle
• Mediator Pattern
• Result Pattern
• Folder-by-Feature Structure

Benefits

• Simple and evolutionary architecture.
• Standardized and centralized flow for validation, log, security, return, etc.
• Avoid cyclical references.
• Avoid unnecessary dependency injection.
• Segregation by feature instead of technical type.
• Single responsibility for each request and response.
• Simplicity of unit testing.

Technologies

• .NET
• ASP.NET Core
• Entity Framework Core
• C#
• Angular
• UIkit

Packages

• Source: https://github.com/rafaelfgx/DotNetCore

• Published: https://www.nuget.org/profiles/rafaelfgx

Run

Layers

• Web: Frontend and Backend.

  • Frontend

    • Service: It is the interface between frontend and backend and has logic that does not belong in components.

    • Guard: It validates if a route can be activated.

    • ErrorHandler: It provides a hook for centralized exception handling.

    • HttpInterceptor: It intercepts and handles an HttpRequest or HttpResponse.

  • Backend

    • Controller: It has no any logic, business rules or dependencies other than mediator.

• Application: Flow control. It has only business flow, not business rules.

  • Request: It has properties representing the request.

  • Request Validator: It has rules for validating the request.

  • Response: It has properties representing the response.

  • Handler: It is responsible for the business flow and processing a request to return a response. It call factories, repositories, unit of work, services or mediator, but it has no business rules.

  • Factory: It creates a complex object. Any change to object affects compile time rather than runtime.

• Domain: Business rules and domain logic. It has no any references to any layer. It has aggregates, entities, value objects and services.

  • Aggregate: It defines a consistency boundary around one or more entities. The purpose is to model transactional invariants. One entity in an aggregate is the root, any other entities in the aggregate are children of the root.

  • Entity: It has unique identity. Identity may span multiple bounded contexts and may endure beyond the lifetime. Changing properties is only allowed through internal business methods in the entity, not through direct access to the properties.

  • Value Object: It has no identity and it is immutable. It is defined only by the values ​​of its properties. To update a value object, you must create a new instance to replace the old one. It can have methods that encapsulate domain logic, but these methods must have no side effects on the state.

  • Services: It performs domain operations and business rules. It is stateless and has no operations that are not a part of an entity or value object.

• Model: Data transfer objects. It has properties to transport and return data.

• Database: Data persistence.

  • Context: It configures the connection and represents the database.

  • Entity Configuration: It configures the entity and its properties in the database.

  • Repository: It inherits from the generic repository and only implements specific methods.