Este patrón se utiliza cuando debemos generar distintas familias de objetos , dejando esto a la interface de la factory y sacándole dicha responsabilidad al cliente.
El cliente tan solo de dedica a crear un determinado tipo de objeto , mientras que la abstract factory se dedica a implementar y especificar a que familia pertenece el mismo .De esta forma podemos generar objetos del mismo tipo , pero generados desde distintas clases .O se tienen distintas implementaciones y estas son manejadas por
El siguiente ejemplo , consta de una clase Abstract Factory que nos permite generar Empleados y Clientes .En base a esta clase generamos las Factory de Personas según
Codigo Clase Factory :
namespace AbstractFactoryPatternLibrary
{
public abstract class PersonaFactory
{
// Nos aseguramos de que todas las clases Factory van
// a generar objetos del tipo Empleado y Cliente
public abstract Empleado BuildEmpleado();
public abstract Cliente BuildCliente();
}
// Implementamos Abstract Factory
// Mediante PersonaFactory sabemos los
// objetos que debe generar la clase.
// En este caso es una factory que lo implementa
// segun los requerimientos de Empresa1
public class Empresa1PersonaFactory:PersonaFactory
{
// Implementamos los contructores que devuelven
// los objetos establecidos en la Abstract Factory
// En este caso se generan para el empleado tipo
// EmpleadoEmpresa1
public override Empleado BuildEmpleado()
{
Empleado emp = new EmpleadoEmpresa1();
return emp;
}
public override Cliente BuildCliente()
{
Cliente cli = new ClienteEmpresa1();
return cli;
}
}
// Cumple el mismo proposito que Empresa2PersonaFactory.
// Aca podemos ver como este pattern nos permite realizar
// una implementacion distinta del primer Factory , generando
// los mismos tipos de clases hacia el cliente , pero creandolo
// desde otras clases.
public class Empresa2PersonaFactory : PersonaFactory
{
public override Empleado BuildEmpleado()
{
Empleado emp = new EmpleadoEmpresa2();
return emp;
}
public override Cliente BuildCliente()
{
Cliente cli = new ClienteEmpresa2();
return cli;
}
}
public class ClienteEmpresa1:Cliente
{
public override void VerificarCuenta()
{
Console.WriteLine("Verificando Cuenta cliente Empresa1");
}
}
public class EmpleadoEmpresa1:Empleado
{
public override void CalcularSueldo()
{
Console.WriteLine("Calculando Sueldo empleado Empresa1");
}
}
public class ClienteEmpresa2:Cliente
{
public override void VerificarCuenta()
{
Console.WriteLine("Verificando Cuenta cliente Empresa2");
}
}
public class EmpleadoEmpresa2:Empleado
{
public override void CalcularSueldo()
{
Console.WriteLine("Calculando Sueldo empleado Empresa2");
}
}
// Clases abstract , van a ser las clases base
// Desde donde van a heredar los Clientes y
// Empleados de TODAS las Empresas.
// De esta forma cada Empresa va a definir el
// campo segun sus reglas de negocio.
public abstract class Empleado
{
// Las clases van a tener que implementar este metodo
public abstract void CalcularSueldo();
}
public abstract class Cliente
{
public abstract void VerificarCuenta();
}
}
Codigo Aplicacion de Consola que consume nuestro Factory :
class Program
{
static void Main(string[] args)
{
// Generamos Factory de Personas para Empresa1
// mediante este objeto vamos a poder generar Clientes y Empleados
// con la estructura que implementa la Empresa1
PersonaFactory personaFactoryEmpresa1 = new Empresa1PersonaFactory();
// Utilizamos la Factory para generar Clientes y Empleados
Cliente clienteEmpresa1 = personaFactoryEmpresa1.BuildCliente();
Empleado empleadoEmpresa1 = personaFactoryEmpresa1.BuildEmpleado();
empleadoEmpresa1.CalcularSueldo();
// Factory para CLientes y Empleados del tipo Empresa2
PersonaFactory personaFactoryEmpresa2 = new Empresa2PersonaFactory();
//Generamos Clientes y Empleados para Empresa2
Cliente clienteEmpresa2 = personaFactoryEmpresa2.BuildCliente();
Empleado empleadoEmpresa2 = personaFactoryEmpresa2.BuildEmpleado();
clienteEmpresa2.VerificarCuenta();
empleadoEmpresa2.CalcularSueldo();
// Otro ejemplo
// En la clase Gestor tenemos un metodo que no espera un Cliente
// ni un Empleado.El mismo se encarga de Generarlos , tan solo nesesita
// un objeto Factory.
// Por lo que este Metodo queda abierto a que se le pueda pasar cualquier
// Factory sin importar la Empresa
Gestor miGestor = new Gestor();
miGestor.GenerarCliente(personaFactoryEmpresa1);
Console.ReadLine();
}
}
class Gestor
{
public void GenerarCliente(PersonaFactory persona)
{
Cliente cliente = persona.BuildCliente();
Console.WriteLine("Cliente Generado desde el Gestor");
}
}
No hay comentarios:
Publicar un comentario