Patrón de constructor

El patrón constructor es un patrón de diseño que proporciona una solución flexible a varios problemas de creación de objetos en la programación orientada a objetos . El patrón constructor separa la construcción de un objeto complejo de su representación. Es uno de los 23 patrones de diseño clásicos descritos en el libro Design Patterns (a menudo denominado "Gang of Four" o simplemente "GoF") y se subcategoriza como un patrón de creación . ^[1]

El patrón de diseño del constructor resuelve problemas como: ^[2]

• ¿Cómo puede una clase (el mismo proceso de construcción) crear diferentes representaciones de un objeto complejo?
• ¿Cómo se puede simplificar una clase que incluye la creación de un objeto complejo?

La creación y el ensamblaje de las partes de un objeto complejo directamente dentro de una clase es inflexible. Obliga a la clase a crear una representación particular del objeto complejo y hace imposible cambiar la representación más adelante de manera independiente (sin tener que cambiar) la clase.

El patrón de diseño del constructor describe cómo resolver estos problemas:

• Encapsular la creación y el ensamblaje de las partes de un objeto complejo en un Builderobjeto separado.
• Una clase delega la creación de objetos a un Builderobjeto en lugar de crear los objetos directamente.

Una clase (el mismo proceso de construcción) puede delegar en diferentes Builderobjetos para crear diferentes representaciones de un objeto complejo.

La intención del patrón de diseño Builder es separar la construcción de un objeto complejo de su representación. De esta manera, el mismo proceso de construcción puede crear diferentes representaciones. ^[1]

Las ventajas del patrón constructor incluyen: ^[3]

• Permite variar la representación interna de un producto.
• Encapsula el código para su construcción y representación.
• Proporciona control sobre los pasos del proceso de construcción.

Las desventajas del patrón constructor incluyen: ^[3]

• Se debe crear un ConcreteBuilder distinto para cada tipo de producto.
• Las clases constructoras deben ser mutables.
• Puede obstaculizar/complicar la inyección de dependencia.
• En muchos lenguajes seguros para valores nulos , el patrón de construcción pospone los errores de tiempo de compilación para campos no configurados al tiempo de ejecución .

En el diagrama de clases UML anterior , la clase no crea ni ensambla los objetos y directamente. En cambio, la hace referencia a la interfaz para construir (crear y ensamblar) las partes de un objeto complejo, lo que hace que la independientemente de qué clases concretas se instancian (qué representación se crea). La clase implementa la interfaz creando y ensamblando los objetos y . El diagrama de secuencia UML muestra las interacciones en tiempo de ejecución: El objeto llama al objeto, que crea y ensambla el objeto. A continuación, la llama a , que crea y ensambla el objeto. DirectorProductA1ProductB1DirectorBuilderDirectorBuilder1BuilderProductA1ProductB1
DirectorbuildPartA()Builder1ProductA1DirectorbuildPartB()Builder1ProductB1

Constructor

Interfaz abstracta para la creación de objetos (producto).

Constructor de hormigón

Proporciona implementación para Builder. Es un objeto capaz de construir otros objetos . Construye y ensambla partes para construir los objetos.

Un ejemplo en C# :

/// <summary> 
/// Representa un producto creado por el constructor. 
/// </summary> 
public class Bicycle { public Bicycle ( string make , string model , string colour , int height ) { Make = make ; Model = model ; Colour = colour ; Height = height ; }  

            
    
          
          
          
          
    

    cadena pública Make { obtener ; establecer ; } cadena pública Model { obtener ; establecer ; } int público Height { obtener ; establecer ; } cadena pública Colour { obtener ; establecer ; } }      
          
          
          


/// <summary> 
/// La abstracción del constructor. 
/// </summary> 
public interface IBicycleBuilder { Bicycle GetResult ();  

     

    cadena Color { obtener ; establecer ; } int Altura { obtener ; establecer ; } }     
         


/// <summary> 
/// Implementación del constructor concreto. 
/// </summary> 
public class GTBuilder : IBicycleBuilder { public Bicycle GetResult () { return Height == 29 ? new Bicycle ( "GT" , "Avalanche" , Colour , Height ) : null ; }    

      
    
                   
    

    cadena pública Color { obtener ; establecer ; } int público Altura { obtener ; establecer ; } }      
          


/// <summary> 
/// El director. 
/// </summary> 
public class MountainBikeBuildDirector { private IBicycleBuilder _builder ;  

      

    público MountainBikeBuildDirector ( IBicycleBuilder constructor ) { _builder = constructor ; }  
    
          
    

    public void Construct ( ) { _builder.Color = " Rojo " ; _builder.Altura = 29 ; }​  
    
          
          
    

    Bicicleta pública GetResult () { devuelve este . _builder . GetResult (); } }  
	
		 
	


public class Client { public void DoSomethingWithBicycles () { var director = new MountainBikeBuildDirector ( new GTBuilder ()); // Director controla la creación paso a paso del producto y devuelve el resultado. director.Construct (); Bicicleta myMountainBike = director.GetResult ( ) ; } }  

      
    
             
        
        
           
    

En el ejemplo anterior, el Director ensambla una instancia de bicicleta y delega la construcción a un objeto constructor separado que el Cliente le ha entregado al Director.

• Zurra

• Gamma, Erich ; Helm, Richard ; Johnson, Ralph ; Vlissides, John (1994). Patrones de diseño: elementos de software orientado a objetos reutilizable . Addison-Wesley. ISBN 0-201-63361-2.