martes, 26 de febrero de 2013

Patrón Observer en C# para Chilean people

Hola a todos mis queridos computines ñoños, esta vez les explicaré pasito a pasito como implementar el Patrón de Diseño Observer, de forma sencilla  pero explicado al estilo chilensis para entendamos todos los que nos aburre aquellos lenguajes y tecnicismos a veces exagerado ;)

¿Que es el patrón de diseño?

En palabras simples es una forma o estilo solución para un problema dado o conocido en la creación de software. Estos patrones son soluciones probadas por lo que en vez de ponerse uno a solucionar un problema desde 0, puede usar uno de estos patrones ya creados.

Existe el libro maestro, un tanto antiguo  pero de todas formas es considerado un biblia, el libro es conocido como GoF o Gang-Of-Four ("La banda de los Cuatro" seguramente por que lo escribieron 4 autores). Se puede comprar acá por casi 40 dólares, está en ingles:
http://www.amazon.com/Design-Patterns-Object-Oriented-Addisonwesley-Professional/dp/0201633612
o bajarlo de http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf

¿Que es el patrón de diseño Observer?

Es un patrón clasificado dentro del grupo de comportamiento (hay 3 tipos de patrones) que permite que un objeto X le avise a N subscriptores de algún cambio de estado. De esta forma los subscriptores no tienen que preguntar eternamente por algún cambio sino que el objeto X, ahora llamado Sujeto, le informa su cambio a los subscriptores, ahora llamados Observadores. Además de realizarse una sincronización de todos los observadores con ese valor.

Si separamos un poco la estructura tenemos estos 5 elementos:
  • Un Sujeto: es una clase abstracta (por lo que otra clase heredará de ella y la utilizará), permite básicamente 3 cosas, registrar o subscribir un observador, de-suscribirlo, notificar a los observadores de algún cambio. 
  • Un Sujeto real o Sujeto concreto: Es objeto real con el cual se trabajará desde otras clases, por lo que hereda de Sujeto y utiliza sus métodos.
  • Un Observador: Es una interfaz (en el código será IObservador) que contiene las acciones que puede realizar un Observador real. Por ahora, solo tiene una acción: Actualizar(valor) por pantalla. Ojo que al ser una interfaz, no implementa esta acción, solo las declara.
  • N Observadores reales o concretos: Estas son objetos que representan tus clases propias, como Cliente, Producto, etc. Esta clase implementa la acción Actualizar(valor) de la interfaz Observador. Puse N ya que es sólo 1 una clase en verdad, pero puedes tener N instancias de ella en el programa principal que hará el llamado a crear estas instancias.
  • Programa o main: a manera de ejemplo la tenemos, en su caso puede que tengan una clase de negocio o algo más complejo.
Algunos novatillos se preguntarán por qué esta estructura, o porque 5 objetos y no 4 o 2. Resulta que los patrones se basan mucho en una estructura de herencia de clases por lo tanto se busca especializar mucho los objetos. Por ejemplo si el objeto es genérico, se declara como Abstracto. Si queremos definir su comportamiento pero no implementarlo inmediatamente usamos Interfaces. No podemos usar una misma clase para todo ya que no estamos frente a una programación estructurada sino a una programación orientada a objetos.

He comparado el modelo de clases de diferentes artículos o libros y la base es la misma, pero varia un poco entre cada una de ellas. Nosotros haremos nuestra propia versión que tiene la base del modelo indicado en el libro "Gang of Four":

Modelo de clases según Wikipedia en inglés.

Modelo de clases según Wikipedia en español.

Modelo de clases según libro "Gang of Four".

Nuestro modelo que implementaremos, vista Diagrama de clases de Visual Studio 2012.

Dejando la cháchara, vamos a meter los dedos.

Metiendo los deditos

El 1er. objeto crear es Observador, que es una interfaz que le llamaremos IObservador:

using System;

