Aplicación del Principio de Abierto/Cerrado en Programación

Clase 8 de 16 • Curso de Principios SOLID en C# y .NET

Contenido del curso

Introducción

Principio de responsabilidad única

Principio de abierto/cerrado

Principio de sustitución de Liskov

Principio de segregación de la interfaz

Principio de inversión de la dependencia

Cierre

16
Principios Solid en C Sharp: Mejora y Aplicación Práctica
02:21 min

Tomar examen

Resumen

¿Cómo aplicar el principio de abierto y cerrado en programación?

Adoptar el principio de abierto y cerrado es crucial para el desarrollo de software flexible y sostenible. Este principio se centra en crear sistemas que puedan ampliarse con nuevas funcionalidades sin alterar el código existente. Usar este enfoque contribuye a la estabilidad, promoviendo un desarrollo evolutivo y minimizando el riesgo de introducir errores al modificar un software existente.

¿Cuál es el desafío inicial?

El desafío consiste en extender una base de código existente que ya cuenta con clases para empleados a tiempo completo y de medio tiempo. La tarea es agregar un tipo de empleado contratado, respetando el principio de abierto y cerrado. Esto implica diseñar un sistema que permita la adición de nuevos tipos de empleados o contratos sin modificar las clases ya existentes.

¿Cómo identificar la reutilización de código?

Analizar el escenario es clave. Al observar las clases existentes, notamos que todas se relacionan con empleados y su tipo de contrato, compartiendo propiedades similares. Identificar estas similitudes nos permite crear componentes genéricos que facilitan la reutilización. Un enfoque propuesto es la creación de una clase abstracta Employee para establecer un estándar común.

¿Cómo estructurar las clases empleando la herencia?

Para optimizar nuestro sistema y alinear con el principio en cuestión, creamos una clase abstracta Employee. Establecemos atributos básicos como fullName y hoursWorked, y definimos un método abstracto para el cálculo del salario. Luego, distintas clases como FullTimeEmployee y PartTimeEmployee heredan de Employee, e implementan su lógica específica de cálculo de salario. Este método nos permite agregar nuevos tipos de empleados simplemente extendiendo Employee sin modificar el código original.

public abstract class Employee {
    public string FullName { get; set; }
    public int HoursWorked { get; set; }

    public abstract decimal CalculateSalary();
}

public class FullTimeEmployee : Employee {
    public override decimal CalculateSalary() {
        return HoursWorked * 20; // precio/hora ficticio para el cálculo
    }
}

¿Cómo integrar nuevas funcionalidades sin romper el código?

Con nuestra estructura basada en clases abstractas, incorporar un nuevo tipo de empleado es sencillo. Creamos una clase nueva, como ContractorEmployee, que hereda de Employee, provee las implementaciones necesarias para sus métodos diferenciales, y dejamos que el sistema existente maneje las instancias de maneras ya previstas.

public class ContractorEmployee : Employee {
    public override decimal CalculateSalary() {
        return HoursWorked * 25; // precio/hora diferente
    }
}

¿Qué aportan las buenas prácticas de programación?

La correcta implementación del principio de abierto y cerrado mejora notablemente la calidad del código. Evitamos modificar las clases existentes, lo que minimiza el riesgo de errores. Además, al usar una estructura bien definida, el sistema se mantiene organizado, promoviendo la responsabilidad única de cada clase. Este tipo de diseño es ejemplar de cómo aplicar técnicas sólidas para el crecimiento orgánico y sostenible de software. Estas prácticas no solo favorecen la extensión del código, sino también su comprensión y mantenimiento, aportando un valor duradero al proyecto.

Miguel Santiago Gómez Suárez

student•

Me pareció super interesante la implementación de clases abstractas e interfaces. Cabe aclarar que las interfaces se implementan muy similar entre lenguajes de programación. Para C#, la inteligencia artificial de notion me deja el siguiente ejemplo: Las clases abstractas y las interfaces son herramientas utilizadas en la programación orientada a objetos para facilitar la creación de componentes con comportamientos comunes.

