Hey devs, nos ponemos técnicos y de principios jaja, en esta ocasión te mostraré qué es esto del principio "Interface Segregation Principle" uno de los famosísimos principios SOLID, particularmente el principio de la letra I y con un ejemplo real en C#, así que ponte el cinturón porque comenzaremos a toda velocidad. 🚀

Introducción

Cuando diseñamos software en C#, a menudo creamos interfaces para definir el comportamiento de nuestras clases. Sin embargo, un error común es diseñar interfaces demasiado grandes que obligan a las clases a implementar métodos que no necesitan. Aquí es donde entra en juego el Principio de Segregación de Interfaces (Interface Segregation Principle o ISP), uno de los cinco principios SOLID.

¿Qué es el principio de Segregación de Interfaces?

El Principio de Segregación de Interfaces (ISP) establece que una interfaz no debe obligar a una clase a implementar métodos que no usa. Entonces en lugar de diseñar interfaces enormes y genéricas, debemos dividirlas en múltiples interfaces más pequeñas y específicas.

Este principio ayuda a evitar acoplamientos innecesarios, hace que el código sea más flexible y facilita la mantenibilidad.

Identificando el problema: Interfaces muy grandes

Imagina que estás desarrollando un sistema de pago para un e-commerce digamos MercadoReLibre 🤣. Podríamos diseñar una interfaz genérica para procesar distintos tipos de pagos, créeme que he visto varias veces algo así:

public interface IPaymentProcessor
{
    void ProcessCreditCardPayment(decimal amount);
    void ProcessPayPalPayment(decimal amount);
    void ProcessBitcoinPayment(decimal amount);
}

A simple vista parece una buena solución, pero genera problemas.

Te pongo el caso: Si creamos una implementación que solo maneja pagos con tarjeta de crédito llamada CreditCardPayment, se verá obligada a implementar métodos que no usa:

public class CreditCardPayment : IPaymentProcessor
{
    public void ProcessCreditCardPayment(decimal amount)
    {
        Console.WriteLine($"Pago con tarjeta de crédito procesado: US${amount}");
    }

    public void ProcessPayPalPayment(decimal amount)
    {
        throw new NotImplementedException(); //Ya que no acepto PayPal
    }

    public void ProcessBitcoinPayment(decimal amount)
    {
        throw new NotImplementedException(); //Tampoco acepto Bitcoin
    }
}

Esto viola el ISP, ya que CreditCardPayment se ve obligada a implementar métodos innecesarios.

Además, si agregamos un nuevo método de pago en el futuro, todas las clases que implementan IPaymentProcessor deberán modificarse, incluso si no lo necesitan.

Solucionando dicho problema con el ISP

Pero ahora vas a aprender dev, para corregir este error, debemos dividir la interfaz en varias más pequeñas y específicas:

public interface ICreditCardPayment
{
    void ProcessCreditCardPayment(decimal amount);
}

public interface IPayPalPayment
{
    void ProcessPayPalPayment(decimal amount);
}

public interface IBitcoinPayment
{
    void ProcessBitcoinPayment(decimal amount);
}

Ahora, cada clase implementa únicamente la interfaz que necesita:

public class CreditCardPayment : ICreditCardPayment
{
    public void ProcessCreditCardPayment(decimal amount)
    {
        Console.WriteLine($"Pago con tarjeta de crédito procesado: US${amount} como debe ser!");
    }
}

public class PayPalPayment : IPayPalPayment
{
    public void ProcessPayPalPayment(decimal amount)
    {
        Console.WriteLine($"Pago con PayPal procesado: US${amount} de forma estupenda");
    }
}

public class BitcoinPayment : IBitcoinPayment
{
    public void ProcessBitcoinPayment(decimal amount)
    {
        Console.WriteLine($"Pago con Bitcoin procesado: US${amount} como lo hacen los cracks xd");
    }
}

Toma nota de las ventajas de aplicar este principio

Como podrás haber notado estimado dev, este principio va a elevar la calidad de tu código, aquí te listo al menos tres beneficios de aplicarlo:

➡️ Cada clase solo implementa lo que necesita, evitando código innecesario.

➡️ Si agregamos un nuevo método de pago, no afectará a las clases existentes.

➡️ El código se vuelve más modular, extensible y fácil de mantener, yeah.

Conclusiones

El Principio de Segregación de Interfaces es una práctica clave en el diseño de software. Nos ayuda a crear código más limpio y desacoplado, evitando que las clases implementen métodos innecesarios. Siguiendo este principio, logramos sistemas más flexibles y mantenibles.

Si en tu proyecto notas que una interfaz está obligando a una clase a hacer más de lo que debería, es hora de dividirla y aplicar ISP. Por supuesto que tu código te lo agradecerá! y además dev, ya tienes un ejemplo real para que se lo menciones cuando te lo pregunten en una entrevista técnica 😎🐿️ No te olvides nomás de pasarle la voz a tus colegas de mi blog! 🐿️🔥

Si esta entrada te ha gustado dev, compártela! 🥳

Créditos de la imagen de portada: Basada en Foto de Mike Petrucci en Unsplash