Los patrones estructurales se enfocan en como las clases y objetos se componen para formar estructuras mayores, los patrones estructurales describen como las estructuras compuestas por clases crecen para crear nuevas funcionalidades de manera de agregar a la estructura flexibilidad y que la misma pueda cambiar en tiempo de ejecución lo cual es imposible con una composición de clases estáticas.

A continuación un repaso rápido por lo que son los patrones estructurales mas utilizados:


Adapter

Definición
Convierte la interfaz de una clase en otra que espera un cliente.

Participantes

Target :

Define la clase que es esperada por el cliente.

Adapter:

Adapta la una clase a otra esperada por el cliente.

Adaptee:

Define la clase que necesita ser adapatada.

Client :

Consume un servicio del target.
Este patrón es comúnmente usado en los casos en los que queremos utilizar una clase cuya interfaz no coincide con nuestras necesidades, como vemos en el diagrama la idea es simple la clase Adapter si cumple con nuestros requerimiento ya que implementa una interfaz en este caso la interfaz Adaptee que si podemos entender, al mismo tiempo podremos utilizar la clase Target debido a que la clase Adapter hereda de la misma.

Una consecuencia que podríamos enfrentar con la implementación de este patrón es que como vemos la clase Adapter podría sobrescribir el comportamiento de la clase Target.

———————————————————————————————

Bridge
Desacopla una clase abstracta de su implementación final de manera de que ambas puedan ser independientes.

Participantes

Abstraction

Define una interfaz abstracta y mantiene una referencia a un objeto del tipo Implementor

RefinedAbstraction

Extiende de la interfaz definida por la clase Abstraction.

Implementor

Define una interfaz para la clase que realiza la implementación, la mima no tiene una correspondencia exacta con la interfaz Abtraction, de hecho ambas interfaces pueden ser complentamente diferente, normalmente la interfaz implementación  provee solo operadores básicos y la clase Abstraction define un nivel mas alto de operaciones basadas en las básicas.

ConcreteImplementor

Implementa la interfaz Implementor y define un implementación en concreto.
Este patrón nos será muy útil cuando queramos cambiar el comportamiento de un objeto en tiempo de ejecución al poder cambiar  entre ConcreteImplementors diferentes de la siguiente manera por ejemplo:

Abstraction ab = new RefinedAbstraction();

// Set implementation and call

ab.Implementor = new ConcreteImplementorA();

ab.Operation();

// Change implemention and call

ab.Implementor = new ConcreteImplementorB();

ab.Operation();

———————————————————————————————

Composite

Definición
Construye objetos dentro de una estructura de árbol,  de esta manera los objetos que componen el árbol pueden tratarse de manera individual o o como una composición de objetos.

Participantes

Component:

Declara una interfaz que implementa los objetos en el árbol, define el comportamiento por defecto de los objetos en el árbol y la manera en la que se acceden y se administran los hijos de la composición.

Leaf:

Representa una rama de objetos dentro del árbol o composición, una Leaf no tiene hijos y define el comportamiento de objetos primitivos en la composición.

Composite: define el comportamiento para los hijos que posee y almacena los mismos.

Client:

Manipula los objetos de la composición a través de la interfaz de los componentes
Este patrón permite que un cliente pueda interactuar con los objetos que componen toda una estructura.

Como podemos ver en este patrón los objetos pueden estar compuesto por objetos mas complejos que a su vez pueden ser también objetos compuesto y así sucesivamente, sin embargo un cliente podría manejar una estructura compuesta o una simple de manera uniforme y sin necesidad de saber si están tratando con objetos compuestos o no.

———————————————————————————————

Decorator

Definición
Agrega responsabilidades adicionales a un objeto de manera dinámica.

Participantes

Component:

Define una interfaz para los objetos que pueden recibir responsabilidades de manera dinamica.

ConcreteComponent:

Define un objeto cuya responsabilidad adicional puede ser agregada a otros objetos dinamicamente.

