patrón de diseño Factory Method

Una factoría es un objeto que maneja la creación de otros objetos. Las factorías se utilizan cuando la creación de un objeto implica algo más que una simple instanciación.
Los siguientes ejemplos son casos donde una factoría puede ayudar:

• Es necesario acceder a algún recurso para la creación y configuración de un objeto.
• No conocemos hasta el momento preciso de la instanciación qué tipo concreto de objeto se va a instanciar.

En estos casos, en lugar de que sea el propio objeto quien se encargue de todos los aspectos realativos a la creación, se crea otro objeto que lo haga. De esta manera, se libera al objeto que va a ser creado de aquellas responsabilidades que no le corresponden pero que son necesarias para su creación, manteniendo su independencia.

El siguiente es un ejemplo de la utilización de una factoría para la creación de objetos. Se pueden crear figuras geométricas y calcular su área. Las figuras estarían definidas por una interfaz. Las figuras posibles son círculos y cuadrados.

Se va a utilizar una factoría para crear las figuras, puesto que no conocemos de antemano a qué clase pertenece el objetoque tenemos que instanciar. El uso de una factoría permite separar la lógica de negocio, igual para todos los casos, de la lógica de instanciación de los objetos. De este forma el código queda más claro.

public interface Figura {
 public double getArea();
}

public class Circulo implements Figura {
 double radio;
 
 public Circulo(double radio) {
  this.radio = radio;
 }
 
 public double getArea() {
  return (3.14 * radio * radio);
 }
}

public class Cuadrado implements Figura {
 double lado;
 
 public Cuadrado(double lado) {
  this.lado = lado;
 }
 
 public double getArea() {
  return lado * lado;
 }
}

public class Principal {
 public static void main(String[] args) {
  int tipo = Integer.parseInt(args[0]);
  double lado = Double.parseDouble(args[0]);  
 
  Figura figura = 
   FiguraFactory.getFigura(tipo, lado);

  System.out.println("El area de la figura es: " + figura.getArea());
 }
}

public class FiguraFactory {
 public final static int CUADRADO = 0;
 public final static int CIRCULO = 1;
 
 public static Figura getFigura(int tipo, double lado) {
  switch (tipo) {
   case CUADRADO:
    return new Cuadrado(lado);
   case CIRCULO:
    return new Circulo(lado);
  }  
  return null;
 }
}

• Factory Method (Medido Factoría):

– Básicamente se crea una interfaz que es la que referencia los nuevos objetos que se van a crear, luego se generan las respectivas subclases que son las encargadas de crear los objetos y que van a ser llamadas por la clase principal.
He aquí el ejemplo:

using System;

namespace Method_Factory
{
    public enum tipoEmpleado
    {
        operario,
        coordinador
    }

    //Consumiendo los Factory
    class MethodFactory
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Salario : " + FactorySalarios.getSalario(tipoEmpleado.operario, 55).ToString());
            Console.ReadLine();
        }
    }

    // Esta es la clase Base
    public abstract class Persona
    {
        public virtual double CalcularSalario(int horasLaboradas)
        {
            return 0;
        }

    }

    // Aqui van las clases derivadas
    public class operario : Persona
    {
        public override double CalcularSalario(int horasLaboradas)
        {
            return 1000 * horasLaboradas;
        }
    }

    public class coordinador : Persona
    {
        public override double CalcularSalario(int horasLaboradas)
        {
            return 2000 * horasLaboradas;
        }
    }

    // Aqui va la clase Factory por fin!!
    public static class FactorySalarios
    {
        public static Nullable<double> getSalario(tipoEmpleado Empleado, int HorasLaboradas)
        {
            if (Empleado == tipoEmpleado.operario)
            {
                return new operario().CalcularSalario(HorasLaboradas);
            }
            else if (Empleado == tipoEmpleado.coordinador)
            {
                return new coordinador().CalcularSalario(HorasLaboradas);
            }
            else
            {
                return null;
            }
        }
    }
}

El ejemplo anterior se corresponde con el patrón de diseño Factory Method, que se refiere a la utiliación de un método cuyo propósito principal es la creación de objetos.


Fuente:
http://tratandodeentenderlo.blogspot.com/2010/02/patrones-de-diseno-factorias.html
https://lalejogg.wordpress.com/2011/06/24/arquitectura-%E2%80%93-patrones-%E2%80%93-factory-factoria-o-fabrica-%E2%80%93-codigo-c/

Extras:
https://msdn.microsoft.com/es-es/library/bb972258.aspx#M12
http://es.slideshare.net/jonathancalero/mtodo-fabrica-method-factory-10275431
http://www.dofactory.com/net/factory-method-design-pattern --Completo
https://sourcemaking.com/design_patterns/factory_method/c-sharp-dot-net
https://www.youtube.com/watch?v=HNJVdj361KY --Completo