Deconstructing Design Patterns (DPs)

 

With this note, I start a little chat about DPs in a simple, down-to-earth manner.

I really don’t have any particular plan, so we will chat about DPs for as long as it is fun.

 

We should not make a lot of fuss about DPs, since we use many of them in C# on a daily basis without even thinking.

For instance, indexers are an implementation of the Iterator DP, events are an implementation of the Observer DP, RCW (Runtime Callable Wrappers), which are the heart of InterOp Assemblies, are an implementation of the Adapter (or Wrapper) DP, and serialization of objects is strongly based on the Memento DP, even though is not a complete implementation of Memento.

A very interesting example of DP spreads along ADO.NET, where the groups of classes that start at SqlConnection, OleDbConnection, OdbcConnection and OracleConnection are implementations of the Bridge DP.

It shouldn’t surprise anyone that .NET is full of DPs (yes!, .NET is “loaded” with DPs). After all, DPs are “general design solutions capable of being customized to solve a general design problem in a particular context” (this is an almost literal quote from the GoF book, page 3).

Just to keep in line with the “deconstructing” concept, it would be neat to use a very simple DP to show how easy DPs are: a case of the Singleton DP (page 127, GoF book).

 

The next lines are quoted from the GoF book, just to illustrate how to use DPs in our daily work.

Intent

Ensure a class only has one instance, and provide a global point of access to it.

 

Motivation

It’s important for some classes to have exactly one instance…There should be one file system and one window manager…

Consequences

The Singleton pattern has several benefits:

  1. Controlled access to sole instance. Because the Singleton class encapsulates its sole instance, it can have strict control over how and when clients access it.

 

Let’s have some sample implementation of the Singleton DP (see code sample 1 below)

 

The sample implementation uses the methods GetHashCode and Equals as ways to verify that we are dealing with the very same instance: that is, instance variables one and two are mere references to the same, sole instance.
Singleton is the simplest of DPs, because DPs are expressed as collaborations, which happen to be societies of classes, and the Singleton collaboration is a society of just one (rather simple) class.

 

Spanish version

 

Deconstruyendo los Patrones de Diseño (DPs)

 

Con esta nota, inicio una pequeña charla sobre DPs en una forma simple y práctica.

No tengo un plan en particular, por lo que charlaremos sobre DPs en tanto y en cuanto resulte divertido hacerlo.

No deberíamos hacer mucho alboroto con los DPs, dado que usamos muchos de ellos en C# en forma diaria sin si quiera pensarlo.

Por ejemplo, los indexers son una implementación del DP Iterator, los eventos son una implementación del DP Observer, RCW (Runtime Callable Wrappers), que son la base fundamental de los InterOp Assemblies, son una implementación del DP Adapter (o Wrapper), y la serialización de objetos en .NET está fuertemente basada en el DP Memento, si bien no es una implementación completa de Memento.

 

Un ejemplo muy interesante de DP se despliega a lo largo de ADO.NET, donde los grupos de clases que parten de SqlConnection, OleDbConnection, OdbcConnection y OracleConnection son implementaciones del DP Bridge.

 

No debería sorprender a nadie que .NET está lleno de DPs (asi es, .NET está "cargado" de DPs). Despues de todo, DPs son "soluciones generales de diseño capaces de ser personalizadas para resolver un problema general de diseño en un contexto particular" (traducción muy libre mía de una cita del libro GoF, página 3).

 

De tal forma de mantenernos en línea con el concepto "deconstructivo" de esta entrada, sería genial usar un ejemplo muy simple de DP para demostrar que facil resultan los DPs: un caso del DP Singleton (página 127, libro GoF).

 

Las próximas líneas son citas extraídas del libro GoF, a fin de ilustrar el uso de los DPs en nuestro trabajo diario.

 

Intención

Asegurar que una clase dada posee una sola instancia, y proveer un punto global de acceso a la misma.

 

Motivación

Es importante para ciertas clases tener exactamente una única instancia…Debería haber un solo y único file system y un único window manager…

 

Consecuencias

El DP Singleton ofrece varios beneficios:

  1. Acceso controlado a una sola y única instancia. Dado que la clase Singleton encapsula su única instancia, ella tiene estricto control de acceso sobre como y  cuando acceden los clientes a dicha instancia.

Veamos una implementación de ejemplo del DP Singleton (ver ejemplo en code sample 1 mas abajo)

 

La implementación de ejemplo usa los metodos GetHashCode y Equals como formas de verificar que estamos en presencia de la misma instancia: esto es, las variables de instancia one and two contienen solamente meras referencias a la misma y única instancia.

Singleton es el mas simple de los DP, ya que los DPs se expresan a través de colaboraciones, las cuales resultan ser sociedades de clases, y la colaboración Singleton es una sociedad de una sola (y bastante simple) clase.

 

Code Sample 1

 

using System;

namespace Singleton
{
 public class Singleton
 {
  private static Singleton _instance;
  
  // constructor must be private to restrict use of "new"
  // from outside the class.
  //
  // el constructor debe ser private para restringir el uso
  // de "new" desde fuera de la misma clase.
  
  private Singleton(){}
  
  // this works like a Factory Method.
  //
  // este metodo trabaja como Factory Method

  public static Singleton Instance()
  {
  
   if ( _instance == null )
     _instance = new Singleton();
    
  
   return _instance;    
  
  }
  
  
  
 }
 class MySingletonClass
 {
  public static void Main(string[] args)
  {
   Singleton one;
   Singleton two;
   
   one = Singleton.Instance();
   
   two = Singleton.Instance();
   
   Console.WriteLine("one HashCode: {0}", one.GetHashCode().ToString());
   Console.WriteLine("two HashCode: {0}", two.GetHashCode().ToString());

   Console.WriteLine("one equals two : {0}", one.Equals(two).ToString());
   
   
  }
 }
}

 

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s