The clean-architecture-manga repository is a .NET Core implementation of Clean Architecture, showcasing best practices in software design. It demonstrates how to structure a project using Domain-Driven Design (DDD) principles, SOLID principles, and design patterns, providing a practical example of a well-architected application.

Pros

• Implements Clean Architecture principles, promoting separation of concerns and maintainability
• Provides a real-world example of Domain-Driven Design in practice
• Includes comprehensive unit and integration tests, demonstrating good testing practices
• Offers a detailed wiki with explanations of architectural decisions and patterns used

Cons

• May be overly complex for small projects or beginners learning Clean Architecture
• Requires a solid understanding of DDD and SOLID principles to fully appreciate and utilize
• Some developers might find the strict adherence to Clean Architecture principles restrictive
• The project structure might require a learning curve for those unfamiliar with the approach

Code Examples

1. Domain Entity Example:

public sealed class Account : IAggregateRoot
{
    public Account(AccountId id, CustomerId customerId, Currency currency)
    {
        Id = id;
        CustomerId = customerId;
        Currency = currency;
    }

    public AccountId Id { get; }
    public CustomerId CustomerId { get; }
    public Currency Currency { get; private set; }
    public Credit Credit { get; private set; }
    public Debit Debit { get; private set; }
}

This code defines an Account entity with its properties and constructor, following DDD principles.

2. Use Case Example:

public sealed class CloseAccount : IUseCase<CloseAccountInput>
{
    private readonly IAccountRepository _accountRepository;
    private readonly IUnitOfWork _unitOfWork;

    public CloseAccount(
        IAccountRepository accountRepository,
        IUnitOfWork unitOfWork)
    {
        _accountRepository = accountRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<bool> Execute(CloseAccountInput input)
    {
        var account = await _accountRepository.GetAccount(input.AccountId);
        if (account == null)
            throw new AccountNotFoundException($"The account {input.AccountId} does not exist or is already closed.");

        account.Close();

        await _accountRepository.Update(account);
        await _unitOfWork.Save();

        return true;
    }
}

This code implements a use case for closing an account, demonstrating the application of Clean Architecture principles.

3. Controller Example:

[Route("api/[controller]")]
[ApiController]
public sealed class AccountsController : ControllerBase
{
    private readonly ICloseAccount _closeAccountUseCase;

    public AccountsController(ICloseAccount closeAccountUseCase)
    {
        _closeAccountUseCase = closeAccountUseCase;
    }

    /// <summary>
    /// Close an account
    /// </summary>
    [HttpDelete("{accountId}")]
    [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CloseAccountResponse))]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
    public async Task<IActionResult> Close([FromRoute][Required] Guid accountId)
    {
        var output = await _closeAccountUseCase.Execute(
            new CloseAccountInput(accountId));

        if (output == null)
        {
            return NotFound();
        }

        var response = new CloseAccountResponse(
            output.AccountId);

        return Ok(response);
    }
}

This code shows a controller implementation, demonstrating how Clean Architecture separates the presentation layer from the application logic.

Getting Started

To get started with the clean-architecture-manga project:

1. Clone the repository:

   git clone https://github.com/ivanpaulovich/clean-architecture-manga.git
   

2. Navigate to the project directory:

   c