Refactorización mediante interfaces
En la lección anterior, ha aprendido sobre los desafíos del código estrechamente acoplado y cómo infringe el principio abierto y cerrado. Ahora, vamos a refactorizar el Library y BorrowableBook el ejemplo para que el sistema sea más flexible y fácil de mantener.
Este es el código original que muestra el problema:
public class BorrowableBook
{
public string Title { get; set; }
public bool IsAvailable { get; private set; } = true;
public BorrowableBook(string title)
{
Title = title;
}
public void Borrow()
{
if (IsAvailable)
{
IsAvailable = false;
Console.WriteLine($"You have borrowed \"{Title}\".");
}
else
{
Console.WriteLine($"\"{Title}\" is already borrowed.");
}
}
}
public class Library
{
private BorrowableBook _book;
public Library(BorrowableBook book)
{
_book = book;
}
public void BorrowBook()
{
if (_book.IsAvailable)
{
_book.Borrow();
}
else
{
Console.WriteLine("The book is not available.");
}
}
}
Este diseño acopla estrechamente la Library clase a la BorrowableBook clase, lo que dificulta agregar nuevos tipos de elementos prestados (por ejemplo, DVDs) sin modificar la Library clase. Para corregir el estrecho acoplamiento, introducimos una interfaz para desacoplar el comportamiento de préstamo.
Introducción a las interfaces
Una interfaz establece un contrato para el comportamiento sin detallar su implementación. La introducción de una interfaz abstrae la funcionalidad de préstamo y aumenta la flexibilidad del sistema.
Esta es la IBorrowable interfaz:
public interface IBorrowable
{
bool IsAvailable { get; }
void Borrow();
}
Esta interfaz presenta dos miembros:
-
IsAvailable: propiedad que indica si el elemento está disponible para el préstamo. -
Borrow: método para tomar prestado el elemento.
Al definir esta interfaz, desacoplamos el comportamiento de préstamo de cualquier implementación específica.
Refactorización de la clase BorrowableBook
A continuación, actualizamos la BorrowableBook clase para implementar la IBorrowable interfaz:
public class BorrowableBook : IBorrowable
{
public string Title { get; set; }
public bool IsAvailable { get; private set; } = true;
public BorrowableBook(string title)
{
Title = title;
}
public void Borrow()
{
if (IsAvailable)
{
IsAvailable = false;
Console.WriteLine($"You have borrowed \"{Title}\".");
}
else
{
Console.WriteLine($"\"{Title}\" is already borrowed.");
}
}
}
Ahora, la BorrowableBook clase se adhiere a la IBorrowable interfaz, por lo que es intercambiable con otras clases que implementan la misma interfaz.
Refactorización de la clase Library
También actualizamos la Library clase para que dependa de la IBorrowable interfaz en lugar de la clase concreta BorrowableBook :
public class Library
{
private IBorrowable _item;
public Library(IBorrowable item)
{
_item = item;
}
public void BorrowItem()
{
if (_item.IsAvailable)
{
_item.Borrow();
}
else
{
Console.WriteLine("The item is not available.");
}
}
}
Ahora, la Library clase puede trabajar con cualquier objeto que implemente la IBorrowable interfaz, lo que hace que sea más flexible y fácil de ampliar.
Uso de la inserción de dependencias
Imagine que está configurando un sistema de entretenimiento doméstico. En lugar de conectar permanentemente una marca específica de altavoces a su estéreo, se usan "conectores" de altavoz que pueden aceptar varios tipos de enchufes de altavoz compatibles. Este diseño le permite reemplazar o actualizar fácilmente los altavoces sin tener que cambiar todo el sistema estéreo.
En el software, la inserción de dependencias funciona de forma similar. Permite que una clase dependa de una interfaz abstracta en lugar de una implementación específica. La inserción de dependencias hace que el sistema sea más flexible y fácil de mantener porque puede "conectar" diferentes implementaciones sin modificar la propia clase.
El constructor en programación es como el técnico que conecta los conectores del altavoz durante la instalación del sistema estéreo. Para la Library clase , el constructor (public Library(IBorrowable item)) es donde se proporciona la dependencia. El constructor permite que la Library clase funcione con cualquier implementación compatible, como BorrowableBook o BorrowableDVD, sin necesidad de cambiar su estructura interna. Al igual que el conector del altavoz permite la flexibilidad de elegir diferentes altavoces, el constructor facilita la flexibilidad en el uso de varios elementos prestados.
Así es como funciona en el código:
public class Library
{
private IBorrowable _item;
public Library(IBorrowable item) // Dependency is injected here
{
_item = item;
}
public void BorrowItem()
{
if (_item.IsAvailable)
{
_item.Borrow();
}
else
{
Console.WriteLine("The item is not available.");
}
}
}
En este ejemplo:
- El constructor es donde se realiza la "conexión" (la dependencia
IBorrowable), similar a cómo se enchufa el altavoz al "conector". - La
IBorrowableinterfaz actúa como el "jack estéreo", definiendo el punto de conexión estándar. -
BorrowableBookyBorrowableDVDson como diferentes tipos de altavoces estéreo con conectores únicos que se conectan al "enchufe".
Mediante la inserción de dependencias, la Library clase puede trabajar con cualquier implementación de IBorrowable. Este enfoque proporciona:
-
Flexibilidad: puede cambiar o agregar implementaciones nuevas fácilmente sin modificar la
Libraryclase. - Capacidad de prueba: puede "conectar" implementaciones ficticias con fines de prueba.
-
Mantenimiento: la
Libraryclase no necesita conocer los detalles de la implementación específica, lo que facilita la extensión y el mantenimiento.
Este diseño garantiza que la Library clase ya no esté estrechamente acoplada a implementaciones específicas, lo que hace que el sistema sea más modular y adaptable.
Agregar nuevos elementos prestables
Con la interfaz en su lugar, podemos agregar fácilmente nuevos tipos de elementos prestables sin modificar la clase Library. Por ejemplo, esta es una BorrowableDVD clase:
public class BorrowableDVD : IBorrowable
{
public string Title { get; set; }
public bool IsAvailable { get; private set; } = true;
public BorrowableDVD(string title)
{
Title = title;
}
public void Borrow()
{
if (IsAvailable)
{
IsAvailable = false;
Console.WriteLine($"You have borrowed the DVD \"{Title}\".");
}
else
{
Console.WriteLine($"The DVD \"{Title}\" is already borrowed.");
}
}
}
La BorrowableDVD clase implementa la misma IBorrowable interfaz, por lo que se puede usar sin problemas con la Library clase .
Probar el sistema
Este es un programa para demostrar el sistema refactorizado:
using System;
class Program
{
static void Main()
{
// Create borrowable items
IBorrowable book = new BorrowableBook("Adventure Works Cycles");
IBorrowable dvd = new BorrowableDVD("Graphic Design Institute");
// Create libraries
Library bookLibrary = new Library(book);
Library dvdLibrary = new Library(dvd);
// Borrow items
bookLibrary.BorrowItem();
bookLibrary.BorrowItem(); // Try borrowing again
Console.WriteLine();
dvdLibrary.BorrowItem();
dvdLibrary.BorrowItem(); // Try borrowing again
}
}
La salida muestra la flexibilidad del sistema refactorizado:
You have borrowed "Adventure Works Cycles".
"Adventure Works Cycles" is already borrowed.
You have borrowed the DVD "Graphic Design Institute".
The DVD "Graphic Design Institute" is already borrowed.
En este ejemplo refactorizado se muestra cómo las interfaces reducen las dependencias y mejoran la modularidad:
-
Separación de intereses: La interfaz
IBorrowableaísla el comportamiento de los préstamos, lo que garantiza que la claseLibraryno depende de implementaciones específicas. -
Flexibilidad mejorada: puede agregar nuevos tipos de elementos prestados (por ejemplo, DVDs) sin modificar la
Libraryclase. - Mantenimiento simplificado: el sistema es más fácil de entender, probar y ampliar porque las responsabilidades están claramente divididas.