Probando Microsoft AZURE

Luego de la espera de 3 días para recibir e acceso a Microsoft AZURE, al fin he logrado probar los servicios realizando conexión desde .net

Luego de registrase, se puede crear la base de datos simplemente como estructura general, pero no se puede aún crear los componentes como tablas, índices, etc.. desde el ambiente proporcionado, para poder crear la estructura se lo debe hacer mediante conexión a la base de datos con .net, php, u otro soportado.

Se proporciona el ConnectionString  para poder ser utilizado, en mi caso desde .net, para lo cual muestro un código muy criollo para la conexión

 

 

 

 

Así mismo todas la configuraciones de firewall se las realiza desde el entorno web proporcionado por AZURE

Espero que el CTP madure, pero ahora mismo ya tenemos con SQL Azure un primer paso para mantener nuestra base de datos.

Patron creacional Singleton

Dentro del conjunto de patrones creacionales uno de los más sencillo de entender e implementar es el singleton.

Propósito

Garantizar que solo se tenga una instancia y maneter un punto de acceso global a ella

Motivación: Muchas ocasiones necesitamos que de una determinada clase únicamente se pueda crear una sola instancia, en mi experiencia muy particular le he encontrado mucha utilidad en las aplicaciones móviles. Cuando tenemos una form creado en .net para dispositivo móvil este se crea con una x en la esquina, el cual no precisamente cierra la venta al hacerle click lo que ocasiona que si nuevamente llamamos al menú que despliega esta ventana nos creará otra instancia lo cual no es recomendable en aplicaciones móviles ya que la memoria tiende a saturarse, al implementar este patron lo que hariamos es mantener una sola instancia y al invocar nuevamente el form lo que hariamos es simplemente reactivar el formulario.

Estructura:

Participantes:

• Singleton: Define la operación instancia que permite que se acceda a la instancia, esta es static.

Implementación:

¿Como sincronizar datos en aplicaciones móviles con .net?

Este tema de sincronización de datos en las aplicaciones móviles es el que posiblemente  nos hace doler la cabeza al momento de desarrollar una aplicación móvil.

Existen varios mecanismos de sincronización como son:

• RDA: Mecanismo de sincronización de datos cuando utilizas sql server para lo cual utilizas la clase SqlCeRemoteDataAccess, para lo que deberias tener sql server tanto en el dispositivo móvil como en el servidor. Si deseas utilizar otra base de datos en el servidor puedes utilizar Microsoft SQL Server 2005 Compact Edition Access Database Synchronizer, este te permite la sincronización con base de datos access. Link de descarga
• Servicios Web(XML, REST): Podrias levantar un conjunto de servicios web los cuales los consumes desde el dispositvo móvil tanto para entrada de datos como para la salida
• Entornos desconectados XML: Si deseas mantener independencia de cualquiera de las partes y manejar un entorno desconectado la mejor opción seria XML ya que lo puedes manejar las carga y descargas estos pueden ser administrados a través del SD de tu dispositivo.
• GPRS, podria ser otra alternativa manejar flujos de información mediante la red de la telefónica pero ahi muchos puntos que evaluar aun.
• Implementar servicios de red mediante sockets, suena bien pero gran trabajo por hacer.

Elegir la mejor alternativa depende del contexto en el cual estemos trabajando pero los medios son varios

ParrallelFX

Son las nuevas extensiones de .net para soporte multicore o multiprocesamiento. En la actualidad tenemos los famosos procesadores multicore pero como podemos utilizarlos de manera adecuada desde nuestro código?.

Que interesante poder escribir cosas como estas

Parallel.For(0, 100, delegate(int i) {
  a[ i ] = a[ i ] * a[ i ];
});

Las nuevas extensión funcionan sobre el famework 3.5, ahi les dejo el link en donde pueden encontrar mas información

http://msdn2.microsoft.com/en-us/concurrency/default.aspx

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);
        }
    }
}