namespace ConsoleApplication1
{
    // Observador es una interfaz que define que método que el ObservadorConcreto debe implementar
    interface IObservador
    {
        void Actualiza(string valor);
    }
}

El 2do. elemento es la clase Observador concreto o real que implementará el método Actualiza de la interfaz. Define una variable valor que es compartido por el resto de los otros Observadores concretos y que debe sincronizarse en caso de un cambio por parte del Sujeto con tal de que todos los Observadores tengas el mismo valor:

using System;

namespace ConsoleApplication1
{
    // Esta clase es tu clase "producto", "cliente" o como le llames, yo le 
    // puse así ya que conceptualmente es un Observador real que implementa 
    // el método definido en la interfaz. 
    // Tiene la propiedad compartida por el resto de los observadores (en este 
    // caso una propiedad llamada Valor) y que es la que los otros 
    // observadores quieren 
    // monitorear, también actualiza su valor e imprime por pantalla el 
    // cambio si el Sujeto le dice que lo haga.
    class ObservadorContreto: IObservador
    {
        string nombre;
        string valor = "0"; //por defecto

        //Constructor: definimos un nombre para el observador real
        public ObservadorContreto(string nombre)
        {
            this.nombre = nombre;
        }

        // Notifica y actualiza el nuevo valor en este ObservadorConcreto 
        // e imprime en pantalla.
        public void Actualiza(string valor)
        {
            // Actualizamos el valor con tal de sincronizar
            this.valor = valor;
 
            Console.WriteLine("Se notifica a {0} que Sujeto ha cambiado 
            el Valor a {1}", nombre, valor);
        }
    }
}

El 3er. elemento es la clase Sujeto, que es abstracta, y usa métodos del Observador concreto creado recientemente:
using System;
using System.Collections;

namespace ConsoleApplication1
{
    // Clase abstracta que almacena una colección de observadores subscritos 
    // y los notifica de algún cambio, le dice a cada ObservadorConcreto 
    // subscrito que actualize el valor e imprima en pantalla el cambio.
    // Es responsabilidad de cada ObservadorConcreto imprimir en pantalla, 
    // pero es responsabilidad del Sujeto indicarles a ellos que lo hagan.
    abstract class Sujeto
    {
        ArrayList coleccionObservadores = new ArrayList();
        
        public void RegistraObservador(ObservadorContreto observador)
        {
            coleccionObservadores.Add(observador);
        }

        public void DesRegistraObservador(ObservadorContreto observador)
        {
            coleccionObservadores.Remove(observador);
        }

