Patrones Estructurales

Patrones Estructurales

Adaptador (Adapter): Convierte una interfaz en otra.

Puente (Bridge): Desacopla una abstracción de su implementación permitiendo modificarlas independientemente.

Objeto Compuesto (Composite): Utilizado para construir objetos complejos a partir de otros más simples, utilizando para ello la composición recursiva y una estructura de árbol.

Envoltorio (Decorator): Permite añadir dinámicamente funcionalidad a una clase existente, evitando heredar sucesivas clases para incorporar la nueva funcionalidad.

Fachada (Facade): Permite simplificar la interfaz para un subsistema.

Peso Ligero (Flyweight): Elimina la redundancia o la reduce cuando tenemos gran cantidad de objetos con información idéntica.

Apoderado (Proxy): Un objeto se aproxima a otro

Singleton patrón de diseño

Estructura de un programa COBOL

La estructura de un programa COBOL Consiste de 4 divisiones:

· Identification Division
· Environment Division
· Data Division
· Procedure Division.

Identification Division

La Identification Division es obligatoria. Las otras tres son opcionales, pero si se las codifica, estas deben ser invocadas en orden. Cada división tiene un propósito especifico y usa Cláusulas, Frases, instrucciones y Sentencias para cumplir con dicho objetivo.
La Identification Division es la primer división que se escribe en un programa COBOL. Especifica el nombre del programa y provee de información adicional, tal como el autor del programa y la fecha de compilación. La Identification Division debe comenzar con las
palabras IDENTIFICATION DIVISION o ID DIVISION. El párrafo PROGRAM-ID es obligatorio y debe ser el primero de la identificación. Los restantes párrafos son opcionales y pueden ser escritos en cualquier orden.

Environment Division

La Environment Division de un programa COBOL brinda información sobre las características físicas especificas del ambiente en el que correrá el programa. Especifica información sobre la computadora en que se generó el programa y aquella en la que se correrá. También relaciona los archivos de entrada y salida del programa con los
dispositivos de hardware específicos. La Environment Division se compone de dos secciones “section”:

*Configuration Section
*Input-Output Section.

Data Division

La Data Division describe las estructuras de datos a ser procesadas por el programa COBOL. Puede contener hasta cinco secciones (dependiendo del cobol en uso, las primeras tres comunes a todos), todas son opcionales:

* File Section
* Working-Storage Section
* Linkage Section
* Screen Section
* Local Section

Estas secciones, en orden, están compuestas por la descripción de los archivos, las descripciones de entrada de datos necesarias para ejecutar el programa, las descripciones de áreas de datos para recibir parámetros, las descripciones de las áreas para describir el formato de los datos a ser mostrados y recibidos desde pantalla y la descripción de las entradas de datos que permitirán generar distintas instancias de las variables en aquellos
programas recursivos.

Procedure Division

La Procedure Division es la cuarta y ultima división dentro de un programa COBOL. Contiene los procedimientos, secciones, párrafos, declaraciones, sentencias e instrucciones necesarias para ejecutar el procesamiento de la función y resolver el problema de procesamiento de los datos. Una sección declarativa “Declaratives Section” puede aparecer al comienzo de la procedure division. Esta especifica procesos declarativos a ser procesados cuando se produce una condición de excepción que no puede ser tratada por los testeos ordinarios. La sentencia USE debe ser la primer sentencia de cada sección especificada dentro de la Declaratives Section. Esta identifica el tipo de procesos declarativos provistos. (En la actualidad esta sección es muy poco usada dada las posibilidades de testeos de condiciones de excepción que tienen las sentencias actuales).

DEFINICION DE BUSINESS INTELLIGENCE

“Business Intelligence (BI) es un término cierto que abarca los procesos, las herramientas, y las tecnologías para convertir datos en información, información en conocimiento y planes para conducir de forma eficaz las actividades de los negocios. BI abarca las tecnologías de datawarehousing los procesos en el ‘back end’, consultas, informes, análisis y las herramientas para mostrar información (estas son las herramientas de BI) y los procesos en el ‘front end’

Exploremos algunos ejemplos concretos de cómo el Business Intelligence nos puede generar beneficios:

• Beneficios tangibles, generación de ingresos:

• Mejorar la adquisición de clientes y su conversión mediante el uso de la segmentación.
• Reducir la tasa de abandono de clientes, incrementar su fidelidad, teniendo en cuenta cuál es su valor.
• Incrementar los ingresos por crecimiento de las ventas.
• Aumentar los resultados, consiguiendo que nuestros clientes actuales compren más productos o servicios.
• Evitar las pérdidas producidas por las ventas de nuestros competidores.
• Aumentar la rentabilidad por el acceso a información detallada de productos, clientes, etc.
• Conocer mejor cuáles son las características demográficas de nuestra zona de influencia.
• Hacer crecer la participación de mercado.
• Reducir el tiempo de lanzamiento de nuevos productos o servicios.
• Mejorar aquellas actividades relacionadas con la captura de datos.
• Analizar la cesta de la compra y la afinidad de venta entre los productos Facilitar la adopción de los cambios en la estrategia.
• Proveer el autoservicio de información a trabajadores, colaboradores, clientes y proveedores.
• Medir la efectividad de las campañas rápidamente y ser capaces de hacer los ajustes durante el ciclo de vida de las mismas.
• Optimizar las acciones de marketing.
• Identificar clientes rentables en segmentos no rentables.
• Analizar a la competencia cuando establecemos precios.
• Crear nuevas oportunidades.

• Beneficios tangibles, reducción de costes:

• Negociar mejores precios con los proveedores, identificar a los proveedores más importantes, gestionar descuentos por cantidades de compra; permitir el análisis del cumplimiento de los proveedores y asignar las compras de acuerdo con ello; medir el nivel de calidad, servicio y precio.
• Reducir o reasignar el personal necesario para llevar a cabo los procesos.
• Incrementar la productividad con información más inmediata y mejor.
• Aumentar el control de costes.
• Disminuir los gastos.
• Eliminar ineficiencias y reducir los costes operativos al generar “una sola versión de la verdad”.
• Descender pérdidas detectando fraude.
• Reducir los créditos incobrables.
• Bajar las reclamaciones (por ejemplo en el sector seguros).
• Eliminarlas sobreproducciones de productos.
• Proveer inventarios “just-in-time”; gestionar los inventarios de productos acabados; mejorar la gestión de materias primas y productos acabados; reducir los costes de mantenimiento del stock.
• Acortar los tiempos de respuesta a las peticiones de informes.
• Analizar los problemas, reparaciones y defectos y proveer la información para hacer un seguimiento y corregir los problemas recurrentes.
• Reducir el tiempo para recoger la información para cumplir con las normativas legales.
• Evaluar el rendimiento de los activos y generar las alertas cuando el mantenimiento preventivo se debe llevar a cabo.
• Proveer el suministro dentro del plazo.
• Hacer un seguimiento de los problemas de los productos desde el inicio de su vida hasta el fin.
• Retirar los viejos equipos para disminuirlos costes de actividad.
• Reducir las devoluciones de productos.
• Analizar la productividad de los empleados.
• Dar soporte a las reclamaciones de facturación.
• Abaratar los costes de las acciones de marketing.
• Hacer un mejor seguimiento de las acciones delictivas.
• Saber qué comisiones se deben pagar.
• Hacer decrecer las pérdidas de créditos, analizando la utilización de los clientes, asignando un análisis de riesgo.

• Beneficios intangibles:

• Optimizar la atención a los clientes.
• Aumentar la satisfacción de los clientes.
• Mejorar el acceso a los datos a través de consultas, análisis informes.
• Información más actualizada.
• Dotar a la información de mayor precisión.
• Conseguir ventajas competitivas.
• Controlar mejor de la información.
• Ahorrar costes.
• Menor dependencia de los sistemas desarrollados.
• Mayor integración de la información.

• Beneficios estratégicos:

• Mayor habilidad para analizar estrategias de precios.
• Y para identificar y nutrir a aquellos clientes con mayor potencial.
• Mejorar la toma de decisiones, realizándola de forma más rápida, informada y basada en hechos.
• Mayor visibilidad de la gestión.
• Dar soporte a las estrategias.
• Aumentar el valor de mercado.

Harold Caicedo

Abstract Factory (Fabrica Abstracta) Patron de diseño

Crea una instancia de varias familias de clases

Definición


Proporcionar una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.

Frecuencia de uso:

High

UML class diagram

Los participantes


Las clases y los objetos que participan en este modelo son:

• AbstractFactory (ContinentFactory) 

1. declara una interfaz para las operaciones que crean productos abstractos 

• ConcreteFactory (AfricaFactory, AmericaFactory) 

1. implementa las operaciones para crear objetos de productos concretos 

• AbstractProduct (Herbivore, Carnivore) 

1. declara una interfaz para un tipo del objeto Product

