Está en la página 1de 43

Programacin III

Monografa 2
Tema: Patrones de diseo
Autores:
Andrade Juan
Antamba Jose
Cuichan Cristhian

Contenido
Contenido.............................................................................................................. 2
Tabla de Ilustraciones................................................................................................... 4
MARCO TERICO.................................................................................................... 5
Patrones de Diseo................................................................................................... 5
Introduccin a Patrones de Diseo................................................................................5
Conceptos Generales................................................................................................. 5
Importancia de los patrones de diseo............................................................................5
Tipos de patrones..................................................................................................... 5
1.

Patrones de creacin........................................................................................ 5

a.

Singleton...................................................................................................... 5

b.

Abstract Factory............................................................................................. 6

2.

Patrones de estructura...................................................................................... 7

a.

Facade......................................................................................................... 7

b.

Proxy.......................................................................................................... 8

3.

Patrones de comportamiento............................................................................10

a.

Observer.................................................................................................... 10

b.

Strategy..................................................................................................... 11

DISEO E IMPLEMENTACIN.................................................................................13
Patrones de creacin........................................................................................ 13
a) SINGLETON........................................................................................... 13
Diagrama UML............................................................................................ 13
Cdigo del Programa.................................................................................13
Capturas de pantalla.................................................................................19
b) ABSTRACT FACTORY............................................................................20
Diagrama UML............................................................................................ 20
2) Patrones de estructura...............................................................................24
a) FACADE.................................................................................................. 24
Capturas de Pantalla.................................................................................27
b) PROXY.................................................................................................... 28
Diagrama UML............................................................................................ 28
Cdigo del programa.................................................................................28
Capturas de Pantalla.................................................................................30
3) Patrones de comportamiento.....................................................................32

a) OBSERVER............................................................................................. 32
Diagrama UML............................................................................................ 32
Cdigo del Programa.................................................................................32
Capturas de Pantalla.................................................................................32
b) STRATEGY.............................................................................................. 32
Diagrama UML............................................................................................ 32
Cdigo del Programa.................................................................................32
Capturas de Pantalla.................................................................................32
ANLISIS DE RESULTADOS..................................................................................... 33
CONCLUSIONES Y RECOMENDACIONES..................................................................34
Conclusiones........................................................................................................ 34
Recomendaciones.................................................................................................. 34
BIBLIOGRAFA...................................................................................................... 35

Tabla de Ilustraciones
Ilustracin 1 Utilizacin del patrn Singleton.....................................................................6
Ilustracin 2 Implementacin patrn Abstract Factory...........................................................7
Ilustracin 3 Implementacin patrn Observer..................................................................11
Ilustracin 4 Implementacin patrn Strategy.....................................................12
Ilustracin 5 Diagrama UML Vehculo Singleton...................................................13
Ilustracin 6 Ingreso de datos.............................................................................. 19
Ilustracin 7 Despliegue datos usuario................................................................19
Ilustracin 8 Diagrama UML Fabrica de vehculos Abstract Factory.....................20
Ilustracin 9 Funcionamiento programa Vehculos Abstract Factory....................24
Ilustracin 10 UML programa Calculadora...........................................................24
Ilustracin 11 Interface Programa Calculadora: ingreso de datos.......................27
Ilustracin 12 Programa Calculadora: ingreso operacin.....................................27
Ilustracin 13 Programa Calculadora Salida de Resultados.................................27
Ilustracin 14 UML Programa PROXY Respaldo On-Line.......................................28
Ilustracin 15 Programa Respaldo On-Line Mensaje Inicial..................................30
Ilustracin 16 Programa Respaldo On-Line Menu.................................................31
Ilustracin 17 Programa Respaldo On-Line Ingreso de datos...............................31
Ilustracin 18 Programa Respaldo On-Line Conexin...........................................31
Ilustracin 19 Programa Respaldo On-Line Ingreso con resplado........................32
Ilustracin 20 Programa Respaldo On-Line Desconexin.....................................32

MARCO TERICO
Patrones de Diseo
Los patrones de diseo son soluciones para problemas tpicos y recurrentes que nos podemos
encontrar a la hora de desarrollar una aplicacin.
Aunque nuestra aplicacin sea nica, tendr partes comunes con otras aplicaciones: acceso a
datos, creacin de objetos, operaciones entre sistemas etc. En lugar de reinventar la rueda,
podemos solucionar problemas utilizando algn patrn, ya que son soluciones probadas y
documentadas
por
multitud
de
programadores.
Introduccin a Patrones de Diseo
Los patrones de diseo son una solucin a los problemas de diseo. Para que un patrn sea
considerado un patrn de diseo debe cumplir con ciertas caractersticas como la efectividad
resolviendo problemas similares, otra que debe ser reutilizable ya que puede ser usado en
diferentes problemas de diseo.
Conceptos Generales
Los patrones de diseo tienen como objetivo proporcionar catlogos de elementos reusables
en el diseo de sistemas software, evitando la reiteracin en la bsqueda de soluciones a
problemas ya conocidos y solucionados anteriormente.
Importancia de los patrones de diseo
Los patrones de diseo nos ayudan a cumplir muchos de estos principios o reglas de diseo.
Programacin SOLID, control de cohesin y acoplamiento o reutilizacin de cdigo son
algunos de los beneficios que podemos conseguir al utilizar patrones.
Tipos de patrones
1. Patrones de creacin
Los patrones de diseo software de creacin proporcionan ayuda a la hora de crear
objetos desde el punto de vista de proporcionar un apoyo en la toma de decisiones,
incluso cuando esta toma de decisiones sea de forma dinmica.
Gracias a ello, ayudan a estructurar y encapsular estas decisiones.
Un patrn de creacin asociado a clases usa la herencia para variar la clase que se
instancia, mientras que un patrn de diseo software de creacin asociado a objetos
delegar la instanciacin a otro objeto.
Hay dos formas de clasificar los patrones de diseo software de creacin basndose en
las clases de objetos que se crean. Una es clasificar las clases que crean los objetos
(Factory Method), y la otra forma est relacionada con la composicin de objetos
(definir un objeto que es responsable de conocer las clases de los objetos producto).
En esta caracterstica se apoyan los patrones Abstract Factory, Builder o Prototype.
a. Singleton
El patrn Singleton hace referencia a una instancia nica, la cual busca restringir
la creacin de objetos pertenecientes a una clase o valor de un tipo nico a un
nico objeto.

