This project is an example of architecture using new technologies and best practices.

The goal is to learn and share knowledge and use it as reference for new projects.

• Clean Architecture
• Clean Code
• SOLID Principles
• KISS Principle
• DRY Principle
• Fail Fast Principle
• Common Closure Principle
• Common Reuse Principle
• Acyclic Dependencies Principle
• Mediator Pattern
• Result Pattern
• Folder-by-Feature Structure
• Separation of Concerns

• 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.

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

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

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

Web: Frontend and Backend.

Application: Flow control.

Domain: Business rules and domain logic.

Model: Data transfer objects.

Database: Data persistence.

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

export class AppCustomerService { }

It validates if a route can be activated.

export class AppGuard implements CanActivate { }

It provides a hook for centralized exception handling.

export class AppErrorHandler implements ErrorHandler { }

It intercepts and handles an HttpRequest or HttpResponse.

export class AppHttpInterceptor implements HttpInterceptor { }

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

[ApiController]
[Route("customers")]
public sealed class CustomerController : BaseController
{
    [HttpPost]
    public IActionResult Add(AddCustomerRequest request) => Mediator.HandleAsync<AddCustomerRequest, AddCustomerResponse>(request).ApiResult();

    [HttpDelete("{id:long}")]
    public IActionResult Delete(long id) => Mediator.HandleAsync(new DeleteCustomerRequest(id)).ApiResult();

    [HttpGet("{id:long}")]
    public IActionResult Get(long id) => Mediator.HandleAsync<GetCustomerRequest, GetCustomerResponse>(new GetCustomerRequest(id)).ApiResult();

    [HttpGet("grid")]
    public IActionResult Grid([FromQuery] GridCustomerRequest request) => Mediator.HandleAsync<GridCustomerRequest, GridCustomerResponse>(request).ApiResult();

    [HttpGet]
    public IActionResult List() => Mediator.HandleAsync<ListCustomerRequest, ListCustomerResponse>(new ListCustomerRequest()).ApiResult();

    [HttpPut("{id:long}")]
    public IActionResult Update(UpdateCustomerRequest request) => Mediator.HandleAsync(request).ApiResult();
}

It has only business flow, not business rules.

It has properties representing the request.

public sealed record AddCustomerRequest;

It has rules for validating the request.

public sealed class AddCustomerRequestValidator : AbstractValidator<AddCustomerRequest> { }

It has properties representing the response.

public sealed record AddCustomerResponse;

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.

public sealed record AddCustomerHandler : IHandler<AddCustomerRequest, AddCustomerResponse>
{
    public async Task<Result<AddCustomerResponse>> HandleAsync(AddCustomerRequest request)
    {
        return Result<AddCustomerResponse>.Success(new AddCustomerResponse());
    }
}

It creates a complex object.

Any change to object affects compile time rather than runtime.

public interface ICustomerFactory { }

public sealed class CustomerFactory : ICustomerFactory { }

It has no any references to any layer.

It has aggregates, entities, value objects and services.

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.

public sealed class CustomerAggregate { }

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.

public sealed class Customer : Entity { }

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.

public sealed record ValueObject;

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.

public interface ICustomerService { }

public sealed class CustomerService : ICustomerService { }

It has properties to transport and return data.

public sealed record CustomerModel;

It encapsulates data persistence.

It configures the connection and represents the database.

public sealed class Context : DbContext
{
    public Context(DbContextOptions options) : base(options) { }
}

It configures the entity and its properties in the database.

public sealed class CustomerConfiguration : IEntityTypeConfiguration<Customer>
{
    public void Configure(EntityTypeBuilder<Customer> builder) { }
}

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

public interface ICustomerRepository : IRepository<Customer> { }

public sealed class CustomerRepository : Repository<Customer>, ICustomerRepository
{
    public CustomerRepository(Context context) : base(context) { }
}