• Product (Wildebeest, Lion, Bison, Wolf) 

1. define un objeto de producto que se crea por la correspondiente fábrica de hormigón 
2. implementa la interfaz AbstractProduct 

• Client (AnimalWorld) 

1. utiliza interfaces declaradas por las clases AbstractFactory y AbstractProduct 

Código estructural en C # 

Este código estructural demuestra el patrón Abstract Factory crear jerarquías paralelas de los objetos. Creación de objetos ha sido abstraído y no hay necesidad de nombres de clase no modificables en el código de cliente.

1. using System;
2. 
   
3. namespace Abstract.Structural
4. {
5.   /// <summary>
6.   /// MainApp startup class for Structural
7.   /// Abstract Factory Design Pattern.
8.   /// </summary>
9.   class MainApp
10.   {
11.     /// <summary>
12.     /// Entry point into console application.
13.     /// </summary>
14.     public static void Main()
15.     {
16.       // Abstract factory #1
17.       AbstractFactory factory1 = new ConcreteFactory1();
18.       Client client1 = new Client(factory1);
19.       client1.Run();
20. 
    
21.       // Abstract factory #2
22.       AbstractFactory factory2 = new ConcreteFactory2();
23.       Client client2 = new Client(factory2);
24.       client2.Run();
25. 
    
26.       // Wait for user input
27.       Console.ReadKey();
28.     }
29.   }
30. 
    
31.   /// <summary>
32.   /// The 'AbstractFactory' abstract class
33.   /// </summary>
34.   abstract class AbstractFactory
35.   {
36.     public abstract AbstractProductA CreateProductA();
37.     public abstract AbstractProductB CreateProductB();
38.   }
39. 
    
40. 
    
41.   /// <summary>
42.   /// The 'ConcreteFactory1' class
43.   /// </summary>
44.   class ConcreteFactory1 : AbstractFactory
45.   {
46.     public override AbstractProductA CreateProductA()
47.     {
48.       return new ProductA1();
49.     }
50.     public override AbstractProductB CreateProductB()
51.     {
52.       return new ProductB1();
53.     }
54.   }
55. 
    
56.   /// <summary>
57.   /// The 'ConcreteFactory2' class
58.   /// </summary>
59.   class ConcreteFactory2 : AbstractFactory
60.   {
61.     public override AbstractProductA CreateProductA()
62.     {
63.       return new ProductA2();
64.     }
65.     public override AbstractProductB CreateProductB()
66.     {
67.       return new ProductB2();
68.     }
69.   }
70. 
    
71.   /// <summary>
72.   /// The 'AbstractProductA' abstract class
73.   /// </summary>
74.   abstract class AbstractProductA
75.   {
76.   }
77. 
    
78.   /// <summary>
79.   /// The 'AbstractProductB' abstract class
80.   /// </summary>
81.   abstract class AbstractProductB
82.   {
83.     public abstract void Interact(AbstractProductA a);
84.   }
85. 
    
86. 
    
87.   /// <summary>
88.   /// The 'ProductA1' class
89.   /// </summary>
90.   class ProductA1 : AbstractProductA
91.   {
92.   }
93. 
    
94.   /// <summary>
95.   /// The 'ProductB1' class
96.   /// </summary>
97.   class ProductB1 : AbstractProductB
98.   {
99.     public override void Interact(AbstractProductA a)
100.     {
101.       Console.WriteLine(this.GetType().Name +
102.         " interacts with " + a.GetType().Name);
103.     }
104.   }
105. 
     
106.   /// <summary>
107.   /// The 'ProductA2' class
108.   /// </summary>
109.   class ProductA2 : AbstractProductA
110.   {
111.   }
112. 
     
113.   /// <summary>
114.   /// The 'ProductB2' class
115.   /// </summary>
116.   class ProductB2 : AbstractProductB
117.   {
118.     public override void Interact(AbstractProductA a)
119.     {
120.       Console.WriteLine(this.GetType().Name +
121.         " interacts with " + a.GetType().Name);
122.     }
123.   }
124. 
     
125.   /// <summary>
126.   /// The 'Client' class. Interaction environment for the products.
127.   /// </summary>
128.   class Client
129.   {
130.     private AbstractProductA _abstractProductA;
131.     private AbstractProductB _abstractProductB;
132. 
     
133.     // Constructor
134.     public Client(AbstractFactory factory)
135.     {
136.       _abstractProductB = factory.CreateProductB();
137.       _abstractProductA = factory.CreateProductA();
138.     }
139. 
     
140.     public void Run()
141.     {
142.       _abstractProductB.Interact(_abstractProductA);
143.     }
144.   }
145. }