Clases abstractas:

Una clase abstracta es una clase que no se puede instanciar, pero que se puede utilizar como plantilla para crear otras clases.
Las clases abstractas pueden contener métodos abstractos, que son métodos sin implementación. Estos métodos deben ser implementados en las clases que heredan de la clase abstracta.
Las clases abstractas pueden contener métodos con implementación, que las clases que heredan pueden usar directamente o sobrescribir si es necesario.

Un ejemplo de una clase abstracta en C#:

public abstract class Animal
{
    public abstract void MakeSound();

    public void Sleep()
    {
        Console.WriteLine("Zzzzz");
    }
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Woof!");
    }
}

public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Meow!");
    }
}

En este ejemplo, Animal es una clase abstracta que contiene un método abstracto MakeSound() y un método con implementación Sleep(). La clase Dog y la clase Cat heredan de Animal y proporcionan su propia implementación del método MakeSound().

Interfaces:

Una interfaz es una especificación de un conjunto de métodos que una clase debe implementar.
Las interfaces no tienen implementación, solo especifican la firma de los métodos que deben ser implementados por las clases que las implementan.
Las clases pueden implementar múltiples interfaces.

Un ejemplo de una interfaz en C#:

public interface IShape
{
    double Area();
    double Perimeter();
}

public class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public double Area()
    {
        return Width * Height;
    }

    public double Perimeter()
    {
        return 2 * (Width + Height);
    }
}

public class Circle : IShape
{
    public double Radius { get; set; }

    public double Area()
    {
        return Math.PI * Radius * Radius;
    }

    public double Perimeter()
    {
        return 2 * Math.PI * Radius;
    }
}

En este ejemplo, IShape es una interfaz que especifica dos métodos Area() y Perimeter(). La clase Rectangle y la clase Circle implementan IShape y proporcionan su propia implementación de los métodos Area() y Perimeter().

Cabe aclarar que, para resolver el reto por medio de interfaces, es necesario implementar todo lo que posee un interfaz, ya sean métodos o propiedades. Dejo un ejemplo de la implementación del EmpleadoTiempoCompleto:

 namespace OpenClose
{
    public class EmployeeFullTime : IEmployee
    {
        public string Fullname { get ; set ; }
        public int HoursWorked { get ; set ; }
        public EmployeeFullTime(string fullname, int hoursWorked)
        {
            Fullname = fullname;
            HoursWorked = hoursWorked;
        }

        

        public decimal CalculateSalaryMonthly()
        {
            decimal hourValue = 30000M;
            decimal salary = hourValue * HoursWorked;
            return salary;
        }
    }
}

Alfonso Navarro

company_admin•

Miguel Angel Reyes Moreno

Daniel Meza

Eduardo Luis Mexia Angulo

Andres Felipe Osorio Molina

José Ángel Soriano Soriano

Francisco Murillo

BALFRE VAZQUEZ CASTREJON

Luis G. Julio

JUAN SILVA

Franco David Perez

Miguel Teheran

teacher•

Leonardo Valdivieso

Sonsire Vidal B.

César Augusto Poveda Floréz

Santiago Rodriguez Palacio

ROMMEL DUAREZ SAENZ

Oseas Pozo

Jose Gabriel Zaragoza

Carlos Madrigal Ramos

Emilio Nicolás Mendoza Patti

Manuel Herrera

Jonathan Harley Sabogal toro

José Luis Hernández

Irwin Morales Cabrera

Aplicación del Principio de Abierto/Cerrado en Programación

Introducción

Principios SOLID en C# y .NET: Teoría y Práctica

Requisitos y Herramientas para Curso de Principios SOLID en C#

Prácticas de Código Limpio y Principios SOLID

Principios SOLID en Programación Orientada a Objetos

Principio de responsabilidad única

Principio de Responsabilidad Única en Programación Orientada a Objetos

Aplicación del Principio de Responsabilidad Única en C#

Principio de abierto/cerrado

Principio Abierto-Cerrado en C# para Extender Código sin Modificarlo