Clean Code em C#: princípios de escrita de código legível com exemplos

Introdução: Por que o código limpo é a chave para um projeto bem-sucedido?

No mundo do desenvolvimento de software na plataforma .NET, escrever código funcional é apenas metade do trabalho. A verdadeira maestria se manifesta na capacidade de criar código que seja fácil de ler, manter e estender. O conceito de Clean Code, popularizado por Robert Martin, representa um conjunto de princípios que transformam um programa caótico em um sistema organizado e compreensível. Para um desenvolvedor C#, seguir esses princípios significa não apenas respeito pelos colegas, mas também uma redução significativa no tempo de depuração e na implementação de novos recursos.

Neste artigo, vamos analisar os princípios-chave do Clean Code aplicados à linguagem C# e ao framework .NET. Você verá exemplos concretos de código "ruim" e "bom" que o ajudarão a escrever aplicações de maior qualidade.

Princípio 1: Nomes significativos e estilo consistente

Nomeação correta de variáveis e métodos

O nome de uma variável, classe ou método deve responder às perguntas: "O que é isso?" ou "O que ele faz?". Evite abreviações de uma letra (exceto para contadores de loop) e nomes abstratos como data, info, temp.

Exemplo ruim:

public int Calc(int a, int b) // O que são a e b? O que o método faz?{    int d = a * b;    return d;}

Exemplo bom (Clean Code):

/// <summary>/// Calcula a área de um retângulo./// </summary>public int CalculateRectangleArea(int width, int height){    int area = width * height;    return area;}

Consistência na equipe

Use camelCase para variáveis locais e parâmetros, PascalCase para métodos e classes, _camelCase para campos privados (de acordo com as diretrizes populares do .NET). Isso torna o código previsível.

public class OrderService{    private readonly IOrderRepository _orderRepository; // campo privado

    public async Task<Order> GetOrderByIdAsync(int orderId) // método    {        var order = await _orderRepository.FindAsync(orderId); // variável local        return order;    }}

Princípio 2: Funções pequenas e princípio da responsabilidade única (SRP)

A função deve fazer apenas uma coisa

Este é o princípio mais importante do Clean Code. Se um método executa várias ações (validação, registro em log, lógica de negócios, salvamento no banco de dados), é difícil testá-lo e modificá-lo. Divida esses métodos em partes menores.

Exemplo ruim (método faz tudo de uma vez):

public void ProcessOrder(Order order){    // 1. Validação    if (order == null || order.TotalAmount <= 0)        throw new ArgumentException("Invalid order");

    // 2. Registro em log    Console.WriteLine($"Processing order {order.Id}");

    // 3. Lógica de negócios    var discount = order.TotalAmount > 100 ? 0.1m : 0;    order.FinalAmount = order.TotalAmount - (order.TotalAmount * discount);

    // 4. Salvamento    _context.Orders.Add(order);    _context.SaveChanges();}

Exemplo bom (divisão em métodos):

public void ProcessOrder(Order order){    ValidateOrder(order);    LogOrderProcessing(order);    ApplyDiscount(order);    SaveOrder(order);}

private void ValidateOrder(Order order){    if (order == null || order.TotalAmount <= 0)        throw new ArgumentException("Invalid order", nameof(order));}

private void LogOrderProcessing(Order order){    Console.WriteLine($"Processing order {order.Id}");}

private void ApplyDiscount(Order order){    const decimal discountThreshold = 100m;    const decimal discountRate = 0.1m;

    if (order.TotalAmount > discountThreshold)    {        order.FinalAmount = order.TotalAmount - (or