Resultado

ProductB1 interacts with ProductA1
ProductB2 interacts with ProductA2

Código del mundo real en C #

Este código del mundo real demuestra la creación de diferentes animales para un juego de ordenador utilizando diferentes fábricas. Aunque los animales creados por las fábricas son de continente diferentes, las interacciones entre los animales siguen siendo los mismos.

1. using System;
2. 
   
3. namespace Abstract.RealWorld
4. {
5.   /// <summary>
6.   /// MainApp startup class for Real-World
7.   /// Abstract Factory Design Pattern.
8.   /// </summary>
9.   class MainApp
10.   {
11.     /// <summary>
12.     /// Entry point into console application.
13.     /// </summary>
14.     public static void Main()
15.     {
16.       // Create and run the African animal world
17.       ContinentFactory africa = new AfricaFactory();
18.       AnimalWorld world = new AnimalWorld(africa);
19.       world.RunFoodChain();
20. 
    
21.       // Create and run the American animal world
22.       ContinentFactory america = new AmericaFactory();
23.       world = new AnimalWorld(america);
24.       world.RunFoodChain();
25.       // Wait for user input
26.       Console.ReadKey();
27.     }
28.   }
29. 
    
30.   /// <summary>
31.   /// The 'AbstractFactory' abstract class
32.   /// </summary>
33.   abstract class ContinentFactory
34.   {
35.     public abstract Herbivore CreateHerbivore();
36.     public abstract Carnivore CreateCarnivore();
37.   }
38. 
    
39.   /// <summary>
40.   /// The 'ConcreteFactory1' class
41.   /// </summary>
42.   class AfricaFactory : ContinentFactory
43.   {
44.     public override Herbivore CreateHerbivore()
45.     {
46.      return new Wildebeest();
47.     }
48.     public override Carnivore CreateCarnivore()
49.     {
50.       return new Lion();
51.     }
52.   }
53. 
    
54.   /// <summary>
55.   /// The 'ConcreteFactory2' class
56.   /// </summary>
57.   class AmericaFactory : ContinentFactory
58.   {
59.     public override Herbivore CreateHerbivore()
60.     {
61.       return new Bison();
62.     }
63.     public override Carnivore CreateCarnivore()
64.     {
65.       return new Wolf();
66.     }
67.   }
68. 
    
69.   /// <summary>
70.   /// The 'AbstractProductA' abstract class
71.   /// </summary>
72.   abstract class Herbivore
73.   {
74.   }
76.   /// <summary>
77.   /// The 'AbstractProductB' abstract class
78.   /// </summary>
79.   abstract class Carnivore
80.   {
81.     public abstract void Eat(Herbivore h);
82.   }
83.   /// <summary>
84.   /// The 'ProductA1' class
85.   /// </summary>
86.   class Wildebeest : Herbivore
87.   {
88.   }
89. 
    
90.   /// <summary>
91.   /// The 'ProductB1' class
92.   /// </summary>
93.   class Lion : Carnivore
94.   {
95.     public override void Eat(Herbivore h)
96.     {
97.       // Eat Wildebeest
98.      Console.WriteLine(this.GetType().Name +
99.         " eats " + h.GetType().Name);
100.     }
101.   }
102. 
     
103.   /// <summary>
104.   /// The 'ProductA2' class
105.   /// </summary>
106.   class Bison : Herbivore
107.   {
108.   }
109. 
     
110.   /// <summary>
111.   /// The 'ProductB2' class
112.   /// </summary>
113.   class Wolf : Carnivore
114.   {
115.     public override void Eat(Herbivore h)
116.     {
117.       // Eat Bison
118.       Console.WriteLine(this.GetType().Name +
119.         " eats " + h.GetType().Name);
120.     }
121.   }
122.   /// <summary>
123.   /// The 'Client' class
124.   /// </summary>
125.   class AnimalWorld
126.   {
127.     private Herbivore _herbivore;
128.     private Carnivore _carnivore;
129. 
     
130.     // Constructor
131.     public AnimalWorld(ContinentFactory factory)
132.     {
133.       _carnivore = factory.CreateCarnivore();
134.       _herbivore = factory.CreateHerbivore();
135.     }
136.     public void RunFoodChain()
137.     {
138.       _carnivore.Eat(_herbivore);
139.     }
140.   }
141. }

Resultado

Lion eats Wildebeest
Wolf eats Bison