Decorator:

Mantiene una referencia al objeto Component y define una interfaz que conforma la interfaz de Component.

ConcreteDecorator:

Agrega una nueva responsabilidad al componente.
La idea en este caso es poder añadir funcionalidades a una subclase sin tener que hacerlo a todo un conjunto de subclases, de esta manera la clase Decorator permite que añadamos comportamiento a la clase Component haciendo uso de la interfaz del mismo y exponiéndola de manera que sea transparente para el cliente que lo consuma.

De esta manera el patrón Decorator permite añadir responsabilidades a otros objetos de una manera bastante flexible, evitándonos tener que construir una clase por cada nueva responsabilidad o funcionalidad que queramos implementar.

Ejemplo de como extendemos del comportamiento en el concreteDecorator.

/// <summary>

/// The ‘ConcreteDecoratorB’ class

/// </summary>

class ConcreteDecoratorB : Decorator

{

public override void Operation()

{

base.Operation();

AddedBehavior();

Console.WriteLine(“ConcreteDecoratorB.Operation()”);

}

void AddedBehavior()

{

}

}

———————————————————————————————

Facade

Definición

Provee una interfaz unificada para un grupo de interfaces en un subsistema, de manera que esta funcione como una interfaz de alto nivel que hace al resto de las interfaces fácil de usar.

Participantes

Facade

– Sabe que sub sistema es responsable de una petición en concreto

– delega las peticiones de los clientes a la interfaz del sub sistema apropiada

Subsystem classes

-Implementa las funcionalidades del sub sistema

– Manejan el trabajo asignado por la clase Facade

La idea principal de este patrón es poder dividir un sistema en múltiples sub sistemas para reducir la complejidad del mismo y al mismo tiempo reducir  la comunicación y la dependencia entre sub sistemas.

El patrón Facade nos ofrece una clase que nos da acceso a un sistema mas complejo y a sus subsistemas, esto hace a su ves a dichos sub sistemas mas reutilizables y cusmotizables, por otra parte hace que para un cliente sea mas fácil de usar al reducir el número de componentes con los que hay que lidiar.

Además al reducir el número de dependencia entre componentes también se reduce los tiempos de compilación.

/// MainApp startup class for Structural

/// Facade Design Pattern.

/// </summary>

class MainApp

{

/// <summary>

/// Entry point into console application.

/// </summary>

public static void Main()

{

Facade facade = new Facade();

facade.MethodA();

facade.MethodB();

facade.MethodC();

// Wait for user

Console.ReadKey();

}

}

———————————————————————————————

Proxy

Definición
Provee un sustituto a otro objeto para controlar el accedo al mismo.

Participantes

Proxy:

Mantiene una referencia que permite al proxy acceder al objeto real, provee una interfaz idéntica al objeto real de manera que este puede actuar como un sustituto, muchas veces el proxy se utiliza no solo para controlar el acceso sino también para dar formato a la petición.

Subject :

Define la interfaz común que implementara el obejor real y el proxy

RealSubject:

Define el objeto real que el proxy representa.
Comúnmente este patrón es muy utilizado cuando queremos controlar el acceso a un componente de esta forma no tenemos que crear objetos costoso que luego no serán utilizados, este generalmente ocurre cuando un objeto tiene diferentes niveles de permisos .

La clase proxy en ocasiones también es usada para realizar el encoding de un mensaje enviando lo luego al RealSubject.

La clase proxy tendría una estructura parecida a la siguiente:

/// <summary>

/// The ‘Proxy’ class

/// </summary>

class Proxy : Subject

{

private RealSubject _realSubject;

public override void Request()

{

// Use ‘lazy initialization’

if (_realSubject == null)

{

_realSubject = new RealSubject();

}

_realSubject.Request();

}

}

Desde este enlace se pueden descargar el diagrama de clases de los patrones, esta vez realizado en el Microsoft Vision 2007