Patrón de diseño Refactory

Este patrón plantea la separación del problema en tres capas: la capa model, que representa la realidad; la capacontroler , que conoce los métodos y atributos del modelo, recibe y realiza lo que el usuario quiere hacer; y la capavista, que muestra un aspecto del modelo y es utilizada por la capa anterior para interaccionar con el usuario.

Los objetos de re fabricación (fábricas) tienen la responsabilidad de crear instancias de objetos de otras clases. Tienen además la responsabilidad y el conocimiento necesario para encapsular la forma en que se crean determinados tipos de objetos en una aplicación.

El término factory (o fábrica) adolece de ser sobreutilizado e impreciso. Mucha gente se refiere a factory para indicar una implementación de Factory Method o de Abstract Factory (patrones definidos en el libro del GoF). Otros sin embargo, se refieren a un objeto que crea instancias de otros, aunque no sigue las reglas de los patrones mencionados anteriormente.

Ejemplos de Patrón de diseño Refactory

Ejemplo 1 - la clase base crea instancias de objetos de tipo Perro y la subclase, en cambio, crea instancias de Gato (redefiniendo la implementación del método de creación del tipo base):

/// <summary> /// Creador. Esta es la clase base del Factory Method. /// Provee una implementación default del método de creación, /// que puede ser redefinida por los métodos hijos /// </summary> public class Creador {    /// <summary>    /// Metodo de creación    /// </summary>    /// <returns>Instancia de una mascota</returns>    public virtual Mascota Crear()    {       return new Perro();    } } /// <summary> /// Creador Concreto. Redefine el método de creación /// definido en Creador, cambiando el "ProductoConcreto" /// que se retorna /// </summary> public class CreadorConcreto: Creador {    /// <summary>    /// Metodo de creación    /// </summary>    /// <returns>Instancia de una mascota</returns>    public override Mascota Crear()    {       return new Gato();    } }

Ejemplo 2 - Cómo puede crearse un cuidador que sepa tratar con perros:

/// <summary> /// Esta es la clase que implementa Template Method /// y Factory Method. En el caso de Factory Method, /// hemos implementado la opción donde el creador /// es una clase abstracta /// </summary> public abstract class Cuidador {    /// <summary>    /// Este es el template method. Este método es    /// el que tiene la lógica y no se redefine en    /// las clases hijas    /// </summary>    public void Cuidar()    {       /// obtenemos una instancia de una mascota       Mascota mascota = this.CrearMascota();       /// alimentamos a la mascota       mascota.Alimentar();       /// si la mascota tiene mas de 2 patas, la llevamos a pasear       if (mascota.CantidadPatas > 1)          mascota.Pasear();    }    /// <summary>    /// Este es el método de creación (para el Factory Method)    /// y la Operación Primitiva que debe ser    /// redefinida por el usuario (para el Template Method)    /// </summary>    /// <returns>Instancia de Mascota</returns>    public abstract Mascota CrearMascota(); } /// <summary> /// Creador Concreto. Solo redefine la operación de creación, pero hereda /// el comportamiento fijo de CreadorTemplateMethod /// </summary> public class CuidadorDePerro: CreadorTemplateMethod {    /// <summary>    /// Método de creación, redefinido de la clase base    /// </summary>    /// <returns>Instancia de Mascota</returns>    public override Mascota CrearMascota()    {       return new Perro();    } }

Compartir en Google Plus