Su intencin es garantizar que una clase solo sea instanciada una vez y, adems,
proporcionar un nico punto de acceso global a la misma. Esto lo consigue gracias
a que es la propia clase la responsable de crear esa nica instancia, (declarando el
constructor de la clase como privado) y a que se permite el acceso global a dicha
instancia mediante un mtodo de clase.
Para implementar el patrn Singleton hay que crear un mtodo que instancie al
objeto slo si todava no existe ninguna otra instancia. Para asegurar que no
vuelva a ser instanciado, se limita al constructor con atributos protegidos o
privados.
Por esto, la implementacin del patrn puede ser complicada en programas
multihilos, ya que si dos o ms hilos de ejecucin instanciaran la clase al mismo
tiempo slo uno de ellos debera lograr crear el objeto. La solucin clsica para
este problema es utilizar exclusin mutua en el mtodo de creacin de la clase que
implementa el patrn.

Ilustracin 1 Utilizacin del patrn Singleton

b. Abstract Factory
El patrn Abstract Factory Define una interfaz para crear familias de objetos
relacionados o dependientes, sin especificar sus clases concretas
Al patrn Abstract Factory tambin se lo conoce como kit. El problema a
solucionar por este patrn es el de crear diferentes familias de objetos, como por
ejemplo la creacin de interfaces grficas de distintos tipos (ventana, men, botn,
etc.).
Ejemplo del patrn Abstract Factory
Podemos decir que los componentes tpicos del patrn Abstract Factory es la
siguiente:

Cliente: Entidad que llamar a la fbrica adecuada que necesite para crear
uno de los objetos que provee dicha factora, es decir, intentar obtener una
instancia de alguno de los productos que entren en juego (ProductoA,
ProductoB).
AbstractFactory: Definicin de la interfaz que usarn las diferentes factoras.
Como mnimo, debe ofrecer un mtodo para la obtencin de cada objeto que
se pueda crear. ("crearProductoA ()" y "crearProductoB ()")
Concrete Factories: Aqu se representarn las diferentes familias de
productos. Provee la instancia concreta del objeto que se encarga de crear.
Abstract Product: Definir las interfaces para la familia de productos
genricos. En el diagrama son "ProductoA" y "ProductoB". El cliente
trabajar directamente sobre esta interfaz, que ser implementada por los
diferentes productos concretos.
Concrete Product: Se encargar de la implementacin especfica de los
diferentes productos.

Ilustracin 2 Implementacin patrn Abstract Factory

2. Patrones de estructura
a. Facade
Qu es una fachada o facade en ingls? Es un patrn de diseo que nos
permite simplificar la interface de comunicacin entre dos objetos A y B de tal
forma que para el objeto A sea ms sencillo interactuar con el objeto B.
Entonces podemos decir que este patrn busca simplificar el sistema, desde el
punto de vista del cliente, proporcionando una interfaz unificada para un
conjunto de subsistemas, definiendo una interfaz de nivel ms alto. Esto hace
que el sistema sea ms fcil de usar.
Este patrn busca reducir al mnimo la comunicacin y dependencias entre
subsistemas. Para ello, utilizaremos una fachada, simplificando la complejidad
al cliente. El cliente debera acceder a un subsistema a travs del Facade. De

esta manera, se estructura un entorno de programacin ms sencillo, al menos


desde el punto de vista del cliente (por ello se llama "fachada").
Es necesario conocer cuando implementarlo y por eso debemos decir que se
debe utilizar cuando:

Se quiera proporcionar una interfaz sencilla para un subsistema complejo.


Se quiera desacoplar un subsistema de sus clientes y de otros subsistemas,
hacindolo ms independiente y portable.
Para una mejor comprensin de manera visual este patrn puede ser
representado de la siguiente forma usando un diagrama UML

