Começando com Clean Architecture: Um Guia Prático para Iniciantes

Introdução

Olá, devs! Vamos falar sobre um dos conceitos mais legais e úteis para melhorar seu código: a Clean Architecture.

Você já se pegou tentando entender um código bagunçado ou achou difícil adicionar uma nova funcionalidade sem quebrar nada?

Clean Architecture está aqui para salvar o dia!

Neste post, vou mostrar o básico dessa abordagem e como ela pode transformar seus projetos de software, deixando tudo mais organizado e fácil de manter.

Bora?

O que é Clean Architecture?

Então, o que é essa tal de Clean Architecture?

Clean Architecture são princípios de design de software introduzidos por Robert C. Martin, também conhecido como “Uncle Bob.”. Basicamente, é uma forma de organizar seu código em camadas bem definidas, onde cada uma tem sua própria responsabilidade. Para maximizar os benefícios, é fundamental seguir também os princípios do Clean Code.

Isso ajuda a manter as coisas separadas e independentes, o que é ótimo para facilitar a manutenção e evolução do software.

Princípios Básicos de Independência

Independência de Frameworks: O sistema não deve depender de frameworks. Eles são ferramentas, não soluções.
Testabilidade: A lógica de negócio pode ser testada independentemente dos detalhes de implementação;
Independência de Interface de Usuário: A interface de usuário pode mudar sem afetar a lógica de negócio;
Independência de Banco de Dados: O sistema pode funcionar com qualquer banco de dados ou mesmo sem um;
Independência de Agentes Externos: As regras de negócio são isoladas de agentes externos, como APIs.

Benefícios da Clean Architecture

Adotar a Clean Architecture traz diversos benefícios para os projetos de software:

Manutenibilidade: Código mais fácil de entender e modificar;
Testabilidade: Facilita a criação de testes automatizados;
Flexibilidade: Mudanças em uma parte do sistema não afetam outras partes;
Escalabilidade: Facilita a adição de novas funcionalidades;
Reutilização: Componentes bem definidos podem ser reutilizados em outros projetos;

Camadas da Clean Architecture

A Clean Architecture é dividida em várias camadas, cada uma com suas responsabilidades. Vamos explorar cada uma delas:

Domain Layer (Entities): As entidades representam as regras de negócio mais gerais e de maior nível. São independentes de qualquer detalhe específico de tecnologia ou framework;
Application Layer (Use Cases): Os casos de uso contêm a lógica de aplicação específica, orquestrando as interações entre as entidades e os sistemas externos;
Presentation Layer: A camada de apresentação tem a responsabilidade de ser a interface entre as regras de negócio e a user interface;
Infrastructure Layer: É aqui onde os sistemas externos, como o banco de dados, interagem com seu sistema.

Implementando Clean Architecture em C#

Vamos ver um exemplo simples e prático de como implementar Clean Architecture em um projeto C#

public class Customer
{
    public Customer(Guid id, string name, string email)
    {
        Id = id;
        Name = name ?? throw new ArgumentNullException(nameof(Name));
        Email = email ?? throw new ArgumentNullException(nameof(Email));
    }
    
    public Guid Id { get; init; }
    public string Name { get; init; }
    public string Email { get; init; }
}

public class CreateCustomer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public interface ICustomerService
{
    Guid Add(Customer customer);
    Customer GetById(Guid id);
}

public class CustomerService : ICustomerService
{
    private readonly ICustomerRepository _customerRepository;

    public CustomerService(ICustomerRepository customerRepository)
    {
        _customerRepository = customerRepository;
    }

    public Guid Add(CreateCustomer request)
    {
        var id = Guid.NewGuid();
        
        var customer = new Customer(id, request.Name, request.Email);
        
        _customerRepository.Add(customer);
        
        return id;
    }

    public Customer GetById(Guid id)
    {
        return _customerRepository.GetById(id);
    }
}

[ApiController]
[Route("customers")]
public class CustomerController : ControllerBase
{
    private readonly ICustomerService _customerService;

    public CustomerController(ICustomerService customerService)
    {
        _customerService = customerService;
    }

    [HttpPost]
    public IActionResult Add([FromBody] CreateCustomer request)
    {
        var id = _customerService.Add(request);
        return Ok(id);
    }

    [HttpGet("{id}")]
    public IActionResult Get(Guid id)
    {
        var customer = _customerService.GetById(id);
        
        if (customer is null)
          return NotFound();

        return Ok(customer);
    }
}

public class CustomerRepository : ICustomerRepository
{
    private readonly AppDbContext _context;

    public CustomerRepository(AppDbContext context)
    {
        _context = context;
    }

    public void Add(Customer customer)
    {
        _context.Customers.Add(customer);
        _context.SaveChanges();
    }

    public Customer? GetById(Guid id)
    {
        return _context.Customers.FirstOrDefault(c => c.Id == id);
    }
}

Boas Práticas e Dicas

Para manter sua arquitetura limpa e eficiente, siga estas boas práticas:

Isolar dependências: Certifique-se de que suas camadas internas não dependam de detalhes de implementação das camadas externas;
Seguir o princípio de responsabilidade única (SRP): Cada classe deve ter uma única responsabilidade bem definida;
Facilitar testes: Utilize injeção de dependências para facilitar a criação de testes automatizados.

Conclusão

Adotar a Clean Architecture pode transformar a maneira como você desenvolve software, trazendo clareza, flexibilidade e manutenibilidade ao seu código. Complementar essa abordagem com os princípios de Clean Code pode potencializar ainda mais esses benefícios.

Embora possa parecer complexa no início, a prática constante e a adoção gradual dos princípios e padrões tornarão esse modelo natural no seu dia a dia. Experimente aplicar esses conceitos em seus projetos e veja como eles podem melhorar a qualidade e a robustez do seu software.

Agora que você conhece um pouco mais sobre Clean Architecture, me conte mais o que achou. Gostou?

Até!