Patrones Creacionales

 

Los patrones creaciones abstraen el proceso de instanciación y hacen que el sistema sea independiente de la creación de los objetos.

Dentro de los patrones creacionales se tiene:

Abstract Factory

Permite la creación de familias de objetos relacionados que dependen entre si.

Motivación: La motivación para la creación de este patróo es a aceptación de multiples presentaciones de usuario, por ejemplo vamos a suponer que deseamos construir una aplicación en la que necesitemos tener diferentes look and feel entonces se lo puede solocionar por medio de este patron.

Estructura:

Participantes:

• Fabrica Abstracta: Declara una interfaz para operaciones que crean objetos de producto abstracto
• FabricaConcreta: Implementa las operaciones para crear objetos producto concreto
• ProductoAbstracto: Declara una interfaz para un tipo de objeto producto
• ProductoConcreto: Define un objeto producto para que sea creado por la fabrica correspondiente
• Cliente: Usa las interfaces de FabricaAbstracta y ProductoAbstracto

Implementación c#

using System;

namespace Patterns.Creational
{
    class AbstractFactoryPattern
    {
        public static void Main()
        {
            // Abstract factory #1
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            // Abstract factory #2
            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();

            // Wait for user input
            Console.Read();
        }
    }

    // "AbstractFactory" 

    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    // "ConcreteFactory1" 

    class ConcreteFactory1 : AbstractFactory
    {
        public ConcreteFactory1()
        {
            int a = 1;
        }
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    // "ConcreteFactory2" 

    class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

    // "AbstractProductA" 

    abstract class AbstractProductA
    {

    }

    // "AbstractProductB" 

    abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    // "ProductA1" 

    class ProductA1 : AbstractProductA
    {
    }

    // "ProductB1" 

    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    // "ProductA2" 

    class ProductA2 : AbstractProductA
    {
    }

    // "ProductB2" 

    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    // "Client" - the interaction environment of the products 

    class Client
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        // Constructor
        public Client(AbstractFactory factory)
        {
            AbstractProductB = factory.CreateProductB();
            AbstractProductA = factory.CreateProductA();
        }

        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }
}

Implementación de ejemplo c#

using System;

namespace Patterns.Creational
{
    // MainApp test application 

    class ExampleAbstractFactory
    {
        public static void Main()
        {
            // Create and run the Africa animal world
            ContinentFactory africa = new AfricaFactory();
            AnimalWorld world = new AnimalWorld(africa);
            world.RunFoodChain();

            // Create and run the America animal world
            ContinentFactory america = new AmericaFactory();
            world = new AnimalWorld(america);
            world.RunFoodChain();

            // Wait for user input
            Console.Read();
        }
    }

    // "AbstractFactory" 

    abstract class ContinentFactory
    {
        public abstract Herbivore CreateHerbivore();
        public abstract Carnivore CreateCarnivore();
    }

    // "ConcreteFactory1" 

    class AfricaFactory : ContinentFactory
    {
        public override Herbivore CreateHerbivore()
        {
            return new Wildebeest();
        }
        public override Carnivore CreateCarnivore()
        {
            return new Lion();
        }
    }

    // "ConcreteFactory2" 

    class AmericaFactory : ContinentFactory
    {
        public override Herbivore CreateHerbivore()
        {
            return new Bison();
        }
        public override Carnivore CreateCarnivore()
        {
            return new Wolf();
        }
    }

    // "AbstractProductA" 

    abstract class Herbivore
    {
    }

    // "AbstractProductB" 

    abstract class Carnivore
    {
        public abstract void Eat(Herbivore h);
    }

    // "ProductA1" 

    class Wildebeest : Herbivore
    {
    }

    // "ProductB1" 

    class Lion : Carnivore
    {
        public override void Eat(Herbivore h)
        {
            // Eat Wildebeest
            Console.WriteLine(this.GetType().Name +
              " eats " + h.GetType().Name);
        }
    }

    // "ProductA2" 

    class Bison : Herbivore
    {
    }