        public void NotificaAObservadores(string valor)
        {
            foreach (ObservadorContreto observadores in coleccionObservadores)
            {
                observadores.Actualiza(valor);
            }
        }      
    }
}

El 4to. elemento es la clase Sujeto concreto o real, que hereda de Sujeto:
using System;

namespace ConsoleApplication1
{
    // Clase real que implementa el Sujeto. Esta clase es usada para 
    // indicar que cualquier cambio afecta a las otros observadores
    class SujetoContreto: Sujeto
    {
        public void CambiaValor(string valor)
        {
            NotificaAObservadores(valor);
        }
    }
}

El 5to. y último elemento es la clase Programa o Main, que utiliza la clase SujetoConcreto para registrar Observadores y cambiar un valor que se replicará o sincronizará en cada uno de ellos y se notificará en pantalla. Luego de des-registran 2 Observadores y cambia de nuevo el valor para ver a quien informa:
using System;

namespace ConsoleApplication1
{
    class Programa
    {
        static void Main(string[] args)
        {
            SujetoContreto sujetoConcreto = new SujetoContreto();

            // Creamos 4 observadores concretos o "sapos"
            ObservadorContreto observdor1 = new ObservadorContreto("Sapo1");
            ObservadorContreto observdor2 = new ObservadorContreto("Sapo2");
            ObservadorContreto observdor3 = new ObservadorContreto("Sapo3");
            ObservadorContreto observdor4 = new ObservadorContreto("Sapo4");

            // SujetoConcreto le dice a Sujeto que agrege un nuevo 
            // ObservadorConcreto a su colección. Esto lo hace el Sujeto 
            // sin derivarle esta tarea a nadie más
            sujetoConcreto.RegistraObservador(observdor1);
            sujetoConcreto.RegistraObservador(observdor2);
            sujetoConcreto.RegistraObservador(observdor3);
            sujetoConcreto.RegistraObservador(observdor4);

            // Por medio de SujetoConcreto decimos que cambiará el valor, 
            // pero lo que por abajo pasa es que el SujetoConcreto 
            // le dice al Sujeto 
            // que actualice el valor, y el Sujeto lo 
            // que hace es decirle a cada ObservadorConcreto que lo haga
            sujetoConcreto.CambiaValor("10");            

            Console.WriteLine("");

            // Sacamos a 2 ObservadoresConcretos, dejando solo a 2. 
            // Esto lo hace el Sujeto en verdad sin darle la tarea a nadie más
            sujetoConcreto.DesRegistraObservador(observdor3);
            sujetoConcreto.DesRegistraObservador(observdor4);

            // Hacemos otro cambio de valor
            sujetoConcreto.CambiaValor("20");

            Console.Read();
        }
    }
}

Salida

La salida del test  nos da:

Se notifica a Sapo1 que Sujeto ha cambiado que el Valor a 10
Se notifica a Sapo2 que Sujeto ha cambiado que el Valor a 10
Se notifica a Sapo3 que Sujeto ha cambiado que el Valor a 10
Se notifica a Sapo4 que Sujeto ha cambiado que el Valor a 10

Se notifica a Sapo1 que Sujeto ha cambiado que el Valor a 20
Se notifica a Sapo2 que Sujeto ha cambiado que el Valor a 20

Descarga de ejemplo

jueves, 14 de febrero de 2013

Como certificarse en Microsoft .Net para Chilean people (Febrero 2013)

Hola a todos los chilenos, esta es mi primera entrada, ahí vamos.

Como computín de profesión, muchos hemos tratado de certificarnos en alguna materia, en esta primera entrada explicaré como se hace una Certificación de un producto Microsoft en Chile, desde que examen tomar hasta sentarse en la sala todo tiritón a darlo, que páginas visitar, donde ir físicamente, etc., según mi punto de vista en los exámenes que he dado (muchos...solo 2 hasta la fecha, 70-562 y 70-515 con este último ya pasé a ser un "MCTS guy"), ya que esta información no está muy clara cuando partes en esto.

Vamos Step by Step como la canción de los New Kids:

I. Preparación y Estudio


1. En que quiero certificarme. Lo primero es escoger un producto que quieres certificarte, en mi caso escogí el Framework 3.5 de Microsoft .Net, estaba de moda cuando se trabajaba con el Visual Studio 2008. Actualmente saben que el que la lleva es el VS 2012, hay que ser pro' no se queden en el pasado.

2. Investigar Road Map. Buscar en la web el  Road Map de certificaciones para ese línea, yo lo encontré buscando mucho ya que como sabrán en http://www.microsoft.com les encanta esconder todo y cuesta en verdad dar con lo que uno busca:
http://download.microsoft.com/download/B/6/6/B66B006F-50AB-493E-BEBE-FD3B1BF548F6/VisualStudio2008_CertPath.pdf

Road Map para Visual Studio 2008:

Para Visual Studio 2010 el camino es un poco más corto:
Para Visual Studio 2012 con el Framework 4.5 y SQL 2012:

Por ejemplo, para quienes les gustaría certificarse en SQL 2008 este es el camino:


3. Selección. En mi caso quiero dar el examen titulado 70-562: TS: Microsoft .NET Framework 3.5, ASP.NET Application Development.

4. Buscar las posibles dependencias del Examen, en mi caso dependía de otro examen: 70-536: TS: Microsoft .NET Framework, Application Development Foundation.

5. MCTS, MCP y MCPD. MCTS valida tu expertiz técnica de cierta área. MCPD valida tu experiencia en todo un ámbito .Net. En el Framework 3.5 con los 2 exámenes aprobados te conviertes en un MCTS (Microsoft Certified Technology Specialist), ahí recién te puedes pegar las quebradas con tus friends.
También en esta versión del Framework debes dar 3 exámenes para ser un caperuso, me refiero a ser un Microsoft Certified Professional Developer (MCPD).
Con la versión del Framework 4, ahora sólo con 1 examen ya eres MTS!!, pero ahora debes dar 4 para ser un MCPD (una por otra).

También, con un solo examen que des y lo apruebes, ya eres considerado del grupo de los MCP (Microsoft Certified Professional) de forma no oficial, pero si te da algo de respeto en tus pares. Con un examen que des ya puedes entrar a un sitio "exclusivo" para gente certificada en http://www.microsoft.com/mcp (cursos, ofertas, etc y lo mejor es que puedes imprimir tu tarjeta de presentación Microsoft donde sale tu nombre y que eres MCTS, super pro!!).
Al entrar el sitio de MCP te pedirá acceder con tu cuenta de correo de Microsoft. 
Ingresas como de costumbre. 
Acceder al sitio de Microsoft MCP donde aparecerán tus "medallitas".
Este era el antiguo sitio de Microsoft MCP.
Puedes descargar tu certificado como PDF o XML para ponerlo enmarcado en un cuadrito en tu murallita. O puedes pagar $9.95 USD para que te lo envíen enmarcado directamente desde Redmond :P
Puedes descargar los logos oficiales ("Certification logos") para colocarlos en algún Word o documento para decirle a otros que eres certificado.
Puedes crear tarjetas virtuales("Virtual business cards") con tu nombre, cargo, correo, avatar (foto), donde el resultado final es un enlace rápido a todo lo ingresado con interfaz de tarjeta. No encontré la opción de generar una tarjeta física, para cuando te pregunten "dame tu número", y tu abres tu billetera y le pasas todo creído tu nueva tarjeta.

Con VS 2010 con sólo dar el examen 70-515: TS: Web Applications Development with Microsoft .NET Framework 4 ya eres un MCTS ya que compactaron la información en un sólo examen (yupi!, aunque para algunos es más complicado ya que metieron todo en un solo libro).

Los examen se pueden dar en cualquier orden, en mi caso primero di 562 y luego iba a dar el 536 (al final no lo di por flojera, hay que decir las cosas por su nombre), pero si prefieres dalos al revés. Ahora, por contenido se recomienda dar primero el 536 y luego el 562. Pero bueno, en cosa de gustos.

7. Estudiar. Solo debes estudiar, estudiar, estudiar!! Hay mucho material para estudiar. Listemos algunos:


7.1. El libro (o libros) oficial siempre es lo principal. Tienes 2 opciones, o lo compras o lo bajas. Si lo compras por http://www.amazon.com/ está a 15 dolares promedio el 70-562 más envío unos 15 más...mas impuesto por el peso...mmm...en promedio se gastan entre 25 a 30 mil pesos por estos libros que te tras de USA.
Si prefieres bajar, busca por http://www.google.cl/ el libro en formato PDF: basta buscar "70-562 pdf" o "70-536 pdf" o el código del examen que buscar. Hay muchos sitios que lo tienen. Personalmente prefiero el PDF.

 
Libros oficiales para el Framework 3.5. En general tienen en promedio 1000 pág.




Libro oficial para Framework 4. Un solo libro yupiii.

7.2 Estos libros oficiales vienen con un CD y en ese CD viene una herramienta muy conocida en el mundillo de las certificaciones Microsoft: Training Kit Exam Prep, aquí puedes auto examinarte ya sea por objetivos del libro (más fáciles) o preguntas al estilo certificación (más peludas):

Imagen referencial.
7.3 Bajar el programa Visual CertExam Manager desde http://www.avanset.com/products/visual-certexam-suite.html ya que permite cargar exámenes (archivos .VCE) con preguntas y respuestas, y auto probarse. La página ofrece un Trial y la versión pagada por 25 dólares. También está en Taringa y otros sitios versión "alternativa"...uds. me entienden...

Los exámenes (archivos .VCE) se bajan desde:


7.4 Test King y otros sitios que venden PDF. Hay sitios que te venden packs de preguntas cercanas a la realidad del examen, en formato PDF. Entre las más conocidas está: http://www.testkings.com (más o menos caro, en promedio 100 dólares 252 preguntas y respuestas) y http://www.braindumps.com (más barateli, promedio 20 dólares 119 preguntas y sus respuestas).
También está la opción alternativa de bajar PDF con preguntas desde Google, por ejemplo si buscas "70-562 questions pdf" aparecerán algunos sitios interesantes.

II. Programar y Pagar el examen


1. Lugar. Buscar donde darlo físicamente en nuestro Chilito. Para esto lo mejor es entrar a un sitio internacional que administra y programa las fechas y lugares de los exámenes: http://www.prometric.com
El problema es que los ñoños, no hicieron un lógin fácil de ver y entrar, así que no queda mas que entrar a la mala con la URL: https://www.register.prometric.com/Login.asp
A la derecha se puede uno registrar o ingresar si ya tienes un Login (que es un email).

2. Registro. Al registrarse debes anotar el Prometric ID. La idea de este código es que todos tus exámenes se mantengan bajo ese número, así si das en el futuro otros mas, le das ese número y estos exámenes se acumulan ahí, incluso los exámenes los das en lados físicos diferentes.


3. Programar el examen. Debes programar tu examen haciendo clic en Schedule An Exam y luego escogiendo el País Chile, Provincia: None (gringos...):
Luego seleccionar "Schedule An Exam"

Escoger Cliente y código. En nuestro caso el cliente es Microsoft y el código un 70 (en mi caso 70-562):

Microsoft te da la bienvenida...Next.

Hora de apretarse lo bolsillos, ver el costo del examen que en mi caso es 100 dolares (en su momento el año 2011 estaba a 80 dolares que fue lo que pagué, todo sube papá). Abajo está la opción de pagarlo en peso chileno que a la fecha son 51 mil pesos.

Escoger la ubicación física donde darlo, aquí en Chilito tenemos 6 lugares para darlo, algunos en el centro de la capital y otros en el sector oriente. Es muy común darlo en New Horizon al ladito de Sonda en Teatinos o en Golden Training en calle Huérfanos:

Si pinchas en Seat Availability en alguno de los lugares puedes ver la fecha y la hora en que hay disponibilidad. No agendas nada, solo es un vistazo ("sapeo") a las fechas/horas. Dale a Back:

En Schedule Appointment está de nuevo el calendario y las fechas. Ahora también dice la duración del examen en este caso 4 horas (ufff) y puedes escoger la fecha que quieras.

El último paso es pagar en una vista de resumen. Por lo que usa alguna tarjeta de pago internacional como VISA, MASTERCARD o AMERICAN EXPRESS. Ya les dije que sale en promedio unos 100 dolares las certificaciones de Microsoft, el resto uds. mismos pueden verlas en la página:

Al finalizar te llegará un mail con el resumen y confirmación de todo el proceso.

III. Enlaces Interesantes



Bueno, esto es todo, espero les haya quedado claro ahora y se certifiquen ya que en general son pocos los que lo intentan, y de los que lo intentan, sólo unos pocos logran certificarse. Las veces que me ha tocado participar, de 10 personas interesadas se certifica sólo 1 o 2, ya me ha pasado 2 veces. Hay que decirlo, acá en Chile somos muy flojos para estudiar (por no decir una palabra muy fea: pajeros, ups. lo dije), es la pura verdad.