Facade: conoce cuales clases del subsistema son responsables de una peticin.
Delega las peticiones de los clientes en los objetos del subsistema.
Subsistema: manejar el trabajo asignado por el objeto Facade. No tienen
ningn conocimiento del Facade (no guardan referencia de ste).
Como se puede notar los clientes se comunican con el subsistema a travs de la
facade, que reenva las peticiones a los objetos del subsistema apropiados y
puede realizar tambin algn trabajo de traduccin. Los clientes que usan la
facade no necesitan acceder directamente a los objetos del sistema.
b. Proxy
El patrn Proxy se utiliza como intermediario para acceder a un objeto,
permitiendo controlar el acceso a l. Para ello obliga que las llamadas a un
objeto ocurran indirectamente a travs de un objeto proxy, que acta como un
sustituto del objeto original, delegando luego las llamadas a los mtodos de los
objetos respectivos.
Este patrn se debe utilizar cuando:

Se necesite retrasar el coste de crear e inicializar un objeto hasta que es


realmente necesario.

Se necesita una referencia a un objeto ms flexible o sofisticada que un


puntero.
Algunas situaciones comunes de aplicacin son:
1. Proxy remoto: representa un objeto en otro espacio de direcciones.
Esto quiere decir que el proxy ser utilizado de manera tal que la
conexin con el objeto remoto se realice de forma controlada sin
saturar el servidor.
2. Proxy virtual: crea objetos costosos por encargo. Cuando se utiliza un
software no siempre se cargan todas las opciones por default. Muchas
veces se habilitan ciertos mdulos slo cuando el usuario decide
utilizarlos.
3. Proxy de proteccin: controla el acceso a un objeto. Controla derechos
de acceso diferentes.
4. Referencia inteligente: sustituto de un puntero que lleva a cabo
operaciones adicionales cuando se accede a un objeto (ej. contar el
nmero de referencias, cargar un objeto persistente en memoria,
bloquear el objeto para impedir acceso concurrente, ...).
El patrn Proxy es muy verstil. Puede ser utilizado en infinitas ocasiones y se
le puede otorgar varios usos. Tiene una gran ventaja y es que no obliga al
desarrollador a crear demasiada estructura para realizar este patrn, sino que es
una forma estndar de acceder a una clase que potencialmente puede ser
conflictiva. Por otro lado, no ayuda al desarrollador a crear un algoritmo, sino
que el desarrollador tiene que hacer toda la lgica.
Es decir, los servidores proxy funcionan como filtros de contenidos. Y tambin
mejoran el rendimiento: guardan en la memoria cach las pginas Web a las
que acceden los sistemas de la red durante un cierto tiempo. Cuando un
sistema solicita la misma pgina web, el servidor proxy utiliza la informacin
guardada en la memoria cach en lugar de recuperarla del proveedor de
contenidos. De esta forma, se accede con ms rapidez.
Este mismo concepto se intenta llevarlo a cabo a nivel cdigo con el patrn
Proxy. Cuando un objeto debe ser controlado de alguna manera, ya sea por
simple control de acceso o por estar en un sitio remoto o por ser muy pesado y
se quiera limitar su uso, es ideal utilizar este patrn.
Diagrama UML

Subject: interfaz o clase abstracta que proporciona un acceso comn al objeto


real y su representante (proxy).
Proxy: mantiene una referencia al objeto real. Controla la creacin y acceso a
las operaciones del objeto real.
RealSubject: define el objeto real representado por el Proxy.
Cliente: solicita el servicio a travs del Proxy y es ste quin se comunica con
el RealSubject.

3. Patrones de comportamiento
El objetivo del patrn de comportamiento es encapsular una peticin como un objeto,
de modo que puedan parametrizarse otros objetos con distintas peticiones o colas de
peticiones y proporcionar soporte para realizar operaciones que puedan deshacerse.
a. Observer
Define una dependencia del tipo uno-a-muchos entre objetos, de manera que
cuando uno de los objetos cambia su estado, notifica este cambio a todos los
dependientes. Est relacionado con algoritmos de funcionamiento y asignacin
de responsabilidades a clases y objetos
El patrn Observer es la clave del patrn de arquitectura Modelo Vista
Controlador (MVC). De hecho, el patrn fue implementado por primera vez en
Smalltalk's MVC basado en un framework de interfaz. Este patrn est
implementado en numerosas libreras y sistemas, incluyendo todos los toolkits de
GUI.
Caractersticas:

Permite modificar sujetos y observadores de manera independiente


Permite reutilizar un sujeto sin reutilizar sus observadores, y viceversa

Permite aadir observadores sin tener que cambiar el sujeto ni los dems
observadores
Acoplamiento abstracto entre el sujeto y el observador. El sujeto no sabe la
clase concreta de sus observadores (acoplamiento mnimo).
Soporte para broadcast. El sujeto enva la notificacin a todos los
observadores suscritos. Se pueden aadir/quitar observadores.
Actualizaciones inesperadas. Una operacin en el sujeto puede
desencadenar una cascada de cambios en sus observadores. El protocolo
no ofrece detalles sobre lo que ha cambiado.

Ilustracin 3 Implementacin patrn Observer