    // "ProductB2" 

    class Wolf : Carnivore
    {
        public override void Eat(Herbivore h)
        {
            // Eat Bison
            Console.WriteLine(this.GetType().Name +
              " eats " + h.GetType().Name);
        }
    }

    // "Client" 

    class AnimalWorld
    {
        private Herbivore herbivore;
        private Carnivore carnivore;

        // Constructor
        public AnimalWorld(ContinentFactory factory)
        {
            carnivore = factory.CreateCarnivore();
            herbivore = factory.CreateHerbivore();
        }

        public void RunFoodChain()
        {
            carnivore.Eat(herbivore);
        }
    }
}

Arquitectura Ajax

Dar al usuario una buena experiencia en el uso de las aplicaciones web es uno de los puntos que permiten que este retorne a visitarlo. Todos hemos experiementado las aplicacionesweb  en las que para cargar un dato necesitamos esperar a que toda la página se cargue para obtene resultados, imaginarse recargar toda la página por un dato especifico no es realmente agradable, gracias AJAX podemos solventar esto.

Lo que Ajax utiliza JavaScript combinado con XML para racargar la información del servidor sin refrescar la página, lo que mejora la experiencia del usuario y el ancho de banda requerido para el paso de información disminuye

Podemos observar la diferencia entre el modelo clasico y un modelo con AJAX.

Dentro de los casos en los cuales es aconsejable la utilización de AJAX se tiene:

• Validación de información de formularios
• Autocompletar información(correos electrónicos, nombres, etc.)
• Operaciones en donde se maneja maestro detalle
• Barras de progreso, mapas, entre otros.

Existen varias alternativas para implentar AJAX, dentro de las que mas se recomienda son las librerias de cliente para Java Script, por el mayor control del lado del cliente, asi como navegadores, facilidad de desarrollo, etc.

 

Loxa Bloggers 2007

Iniciativa interesante que nos podamos reunir para compartir todos los que blogeamos en Loxa para el mundo

La agenda de dicho evento Aqui, asi que todos estamos invitados y si no pues nos colamos pero ahi estarémos

Instalando y configurando Project Server 2007

Quiero compartir la instalación y configuración de Project Server 2007, ya que me he gastado unos cuantos días por no tener conocimiento o intuición de algunos cosas triviales.

• Tener instalado windows server 2003
• Descargar e Instalar los services pack  2
• Tener instalado IIS
• Instalar el Framework 3.0 o 3.5
• Conocer el servidor de base de datos SQL Server a utilizar, en caso de ser el mismo servidor instalar SQL Server 2005.
• Proceder con la instalación de Project Server 2007
• Terminada la instalación, ejecutar el asistente de configuración de tecnologías SharePoint, la información que se solicita en este proceso es sencilla de configurar(servidor de base de datos,  usuario que realiza la conexión, elegir un puerto desde se realizará la administración de share point,etc).
• Ingresar al link de administación http://servidor:puerto/ , luego ingresar  en el area donde esta el nombre del servidor
• Luego hacer click para levantar Project Application Service y Windows Sharepoint Service Search
• Configurar la información solicitada para levantar el servicio y no olvidar colocar el dominio del usuario, en caso de no hacerlo al aceptar los cambios lanza un error inesperado que les podra hacer quebrar la cabeza.
• Realizado esto ir a la pestaña Application Management y seleccionar la opción crear un conjunto de servidores(Create or configure this farm’s shared services), luego elegimos New SSP
• Elegimos crear una nueva aplicación web si aun no la hemos creado
• En el application pool de la configuración del nuevo sitio web que estamos creando tener cuidado de que no sea un servicio de red, ya que al serlo no permitirá que se utilice para creación del conjunto de servidores. Parametrizamos la información necesaria y estamos casi a 1 paso.
• Creado el conjunto de servidores, elegimos el conjunto de servidores creado, en la parte izquierda.

                                        

           

• Elegimos crear Project Web Access Site, y uff!! al fin hemos terminado.

Buen Provecho.