Conociendo el principio de abierto/cerrado

¿Qué es el principio abierto-cerrado?

El principio abierto-cerrado, conocido en inglés como Open-Close Principle, es uno de los cinco principios SOLID fundamentales en el diseño de software, propuestos por Robert C. Martin. Este principio establece que un componente de un sistema debe estar abierto para ser extendido, pero cerrado para modificaciones. Es una regla esencial que permite la evolución del software sin comprometer la estabilidad del sistema.

1. Extensibilidad: La idea es que el código debe poder ampliarse para agregar nuevas funcionalidades. Cuando se requiere un nuevo comportamiento, debería ser posible añadirlo sin tener que alterar el código existente.
2. Proteger el código probado: Esto es crucial para asegurar que el código ya probado y validado no sea alterado, minimizando así los riesgos de introducir nuevos errores durante el proceso de expansión.

¿Cómo se aplica este principio en C#?

C# ofrece herramientas y técnicas que permiten aplicar el principio abierto-cerrado de forma efectiva. Aquí te damos algunas claves esenciales para ello:

Uso de clases abstractas e interfaces

En C#, las clases abstractas e interfaces proporcionan una manera de extender funcionalidades sin alterar el código existente:

• Clases abstractas: Estas se utilizan como modelos que otras clases pueden heredar. Permiten definir métodos que las subclases deben implementar, promoviendo así la extensión sin modificar la lógica base.

  public abstract class Employee
  {
      public abstract void CalculateSalary();
  }
  
  public class FullTimeEmployee : Employee
  {
      public override void CalculateSalary()
      {
          // Implementación del cálculo para empleados a tiempo completo
      }
  }
  
  public class PartTimeEmployee : Employee
  {
      public override void CalculateSalary()
      {
          // Implementación del cálculo para empleados a medio tiempo
      }
  }
  

• Interfaces: C# no soporta la herencia múltiple, pero las interfaces ofrecen una forma poderosa de añadir capacidades a las clases sin cambiar su estructura existente. Permiten que una clase implemente múltiples interfaces, cada una centrada en una responsabilidad específica.

Ejemplo práctico con acceso a datos

Un ejemplo claro de cómo aplicar este principio se muestra en la arquitectura de acceso a datos. Imagina un sistema que requiere diferentes tipos de interacciones con una base de datos. Puedes utilizar interfaces para dividir responsabilidades:

• Una interfaz para manejar la conexión a la base de datos.
• Otra interfaz para consultas (iQuery).
• Una interfaz adicional para operaciones de eliminación (iDelete).

Cada componente del acceso a datos implementará solo las interfaces que necesite, asegurando que nuevos comportamientos pueden ser añadidos por medio de nuevas interfaces sin tocar el código existente.

public interface IDataConnection
{
    void Connect();
}

public interface IQuery
{
    void ExecuteQuery(string query);
}

public interface IDelete
{
    void DeleteItem(int id);
}

public class DataAccess : IDataConnection, IQuery, IDelete
{
    public void Connect()
    {
        // Código para conectar
    }

    public void ExecuteQuery(string query)
    {
        // Código para ejecutar consulta
    }

    public void DeleteItem(int id)
    {
        // Código para eliminar item
    }
}

¿Por qué es esencial evitar la herencia múltiple en C#?

A diferencia de otros lenguajes, en C#, no se permite la herencia múltiple de clases por las complejidades que esto podría introducir en el modelo de objetos. Sin embargo, las interfaces proporcionan una solución flexible y precisa para implementar múltiples comportamientos. Esto permite diseñar sistemas que son susceptibles de evolución y extensión, sin el riesgo de complicaciones que vendrían con la modificación directa del código existente.

Implementación de un caso práctico: EmployeeContractor

En el proyecto de clase ejemplo, donde existen clases de empleados a tiempo completo (EmployeeFullTime) y a tiempo parcial (EmployeePartTime), se rellena la necesidad de extender funcionalidad para incluir empleados contratistas sin cambiar las clases existentes. Esto se logra definiendo una nueva clase que hereda de la clase base.

public class EmployeeContractor : Employee
{
    // Implementación para empleados contratistas
}

Así, siguiendo el principio abierto-cerrado, se añade funcionalidad asegurando la integridad del sistema y preparando el terreno para futuras extensiones. La implementación respetuosa de este principio fomenta un diseño arquitectónicamente robusto y escalable.