b. Strategy
El patrn Estrategia (Strategy) es un patrn de diseo para el desarrollo de
software. Se clasifica como patrn de comportamiento porque determina cmo se
debe realizar el intercambio de mensajes entre diferentes objetos para resolver una
tarea. El patrn estrategia permite mantener un conjunto de algoritmos de entre los
cuales el objeto cliente puede elegir aquel que le conviene e intercambiarlo
dinmicamente segn sus necesidades.
Contexto (Context): Es el elemento que usa los algoritmos, por tanto, delega en la
jerarqua de estrategias. Configura una estrategia concreta mediante una referencia
a la estrategia necesaria. Puede definir una interfaz que permita a la estrategia el
acceso a sus datos en caso de que fuese necesario el intercambio de informacin
entre el contexto y la estrategia. En caso de no definir dicha interfaz, el contexto
podra pasarse a s mismo a la estrategia como parmetro.
Estrategia (Strategy): Declara una interfaz comn para todos los algoritmos
soportados. Esta interfaz ser usada por el contexto para invocar a la estrategia
concreta.

Estrategia Concreta (ConcreteStrategy): Implementa el algoritmo utilizando la


interfaz definida por la estrategia.

Ilustracin 4 Implementacin patrn Strategy

DISEO E IMPLEMENTACIN
Diseo en UML e implementacin de 6 proyectos en Visual C#. Uno por cada patrn de
diseo.
Patrones de creacin
a) SINGLETON
Diagrama UML

Ilustracin 5 Diagrama UML Vehculo Singleton

Cdigo del Programa


