Clean Code en C#: principios para escribir código legible con ejemplos

Introducción: ¿Por qué el código limpio es la clave del éxito de un proyecto?

En el mundo del desarrollo de software en la plataforma .NET, escribir código funcional es solo la mitad del trabajo. La verdadera maestría se demuestra en la capacidad de crear código que sea fácil de leer, mantener y ampliar. El concepto de Clean Code (Código Limpio), popularizado por Robert Martin, es un conjunto de principios que transforman un programa caótico en un sistema ordenado y comprensible. Para un desarrollador de C#, seguir estos principios significa no solo respeto hacia los colegas, sino también una reducción significativa del tiempo dedicado a la depuración y la implementación de nuevas funcionalidades.

En este artículo, analizaremos los principios clave de Clean Code aplicados al lenguaje C# y al framework .NET. Verá ejemplos concretos de código "malo" y "bueno" que le ayudarán a escribir aplicaciones de mayor calidad.

Principio 1: Nombres descriptivos y estilo uniforme

Nombrado correcto de variables y métodos

El nombre de una variable, clase o método debe responder a las preguntas: "¿Qué es esto?" o "¿Qué hace?". Evite abreviaturas de una sola letra (excepto para contadores de bucles) y nombres abstractos como data, info, temp.

Ejemplo malo:

public int Calc(int a, int b) // ¿Qué son a y b? ¿Qué hace el método?{    int d = a * b;    return d;}

Ejemplo bueno (Clean Code):

/// <summary>/// Calcula el área de un rectángulo./// </summary>public int CalculateRectangleArea(int width, int height){    int area = width * height;    return area;}

Uniformidad en el equipo

Use camelCase para variables locales y parámetros, PascalCase para métodos y clases, _camelCase para campos privados (según las guías populares de .NET). Esto hace que el código sea predecible.

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

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

Principio 2: Funciones pequeñas y principio de responsabilidad única (SRP)

Una función debe hacer solo una cosa

Este es el principio más importante de Clean Code. Si un método realiza varias acciones (validación, registro en log, lógica de negocio, guardado en BD), es difícil de probar y modificar. Divida estos métodos en otros más pequeños.

Ejemplo malo (el método lo hace todo de una vez):

public void ProcessOrder(Order order){    // 1. Validación    if (order == null || order.TotalAmount <= 0)        throw new ArgumentException("Invalid order");

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

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

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

Ejemplo bueno (división en 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 - (order.TotalAmount * discountRate);    }}