No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Segregación de Interfaces en Programación SOLID

12/16
Recursos

¿Cómo resolver el problema de la segregación de interfaces en programación?

En el desarrollo de software, la segregación de interfaces es un principio fundamental que asegura que las interfaces no se sobrecarguen de responsabilidades. Una interfaz bien diseñada debe ser específica para un conjunto de tareas relacionadas, evitando imponer a las clases que implementan dicha interfaz métodos que no necesitan. Vamos a explorar cómo aplicar este principio mediante un caso práctico.

¿Cuál es el problema de las interfaces "gordas"?

En el escenario presentado, se tenía la interfaz IActivities, la cual contiene muchas actividades o métodos que no todas las clases necesitan implementar. Por ejemplo:

  • La clase Developer solo necesita implementar el método Develop.
  • La clase Tester, aunque utiliza IActivities, no necesita el método Develop, pero sí requiere de una funcionalidad para pruebas.
  • El Scrum Master no estaría desarollando o probando, sino planificando y comunicando.

Estas discrepancias resaltan que las interfaces se han diseñado de forma incorrecta, creando una dependencia innecesaria de métodos que no se aplican a cada rol.

¿Cómo aplicar la segregación de interfaces?

La solución es dividir la interfaz grande en diversas interfaces más especializadas y asignarlas correctamente a las clases correspondientes. En este ejemplo práctico, se crean cuatro interfaces nuevas:

public interface IWorkingActivities {
    void Plan();
    void Communicate();
}

public interface IDesignActivities {
    void Design();
}

public interface IDevelopActivities {
    void Develop();
}

public interface ITestActivities {
    void Test();
}

¿Cómo asignamos las interfaces a los roles?

Cada clase ahora implementa solo las interfaces que reflejan sus verdaderas responsabilidades:

  • Developer: Implementa IWorkingActivities e IDevelopActivities.
  • Tester: Implementa IWorkingActivities y ITestActivities.
  • Scrum Master: Podría implementar IWorkingActivities e, hipotéticamente, partes de IDesignActivities.

Este diseño permite un código más limpio y evita errores porque cada clase solo es responsable de las actividades que realmente realiza.

¿Cómo manejamos las actividades comunes?

Una buena práctica cuando hay actividades comunes es crear una interfaz madre que herede de otras interfaces. Por ejemplo, la interfaz IActivitiesComplete puede combinar métodos de múltiples interfaces:

public interface IActivitiesComplete : IWorkingActivities, IDesignActivities, IDevelopActivities, ITestActivities {}

Esta técnica es útil cuando un nuevo rol incluye todas o varias de las actividades, como podría ser el caso de un Architect, quien participa en cada fase del desarrollo de software.

¿Un ejercicio práctico para ti?

Para consolidar lo aprendido, puedes intentar crear un nuevo rol dentro de tu proyecto. Elige un rol común en una empresa de software, como un Product Manager, y diseña interfaces para describir sus actividades específicas. Luego, implementa esas interfaces siguiendo el principio de segregación.

Este tipo de prácticas te ayudará a comprender mejor los beneficios del principio SOLID, aumentando la eficiencia y mantenibilidad de tu código. ¡No olvides que este es un camino de aprendizaje continuo!

Aportes 13

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Falto agregar IDesingActivities a ScrumMaster

Arquitecto -> Architect 😛

¡Wow! Se puede hacer herencia entre interfaces, esa no me la sabía. 😄

Lindo ejemplo suma! me encantaria que sean “Mas relacionados a trabajos” no un codigo prolijo, y entendible.

Este curso es demasiado bueno para entender SOLID ✌.

Muy bien explicado

Creé una interfaz para los ingenieros Cloud:

namespace InterfaceSegregation
{
  public class Cloud
  {
    public void CreateCloud()
    {
      System.Console.WriteLine("I'm creating the Cloud Infrastructure");
    }
  }
}

Y la uso en Program.cs:

using InterfaceSegregation;

new Developer().Develop();
new Cloud().CreateCloud();
Mi aporte. He agregado una Interface IProductActivities y una clase ProductOwner IProductActivities ![](https://static.platzi.com/media/user_upload/imagen-9f738d09-bce6-44f2-88cd-269a8b0da7b9.jpg) ProductOwner ![](https://static.platzi.com/media/user_upload/imagen-e8faa41c-6180-45ac-92fd-34ca13d6340a.jpg) Clase Program ![](https://static.platzi.com/media/user_upload/imagen-fa3c8e77-5b6d-4296-814a-af4cfb1c7a93.jpg) Resultados ![](https://static.platzi.com/media/user_upload/imagen-d06d8c4c-9140-42ed-a604-a045d8e6c8cc.jpg)
Mi aporte. Agregué una Interface IproductActivities y una clase ProductManager que implementa de IProductActivities. IProductActivities abstrae responsabilidades de Product Owner. ![](https://static.platzi.com/media/user_upload/imagen-dc10efb3-864f-4c68-b706-586df0881ed8.jpg) ![](https://static.platzi.com/media/user_upload/imagen-caf04769-54ee-4ad2-87d8-53828e00fcc9.jpg)
Mi aporte, agregué la In ![](https://static.platzi.com/media/user_upload/imagen-d5df51ce-89b2-4c0b-b900-f001d70d18a5.jpg)![](https://static.platzi.com/media/user_upload/imagen-8f8cd5d8-2fe6-4f80-8197-aca911e4f912.jpg)

Reto:

Role DevOps

namespace InterfaceSegregation
{
public class DevOps : IDeploy
{
public DevOps()
{
}

    public void Deploy()
    {
        Console.WriteLine("The new implementation will be release on November 30");
    }
}

}

Activity: Deploy

namespace InterfaceSegregation
{
public interface IDeploy
{
void Deploy();
}
}

// New rol: TechLead namespace InterfaceSegregation{ public interface ITechLeadActivities: IWorkteamActivities, IDevelopActivities { void EstablishingProjectSpecifications (); void OverseeingSoftwareQuality(); }} namespace InterfaceSegregation{ public class TechLead : ITechLeadActivities { public TechLead() { } public void Plan() { throw new ArgumentException(); } public void Comunicate() { throw new ArgumentException(); } public void Develop() { Console.WriteLine("I'm developing the functionalities required"); } public void EstablishingProjectSpecifications() { throw new ArgumentException(); } public void OverseeingSoftwareQuality() { throw new ArgumentException(); } }}

Cuando no hay access modifier en una interfaz, esta toma por defecto el accesso private, aparentemente.