Class Elemento
using System;
public class Cmotor
{
// Atributos:
private static Cmotor motor = new Cmotor();
private String num_motor;
private int tipo_combustible;
// Metodos:
private Cmotor()
{
}
public static Cmotor Motor
{
get { return motor; }
set { motor = value; }
}
public String num_Motor
{

get { return num_motor; }


set { num_motor = value; }
}
public int tipo_Combustible
{
get { return tipo_combustible; }
set { tipo_combustible = value; }
}
public void leer()
{
Console.Write("Ingresar el numero del motor: ");
num_motor= Console.ReadLine();
do {
Console.WriteLine("Tipo de combustible: ");
Console.WriteLine("\t1.-Diesel");
Console.WriteLine("\t2.-Extra");
Console.WriteLine("\t3.-Super");
Console.Write("Ingresar el tipo de combustible: ");
try
{
tipo_combustible = int.Parse(Console.ReadLine());
}
catch
{
Console.WriteLine("Ingrese solo numeros");
}
} while (tipo_combustible<=0||tipo_combustible>3);
}
public void mostrar()
{
Console.WriteLine("\t Numero del motor: {0}", num_motor);
if (tipo_Combustible==1)
{
Console.WriteLine("\t Tipo de combustible del motor: Diesel");
}
if (tipo_Combustible==2)
{
Console.WriteLine("\t Tipo de combustible del motor: Extra");
}
if (tipo_Combustible==3)
{
Console.WriteLine("\t Tipo de combustible del motor: Super");
}
}
}
public class Cchasis
{
// Atributos:
private static Cchasis chasis = new Cchasis();
private String num_chasis;
private int tipo_chasis;
// Metodos:
private Cchasis()
{
}
public static Cchasis Chasis
{
get { return chasis; }
set { chasis = value; }

}
public String Nombre
{
get { return num_chasis; }
set { num_chasis= value; }
}
public void leer()
{
Console.Write("Ingresar el numero del chasis: ");
num_chasis = Console.ReadLine();
do
{
Console.WriteLine("Tipo de Chasis: ");
Console.WriteLine("\t1.-Americano");
Console.WriteLine("\t2.-Europeo");
Console.WriteLine("\t3.-Japones");
Console.Write("Ingresar el tipo de chasis: ");
try
{
tipo_chasis = int.Parse(Console.ReadLine());
}
catch
{
Console.WriteLine("Ingrese solo numeros");
}
} while (tipo_chasis <= 0 || tipo_chasis > 3);
}
public void mostrar()
{
Console.WriteLine("\t Nombre del chasis: {0}", Nombre);
if (tipo_chasis == 1)
{
Console.WriteLine("\t Tipo de combustible del motor: Americano");
}
if (tipo_chasis == 2)
{
Console.WriteLine("\t Tipo de combustible del motor: Europeo");
}
if (tipo_chasis == 3)
{
Console.WriteLine("\t Tipo de combustible del motor: Japones");
}
}
}
public class Cdueo
{
// Atributos:
private static Cdueo dueo = new Cdueo();
private String nombre;
private String apellido;
private String direccion;
private String telefono;
private float velocidad;
// Metodos:
private Cdueo()
{
}
public static Cdueo Dueo
{
get { return dueo; }
set { dueo = value; }

}
public String Nombre
{
get { return nombre; }
set { nombre = value; }
}
public String Apellido
{
get { return nombre; }
set { nombre = value; }
}
public String Direccion
{
get { return nombre; }
set { nombre = value; }
}
public String Telefono
{
get { return nombre; }
set { nombre = value; }
}
public void leer()
{
Console.Write("Ingresar el nombre del dueo: ");
nombre = Console.ReadLine();
Console.Write("Ingresar el apellido del dueo: ");
apellido = Console.ReadLine();
Console.Write("Ingresar la direccion del dueo {0} {1}: ",nombre,apellido);
direccion = Console.ReadLine();
Console.Write("Ingresar el telefono del dueo {0} {1}: ",nombre, apellido);
telefono = Console.ReadLine();
}
public void mostrar()
{
Console.WriteLine("\t Nombre del dueo: {0}", Nombre);
Console.WriteLine("\t Apellido del dueo: {0}", Apellido);
Console.WriteLine("\t Direccion del dueo: {0}", Direccion);
Console.WriteLine("\t Telefono del dueo: {0}", Telefono);
}

public class CFecha


{
// Atributos:
private static CFecha fecha = new CFecha();
private DateTime fecha_auto;
// Metodos:
private CFecha()
{
}
public static CFecha Fecha
{
get { return fecha; }
set { fecha = value; }
}
public DateTime Hora
{
get { return fecha_auto; }
set { fecha_auto = value; }
}
public void fecha_Actual()
{
fecha_auto = DateTime.Now;

}
public void mostrar()
{
Console.WriteLine("\t Nombre del fecha: {0}", fecha_auto);
}

}
public class Cmatricula
{
// Atributos:
private static Cmatricula matricula = new Cmatricula();
private DateTime fecha;
private float valor;
// Metodos:
private Cmatricula()
{
}
public static Cmatricula Matricula
{
get { return matricula; }
set { matricula = value; }
}
public DateTime Fecha
{
get { return fecha; }
set { fecha = value; }
}
public float Valor
{
get { return valor; }
set { valor = value; }
}
public void leer()
{
fecha = DateTime.Now;
Console.Write("Ingresar el valor de la matricula: ");
valor = float.Parse(Console.ReadLine());
}
public void mostrar()
{
Console.WriteLine("\t Nombre del matricula: {0}", fecha);
Console.WriteLine("\t Velocidad del matricula: {0}", valor);
}
}
public class Cmultas
{
// Atributos:
private static Cmultas multas = new Cmultas();
private int multas_auto;
private float valor;
// Metodos:
private Cmultas()
{
}
public static Cmultas Multas
{
get { return multas; }
set { multas = value; }
}
public int Multas_Auto
{
get { return multas_auto; }
set { multas_auto = value; }

}
public float Valor
{
get { return valor; }
set { Valor = value; }
}
public void leer()
{
do
{
Console.Write("El auto tiene multas 1:Si 2:No : ");
try
{
multas_auto = int.Parse(Console.ReadLine());
}
catch (Exception)
{
Console.WriteLine("Ingrese solo numeros");
}
} while (multas_auto<=0||multas_auto>2);
Console.Write("Ingresar el valor de las multas del auto: ");
valor = float.Parse(Console.ReadLine());
}
public void mostrar()
{
if (multas_auto==1)
{
Console.WriteLine("\t El auto tiene multas debe cancelarlas" );
}
else
{
Console.WriteLine("\t El auto no tiene multas");
}
Console.WriteLine("\t Valor del multas: {0}", valor);
}

Class Program

class Program
{
static void Main(string[] args)
{
//Agregando metodo Singleton de las clases
Cmotor motor = Cmotor.Motor;
Cmultas multas = Cmultas.Multas;
Cdueo dueo = Cdueo.Dueo;
Cchasis chasis = Cchasis.Chasis;
CFecha fecha_auto = CFecha.Fecha;
Cmatricula matricula = Cmatricula.Matricula;
//Agregando elementos
motor.leer();
chasis.leer();
dueo.leer();
fecha_auto.fecha_Actual();
matricula.leer();
multas.leer();
//Mostrando Elementos
Console.WriteLine("\n \n \n \t DATOS DEL USUARIO");
motor.mostrar();
chasis.mostrar();
dueo.mostrar();
fecha_auto.mostrar();

matricula.mostrar();
multas.mostrar();
Console.ReadKey();
}
}

Capturas de pantalla

Ilustracin 6 Ingreso de datos

Ilustracin 7 Despliegue datos usuario

b) ABSTRACT FACTORY
Diagrama UML

Ilustracin 8 Diagrama UML Fabrica de vehculos Abstract Factory

Cdigo del Programa


class Program
{
static void Main(string[] args)
{
IFabricaVehiculos fabrica;
CDeportivo deportivo;
CCamioneta camioneta;
Console.WriteLine("\nVEHICULOS DEPORTIVOS");
fabrica = new CFabricaVehiculosNormal();
deportivo = fabrica.crearDeportivo();
camioneta = fabrica.crearCamioneta();
Console.WriteLine(deportivo);
Console.WriteLine(camioneta);
Console.WriteLine("VEHICULOS CAMIONETAS");
fabrica = new CFabricaVehiculosTodoterreno();
deportivo = fabrica.crearDeportivo();

camioneta = fabrica.crearCamioneta();
Console.WriteLine(deportivo);
Console.WriteLine(camioneta);
Console.ReadLine();
}
}
public abstract class CCamioneta : CVehiculo
{

}
public abstract class CDeportivo : CVehiculo
{
}
public class CDeportivoNormal : CDeportivo
{
public override float getCapacidad()
{
capacidadMotor = 1600;
return capacidadMotor;
}
public override string getColor()
{
color = "Amarillo";
return color;
}
public override string getNombre()
{
nombre = "Kia";
return nombre;
}
public override float getPrecio()
{
precio = 13500;
return precio;
}
}
public class CDeportivoTodoterreno : CDeportivo
{
public override float getCapacidad()
{
capacidadMotor = 2000;
return capacidadMotor;
}
public override string getColor()
{
color = "Negro";
return color;
}

public override string getNombre()


{
nombre = "Toyota";
return nombre;
}
public override float getPrecio()
{
precio = 23500;
return precio;
}
}
public class CCamionetaNormal : CCamioneta
{
public override float getCapacidad()
{
capacidadMotor = 2000;
return capacidadMotor;
}
public override string getColor()
{
color = "Gris";
return color;
}
public override string getNombre()
{
nombre = "Chevrolet";
return nombre;
}
public override float getPrecio()
{
precio = 27500;
return precio;
}
}
public class CCamionetaTodoterreno : CCamioneta
{
public override float getCapacidad()
{
capacidadMotor = 2800;
return capacidadMotor;
}
public override string getColor()
{
color = "Rojo";
return color;
}
public override string getNombre()
{
nombre = "Toyota";
return nombre;

}
public override float getPrecio()
{
precio = 33800;
return precio;
}
}
public class CFabricaVehiculosNormal : IFabricaVehiculos
{
public CDeportivo crearDeportivo()
{
return new CDeportivoNormal();
}
public CCamioneta crearCamioneta()
{
return new CCamionetaNormal();
}

}
public class CFabricaVehiculosTodoterreno : IFabricaVehiculos
{
public CDeportivo crearDeportivo()
{
return new CDeportivoTodoterreno();
}
public CCamioneta crearCamioneta()
{
return new CCamionetaTodoterreno();
}
}
public abstract class CVehiculo
{
protected float capacidadMotor;
protected String nombre;
protected float precio;
protected String color;
//Metodos
public abstract float getCapacidad();
public abstract String getNombre();
public abstract float getPrecio();
public abstract String getColor();
public override String ToString()
{
return "\n \tNombre= " + getNombre() + "\n \tColor= " + getColor() + "\n
\t(Capacidad = " + getCapacidad()+"cc"+ " \n \tPrecio = " + getPrecio() + " usd)";

}
}
public interface IFabricaVehiculos
{
CDeportivo crearDeportivo();
CCamioneta crearCamioneta();

Capturas de Pantalla

Ilustracin 9 Funcionamiento programa Vehculos Abstract Factory

2) Patrones de estructura
a) FACADE
Diagrama UML

Ilustracin 10 UML programa Calculadora

Cdigo del programa


Clase Fachada
class CFachada
{
public CFachada()
{
}
public void UsoCalculadora()
{
int num1, num2;
String operacion;
Console.WriteLine("CALCULADORA");
Console.Write("Ingrese el primer numero: ");
num1 = int.Parse(Console.ReadLine());
Console.Write("Ingrese el segundo numero: ");

num2 = int.Parse(Console.ReadLine());
Console.WriteLine("Operaciones ");
Console.WriteLine("SUMA (+)");
Console.WriteLine("RESTA (-)");
Console.Write("Escoja la operacion: ");
operacion = Console.ReadLine();
Console.Clear();
Console.WriteLine("Se usa calculadora para: {0}", operacion);
CCalculadora calc = new CCalculadora(num1, num2, operacion);
Console.WriteLine("Resultado de la operacion: {0}", calc.Operacion());
Console.Read();
}

Clase Calculadora
class CCalculadora
{
private int num1;
private int num2;
private string operacion;

public CCalculadora(int num1, int num2, string Ooperacion)


{
this.num1 = num1;
this.num2 = num2;
this.operacion = Ooperacion;
}
public int Operacion()
{
int resultado=0;
if (operacion.Equals("+"))
{
CSumaNumeros s = new CSumaNumeros();
resultado = s.suma(num1, num2);
}
if (operacion.Equals("-"))
{
CRestaNumeros s = new CRestaNumeros();

resultado = s.resta(num1, num2);


}
return resultado;
}
}

Clase Suma
class CSumaNumeros
{
public CSumaNumeros()
{

}
public int suma(int pA, int pB)
{
return pA + pB;
}
}

Clase Resta
class CRestaNumeros
{
public CRestaNumeros()
{
}
public int resta(int pA, int pB)

{
return pA - pB;
}
}

Capturas de Pantalla

Ilustracin 11 Interface Programa Calculadora: ingreso de datos

Ilustracin 12 Programa Calculadora: ingreso operacin

Ilustracin 13 Programa Calculadora Salida de Resultados

b) PROXY
Diagrama UML

Ilustracin 14 UML Programa PROXY Respaldo On-Line

Cdigo del programa

Interface Guardar
interface IGurdar
{
void Guardar(string Lista);
}

Clase Administrador de Conexin


class CAdministradorConeccion
{
private static bool hayConexion;
public CAdministradorConeccion()
{
hayConexion = false;
}
public void Conectate()
{
hayConexion = true;
}
public void Desconectate()
{

hayConexion = false;
}
public Boolean hayconexion()
{
return hayConexion;
}
}

Clase Guardar Datos


class CGuardarDatos : IGurdar
{
CAdministradorConeccion Cadmi;
public CGuardarDatos(CAdministradorConeccion Recive)
{
Cadmi = Recive;
}
public void Guardar(string Lista)
{
if (Cadmi.hayconexion())
{
CGuardadoRemoto obj1 = new CGuardadoRemoto();
obj1.Guardar("Datos Guardar");
}
else
{
CGuardarDiscoDuro obj2 = new CGuardarDiscoDuro();
obj2.Guardar("Datos Guardar");
}
}
}

Clase Guardar en disco


class CGuardarDiscoDuro : IGurdar
{
public void Guardar(string Lista)
{
Console.WriteLine("Datos Guaraddos en el Disco Duro...");

}
}

Clase Guardar Remoto


class CGuardadoRemoto : IGurdar
{
public void Guardar(string Lista)
{
Console.WriteLine("Datos guardados en la nube...");
}
}

Capturas de Pantalla

Ilustracin 15 Programa Respaldo On-Line Mensaje Inicial

Ilustracin 16 Programa Respaldo On-Line Menu

Ilustracin 17 Programa Respaldo On-Line Ingreso de datos

Ilustracin 18 Programa Respaldo On-Line Conexin

Ilustracin 19 Programa Respaldo On-Line Ingreso con resplado

Ilustracin 20 Programa Respaldo On-Line Desconexin

3) Patrones de comportamiento
a) OBSERVER
Diagrama UML

Ilustracin 21 Diagrama UML Patrn Observer

Cdigo del Programa


class IBM : Stock
{
public IBM(string symbol, double price) : base(symbol, price) { }
}
interface IInvestor
{
void Update(Stock stock);
}
namespace Observer
{
class Investor : IInvestor
{
private string _name;
private Stock _stock;
public Investor(string name)
{
this._name = name;

}
public void Update(Stock stock)
{
Console.WriteLine("Notificando que {0} de {1}'s " +
"cambio a {2:C}", _name, stock.Symbol, stock.Price);
}
public Stock Stock
{
get { return _stock; }
set { _stock = value; }
}

}
}
class Program
{
static void Main(string[] args)
{
// Crear acciones de IBM y adjuntar los inversores
IBM ibm = new IBM("IBM", 120.00);
ibm.Attach(new Investor("ESPE"));
ibm.Attach(new Investor("Quito"));

// fluctuacin de los precios notificarn a los inversores


ibm.Price = 120.10;
ibm.Price = 121.00;
// Esperar por usuario
Console.ReadKey();
}

}
abstract class Stock
{
private string _symbol;
private double _price;
private List<IInvestor> _investors = new List<IInvestor>();
// Constructor
public Stock(string symbol, double price)
{
this._symbol = symbol;
this._price = price;
}
public void Attach(IInvestor investor)
{
_investors.Add(investor);
}
public void Detach(IInvestor investor)
{
_investors.Remove(investor);
}
public void Notify()
{
foreach (IInvestor investor in _investors)
{
investor.Update(this);
}
Console.WriteLine("");
}
// Gets or sets the price
public double Price
{
get { return _price; }
set
{

if (_price != value)
{
_price = value;
Notify();
}

}
}
// Gets the symbol
public string Symbol
{
get { return _symbol; }
}
}

Capturas de Pantalla

b) STRATEGY
Diagrama UML

Ilustracin 22 Diagrama UML Strategy

Cdigo del Programa


class Program
{
/// <summary>
/// MainApp startup class for Real-World
/// Strategy Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
static void Main()
{
// Two contexts following different strategies
SortedList studentRecords = new SortedList();
studentRecords.Add("Samual");
studentRecords.Add("Jimmy");
studentRecords.Add("Sandra");
studentRecords.Add("Vivek");
studentRecords.Add("Anna");
studentRecords.SetSortStrategy(new QuickSort());
studentRecords.Sort();
studentRecords.SetSortStrategy(new ShellSort());
studentRecords.Sort();
studentRecords.SetSortStrategy(new MergeSort());
studentRecords.Sort();
// Wait for user
Console.ReadKey();
}

/// <summary>
/// The 'Strategy' abstract class
/// </summary>
abstract class SortStrategy
{
public abstract void Sort(List<string> list);
}
/// <summary>
/// A 'ConcreteStrategy' class
/// </summary>
class QuickSort : SortStrategy
{
public override void Sort(List<string> list)
{
list.Sort(); // Default is Quicksort
Console.WriteLine("lista de ordenamiendo rapido ");
}
}
/// <summary>
/// A 'ConcreteStrategy' class
/// </summary>
class ShellSort : SortStrategy
{
public override void Sort(List<string> list)
{
//list.ShellSort(); not-implemented
Console.WriteLine("Shell ordenada ");
}
}
/// <summary>
/// A 'ConcreteStrategy' class
/// </summary>
class MergeSort : SortStrategy
{
public override void Sort(List<string> list)
{
//list.MergeSort(); not-implemented
Console.WriteLine("Combinacion de lista ordenada");
}
}
/// <summary>
/// The 'Context' class
/// </summary>
class SortedList
{
private List<string> _list = new List<string>();
private SortStrategy _sortstrategy;
public void SetSortStrategy(SortStrategy sortstrategy)
{
this._sortstrategy = sortstrategy;
}
public void Add(string name)
{
_list.Add(name);
}

public void Sort()


{
_sortstrategy.Sort(_list);
// Iterate over list and display results
foreach (string name in _list)
{
Console.WriteLine(" " + name);
}
Console.WriteLine();
}

Capturas de Pantalla

Ilustracin 23 Funcionamiento del Patrn Strategy

ANLISIS DE RESULTADOS.
Patrn Singleton
Un Singleton permite que una clase tenga persistencia en cuanto a aquello que almacenan sus
propiedades. Y tambin consigue que los mtodos se comporten de formas similares porque las
propiedades que usan no se modifican entre instanciacin e instanciacin.
Patrn Abstract Factory
Intencin
Proporciona una interfaz para crear familias de objetos relacionados o que dependen entre s, sin
especificar sus clases concretas.
Problema
Se necesita instanciar familias de objetos.
Solucin
Coordinar la creacin de familias de objetos. Establecer una forma para quitar las reglas de cmo
realizar la instanciacin fuera del objeto que est usando los objetos a crear.
Patrn Facade
La principal ventaja del patrn fachada consiste en que para modificar las clases de los
subsistemas, slo hay que realizar cambios en la interfaz/fachada, y los clientes pueden
permanecer ajenos a ello. Adems, y como se mencion anteriormente, los clientes no
necesitan conocer las clases que hay tras dicha interfaz.
Como inconveniente, si se considera el caso de que varios clientes necesiten acceder a
subconjuntos diferentes de la funcionalidad que provee el sistema, podran acabar usando slo
una pequea parte de la fachada, por lo que sera conveniente utilizar varias fachadas ms
especficas en lugar de una nica global.

Patrn Proxy
El uso de un proxy introduce un nivel de indireccin adicional con diferentes usos:

Un proxy remoto oculta el hecho de que un objeto reside en otro espacio de


direcciones.

Un proxy virtual puede realizar optimizaciones, como la creacin de objetos bajo


demanda.

El proxy de proteccin y las referencias inteligentes permiten realizar diversas tareas


de mantenimiento adicionales al acceder a un objeto.

Adems, su uso tambin permite realizar una optimizacin COW (copy-on-write) , puesto
que copiar un objeto grande puede ser costoso, y si la copia no se modifica, no es necesario
incurrir en dicho gasto. Adems el sujeto mantiene un nmero de referencias, y slo cuando se

realiza una operacin que modifica el objeto, ste se copia. Es til por tanto para retrasar la
replicacin de un objeto hasta que cambia.

Patrn Observer
Puede pensarse en aplicar este patrn cuando una modificacin en el estado de un objeto requiere
cambios de otros, y no deseamos que se conozca el nmero de objetos que deben ser cambiados.
Tambin cuando queremos que un objeto sea capaz de notificar a otros objetos sin hacer ninguna
suposicin acerca de los objetos notificados y cuando una abstraccin tiene dos aspectos diferentes,
que dependen uno del otro; si encapsulamos estos aspectos en objetos separados permitiremos su
variacin y reutilizacin de modo independiente.

Patrn Strategy
Cualquier programa que ofrezca un servicio o funcin determinada, que pueda ser realizada de varias
maneras, es candidato a utilizar el patrn estrategia. Puede haber cualquier nmero de estrategias y
cualquiera de ellas podr ser intercambiada por otra en cualquier momento, incluso en tiempo de
ejecucin. Si muchas clases relacionadas se diferencian nicamente por su comportamiento, se crea
una superclase que almacene el comportamiento comn y que har de interfaz hacia las clases
concretas.
Si un algoritmo utiliza informacin que no deberan conocer los clientes, la utilizacin del patrn
estrategia evita la exposicin de dichas estructuras. Aplicando el patrn a una clase que defina
mltiples comportamientos mediante instrucciones condicionales, se evita emplear estas
instrucciones, moviendo el cdigo a clases independientes donde se almacenar cada estrategia.
Efectivamente, como se comenta anteriormente, este patrn de diseo nos sirve para intercambiar un
sin nmero de estrategias posibles.

CONCLUSIONES Y RECOMENDACIONES.
Conclusiones
El uso del patrn Singleton ayuda en la utilizacin de un solo elemento de clase,
permitiendo usar un elemento de la clase sin necesidad de crear un nuevo objeto de la
clase
El uso de un case para el diseo del diagrama UML, ayuda en la creacin de un
Software, ya que se especifica las funcionalidades y se puede realizar la creacin del
mismo desde el case.
Recomendaciones
Definir bien la clase y especificar que elemento se utilizara con el patrn Singleton
Definir bien el tipo de datos de los atributos cuando se realiza el diagrama UML, as
como las funciones que retornan

BIBLIOGRAFA
Aprende a Programar Corporation. (3 de Enero de 2016). Aprende a Programar.
Obtenido de http://www.aprenderaprogramar.com/
Juarez, M. (22 de Mayo de 2016). Proxy. Obtenido de Mi Granito de Java:
http://migranitodejava.blogspot.com/2011/06/proxy.html
Ramirez, J. L. (22 de Mayo de 2016). Facade. Obtenido de El Espacio Java:
http://elespaciojava.blogspot.com/2012/10/patron-facade-o-fachada.html