El alegre bandolero...

[CatDotNet] Dices tu de nServiceBus…

José Miguel Torres — Wed, 24 Feb 2010 22:33:36 GMT

Buenas!! Pues el próximo viernes 26 de febrero tendremos el placer de contar en Igualada con Sergio Bermudez quién nos presentará lo bueno y lo malo –si es que lo hay- de nServiceBus del amigo Udi Dahan, y cuyo pretexto utilizaremos para tomar, a posteriori, unos cacharros entre amigos y saber más sobre los ESB (ver foto).

Así que si estás por las cercanías, ¡¡te esperamos!!

Virtualización de Servicios con Managed Services Engines

José Miguel Torres — Thu, 04 Feb 2010 07:57:00 GMT

Desde mis primeras incursiones en el desarrollo de Servicios empresariales, básicamente desde la aparición de las primeras betas de WCF, ha habido un miedo escénico que me ha atormentado y es la programación déspota e incontrolada de servicios, servicios y más servicios, lo que deriva en la producción de 300 servicios, con 300 enlaces distintos (no más de 10 comunes), en 50 endpoints y cuyo valor operativo era equivalente a 50 servicios bien diseñados y gobernados. No concebía una arquitectura sólida de servicios sin una “torre de control” o una “cabina de mando” desde dónde poder ver, gestionar y modificar nuestros servicios.

Más adelante tuve la oportunidad de trabajar en una arquitectura SOA desarrollada en J2EE, dirigida por un ESB de Oracle y gestionada con herramientas de gobernabilidad SOA, que manejaban más de un centenar de servicios (proxy y legacy) y dónde la publicación y consumo de dichos servicios se realizaban a través de estrictas normas protocolarias (seguridad, documentación,…).

Ahora vuelvo, de nuevo, a tener la misma necesidad, diseñar una infraestructura de servicios y cuando hablo de infraestructura hablo de ese tipo de herramientas fundamentales para el control de todos y cada uno de los servicios. Pero ahora (en realidad hace ya un tiempo que existe) me encontré con un software, bajo licencia Microsoft Public License (Ms-PL) y código abierto, que adopta de forma práctica la idea de Virtualización de Servicios, llamado Managed Services Engine.

Virtualización de Servicios

La idea básica del patrón de Virtualización de Servicios es el de aislar la complejidad de los servicios expuestos del cliente que los consume ya que tras cada servicio se alberga una gran cantidad de aspectos tales como las localizaciones de los endpoints, las configuraciones de los enlaces, la aplicación de políticas, etc. Además muchas de las adopciones SOA a la practica no ofrecen soluciones sobre versionado de servicios, aplicación de políticas de seguridad o cambios operativos sin necesidad volver a codificar el servicio así como el cumplimiento del SLA entre el proveedor –nosotros- y el cliente.

Aparece la idea de Servicio Intermediario que desacopla el cliente de la implementación del servicio. Como tal, podemos ofrece varios servicios virtuales de una misma implementación para, por ejemplo, utilizarlo en distintos escenarios. Es aquí dónde encontramos la clave de la virtualización, en el servicio intermediario, pues todas las llamadas se realizaran a través de este y podremos modificar su comportamiento sin comprometer los modelos del servicio.

Managed Services Engine

Microsoft Services SOA Infraestructure ofrece una solución de virtualización de servicios a través de Managed Services Engine (MSE). Como cabe esperar, MSE está basado en la plataforma Windows, esto es, Windows Server 2003/2008, SQL Server 2005/2008 y .NET Framework 3.5, especialmente con Windows Communication Foundation para la interceptación de comunicaciones entre servicios virtuales y reales.

MSE puede integrarse tanto con MS Biztalk Server 2006 R2 / 2009 para proporcionar capacidades adicionales tales como la monitorización de las actividades de negocio (BAM), el Business Rules Engine o el ESB Toolkit, entre otros. Además también podemos utilizar los servicios Azure a través de Azure AppFabric, especialmente con .NET Service Bus.

MSE consiste, básicamente, en tres componentes:

Messenger: proporciona la normalización del mensaje de entrada a través de los servicios virtuales. Este componente soporta además la aplicación de políticas (de transformación por ejemplo, tanto de peticiones como de respuestas) así como el mapeo de protocolos.
Broker: este componente obtiene el mensaje normalizado y lo reconvierte a la operación (es decir la implementación de un método del servicio) y su respectiva versión (pues podemos tener más de una operación con distintas versiones).
Dispatcher: una vez se tiene el mensaje y la operación pertinente, dispatcher invoca el método del servicio y se transmite dicho mensaje.

Recalcar que estos tres componentes están totalmente desacoplados unos de otros con lo que podríamos distribuirlos de forma que obtendríamos una gran cantidad de tipologías del sistema. Todo esto es gracias a la catalogo del servicio (Service Catalog), también conocido como repositorio de metadata o simplemente repository o repositorio, ya que contiene todos los modelos de los servicios que hospeda el runtime del MSE –incorpora asistentes para la importación de servicios a través del WSDL y otros mecanismos para servicios POX o REST-. Como dije anteriormente, MSE contiene una implementación de WCF así que es fácil intuir que la comunicación entre ellos se realizan a través de canales de mensajería. El repositorio, por último, utiliza una base de datos SQL Server y la información puede ser publicada en un registry externo UDDI 2.0/3.0.

Por último, MSE contiene una interfaz para la administración de los servicios –MSE Model Viewer- así como una herramienta de test –MSE Universal Service Tester-.

En próximos posts hablaré de las diferentes posibilidades que ofrece MSE desde el punto del vista del rol (developer, IT, architect,…) y como familiarizarse MSE.

[CatDotNet] Eduard Tomàs hablando sobre ASP.NET MVC en Igualada? Comorrr?

José Miguel Torres — Tue, 26 Jan 2010 15:11:00 GMT

Pues sí, Eduard Tomàs, habitual y conocido de geeks.ms y de CatDotNet así como en presentaciones MSDN de Microsoft Ibérica , nos presenta este viernes en Igualada las bondades de ASP.NET MVC.

Si estáis por la zona no dudéis en asistir!!!

Lugar: Sala Ig-Nova Tecnospai. Av. Barcelona núm. 105 (Igualada) a las 19h.

Ver mapa más grande

Inicialización con System.Lazy en .NET Framework 4.0

José Miguel Torres — Thu, 21 Jan 2010 12:11:00 GMT

Una de las novedades de .NET Framework 4.0 es la presentación de la clase System.Lazy<T>. En programación, una inicialización Lazy (el término Lazy significa, literalmente, gandul o retardado) es un método de inicialización que permite que el objeto no se instancie hasta que se llame por primera vez, es decir hasta que sea utilizado. En el ciclo de vida de una aplicación, los métodos y propiedades de una clase que componen existen, es decir se instancian en memoria y permanecen ahí desde la creación hasta que la destrucción de la clase.

Una clase Customer dónde el constructor carga una lista genérica de Order –inicializa un objecto List<Order> – éste permanece en memoria pese a que incluso es posible que ni siquiera lo necesitemos. Hasta .NET Framework 4.0 la implantación de este tipo de inicializaciones se realiza mediante programación retrasando la inicialización de un objeto hasta que realmente se necesitara; en el caso de la clase Customer, por ejemplo, instanciaríamos el objeto List<Order> en un método LoadOrders() o GetOrders(), por ejemplo. En el caso de multithreading, la cosa se complica aún más y a veces el planteamiento o diseño de la clase no es suficiente.

Como novedad esta característica ya forma parte en .NET Framework 4.0 a través de System.Lazy<T> y aporta soporte Thread-Safety y una política de propagación de excepciones consistente para dar soporte al multithreading.

A partir de ahora nos olvidaremos de las técnicas anteriores y utilizaremos System.Lazy<T> para inicializaciones perezosas. Veamos un ejemplo:

   1: static void Main(string[] args)

   2: {

   3:     Lazy<string> cadena = new Lazy<string>(delegate

   4:                                                 {

   5:                                                     return "Ejemplo Lazy";

   6:                                                 });

7:

   8:     Console.WriteLine(string.Format("isValueCreated: {0}", cadena.IsValueCreated));

   9:     //podemos ejecutar cualquier acción y no se ejecutará hasta...

  10:     Console.WriteLine(string.Format("Value calling: {0}", cadena.Value));

  11:     //... que no llamemos al valor

  12:     Console.WriteLine(string.Format("isValueCreated: {0}", cadena.IsValueCreated));

13:

  14:     Console.Read();

  15: }

El constructor de System.Lazy<T> soporta las siguientes sobrecargas:

   1: public Lazy();

   2: public Lazy(Func<T> valueFactory);

   3: public Lazy(bool isThreadSafe);

   4: public Lazy(Func<T> valueFactory, bool isThreadSafe);

El parámetro isThreadSafe se establecerá a true cuando necesitemos utilizar el objeto de forma concurrente por multiples threads, con valor predeterminado a false.

El parámetro valueFactory es un delegado del tipo Func<T> y será el encargado de inicializar el valor del objeto Lazy. Un ejemplo, además del expuesto en el ejemplo anterior, podría ser:

   1: public class Order {}

2:

   3: public class OrderDb

   4: {

   5:     public static List<Order> GetOrdersBy(string idCustomer)

   6:     {

   7:         return new List<Order>

   8:                    {

   9:                        new Order(),

  10:                        new Order(),

  11:                        new Order()

  12:                    };

  13:     }

  14: }

15:

  16: public class Customer

  17: {

  18:     public Lazy<List<Order>> _orders;

19:

  20:     public Customer(string id)

  21:     {

  22:         //inicialización Lazy

  23:         _orders =new Lazy<List<Order>>(() =>  OrderDb.GetOrdersBy(id) );

  24:     }

  25: }

Con el siguiente programa de consola:

   1: class Program

   2: {

   3:     static void Main(string[] args)

   4:     {

   5:         Customer customer = new Customer("10");

6:

   7:         //pese a que customer se ha incializado la Lista de Orders aún no:

   8:         Console.WriteLine(string.Format("isValueCreated: {0}", customer._orders.IsValueCreated));

   9:         //Solicitamos las ordenes

  10:         Console.WriteLine(string.Format("calling Value.Count: {0}", customer._orders.Value.Count));

  11:         //Ahora si se han instanciado

  12:         Console.WriteLine(string.Format("isValueCreated: {0}", customer._orders.IsValueCreated));

13:

  14:         Console.Read();

  15:     }

  16: }

Cuya salida será:

Es importante tener en mente este tipo de inicializaciones sobre todo en procesos de mucho consumo de recursos, por ejemplo objetos de la capa de datos que almacenan datos binarios – imagen, video,- y que muchas veces no necesitamos que consuman memoria si no se van a utilizar. Como este ejemplo, muchos más…

Ejemplo de Sync entre Oracle y SQL Server Compact

José Miguel Torres — Tue, 05 Jan 2010 11:51:00 GMT

Publicado en MSDN Code Gallery nuevo ejemplo de entorno de sincronización para orígenes de datos Oracle 10g o superior con SQL Server Compact en modo peer-to-peer. Lo más destacado de este ejemplo es el modo de creación del proveedor específico para Oracle a través de la clase DbSyncProvide. Peses a que el ejemplo utiliza SQL Server Compact, podemos hace uso tanto del nuevo proveedor específico para SQL Server Express, incluido en MS Sync Framework 2.0, como SQL Server.

Al pan Enum y al vino Flags

José Miguel Torres — Sun, 15 Nov 2009 23:06:00 GMT

Mientras preparaba el material para el WebCast que di para el dotNet Club de la U. Lleida, me tope con enumeradores como marcadores de bit y quiero comentar lo útil que pueden llegar a ser.

Básicamente tenemos dos opciones o características que determinan el comportamiento de este tipo de dato constante y se basa en el uso o no del atributo FlagAttribute sobre el Enum. Es importante entender que dicho atributo será especialmente útil cuando necesitemos que los valores del enumerador se combinen a través de operaciones lógicas o bit a bit del tipo AND, OR, NOT y XOR.

Un ejemplo de típica declaración de enumeradores seria:

   1: public enum TypicalEnums

   2: {

   3:     Option1, // = 0x00

   4:     Option2, // = 0x01

   5:     Option3, // = 0x02

   6:     Option4, // = 0x03

   7:     Option5, // = 0x04

   8:     Option6  // = 0x05

   9: }

En este ejemplo, damos por supuesto que una variable de tipo TypicalEnums únicamente podrá contener un único valor, cuyo tipo subyacente es por defecto es int. Sin embargo el siguiente enumerador:

   1: [Flags]

   2: public enum FlagEnums

   3: {

   4:     Option0 = 0x00,     // 0 = 0x00

   5:     Option1 = 0x01,     // 1 = 0x01

   6:     Option2 = 0x01 << 1,// 2 = 0x02

   7:     Option3 = 0x01 << 2,// 4 = 0x04

   8:     Option4 = 0x01 << 3,// 8 = 0x08

   9:     Option5 = 0x01 << 4,//16 = 0x16

  10:     Option6 = 0x01 << 5 //32 = 0x32

  11: }

Nos permitirá tener varios valores dentro de una misma variable del tipo FlagsEnums.

En el primer caso podremos hacer por ejemplo:

Cliente.Tipo = TypicalEnums.Option1 | TypicalEnums.Option2

Pero no tendrá ninguna repercusión pues Cliente.Tipo almacenará el valor 1 (TypicalEnums.Option1), pero sin embargo la siguiente sentencia:

Cliente.Caracteristicas = FlagEnums.Option2 | FlagEnums.Option5,

Si que almacenará ambas opciones.

Fijaros que en la declaración de FlagsEnum hemos indicado explícitamente el valor de las opciones de tres formas, desplazando un bits a la izquierda en base al valor 0x01, con valores numéricos decimales y valores hexadecimales. Todos ellos tendrán la siguiente correspondencia en binario:

Option0 = 0000000
Option1 = 0000001
Option2 = 0000010
Option3 = 0000100
Option4 = 0001000
Option5 = 0010000
Option6 = 0100000

A partir de aquí todo lógica. Si en el anterior ejemplo asignamos FlagsEnum.Option2 y FlagsEnum.Option5 al campo Cliente.Característica el valor que almacenará será 7 es decir 2 + 5, y por tanto utilizaremos el operador lógico OR:

   1: Cliente cliente = new Cliente

   2:                       {

   3:                           IdProvincia = 1,

   4:                           Tipo = TypicalEnums.Option1,

   5:                           Caracteristicas = FlagEnums.Option2 | FlagEnums.Option5,

   6:                           //Caracteristicas = 00000010        | 00001000           = 00001010

   7:                           Nombre = "Cliente 1",

   8:                           VolumenNegocio = 10.0m

   9:                       };

Ahora bien,¿cómo podemos sacar el máximo provecho de los enumeradores con marcadores de bit? pues aplicando lógica, es decir, si queremos saber si un marcador se ha establecido utilizaremos AND:

   1: if ((cliente.Caracteristicas & FlagEnums.Option5) == FlagEnums.Option5)

   2:     // (00001010 & 00001000) = 00001000

   3:     //             00001000  = 00001000 => true

   4:     Console.WriteLine("{0}: \nFlagEnum \t[{1}] \nOption 5 \t[{2}] \nHence: \t\t[{3}]",

   5:                       cliente.Nombre,

   6:                       Convert.ToString(((int)cliente.Caracteristicas), 2),

   7:                       Convert.ToString(((int)FlagEnums.Option5), 2),

   8:                       Convert.ToString((int)(cliente.Caracteristicas & FlagEnums.Option5), 2));

Como puedes ver, en la condición de la sentencia if estamos comprobando la existencia de FlagsEnums.Option5 de forma lógica. Realizamos la operación lógica a nivel de bit de Cliente.Característica AND FlagsEnums.Option5 e igualamos al valor de FlagsEnums.Option5. Por otro lado:

   1: if ((cliente.Caracteristicas & FlagEnums.Option4) != FlagEnums.Option4)

   2:     // (00001010 & 00000100) = 00000100

   3:     //             000000000 = 00000100 => false

   4:     Console.WriteLine("Cliente with \nFlagEnum \t[{0}] \nhasn't Option 4 \t[{1}]",

   5:         Convert.ToString(((int)cliente.Caracteristicas), 2),

   6:         Convert.ToString(((int)FlagEnums.Option4), 2));

Si queremos comprobar FlagsEnums.Option4, el cual no está, el razonamiento será el mismo (fíjate en las líneas 2 y 3). Tras ejecutar ambos Snippets con la clase Cliente definida como:

   1: public class Cliente

   2: {

   3:     public int IdProvincia { get; set; }

   4:     public TypicalEnums Tipo { get; set; }

   5:     public FlagEnums Caracteristicas { get; set; }

   6:     public string Nombre { get; set; }

   7:     public decimal VolumenNegocio { get; set; }

8:

   9:     public override string ToString()

  10:     {

  11:         return string.Format("Cliente: {0} - Provincia:{1} - \nTipo: {2} - Caract:{3} - Vol.:{4}e\n",

  12:                              Nombre, IdProvincia, (int) Tipo,Caracteristicas, VolumenNegocio);

  13:     }

  14: }

Obtendremos:

Por último, si pretendemos quitar un marcador ya establecido utilizaremos un XOR de forma que:

cliente.Caracteristicas = cliente.Caracteristicas ^ FlagEnums.Option5;

Desasignaría FlagsEnums.Option5 al campo Cliente.Características.

Uso de métodos extensores

Soy un auténtico fan de este tipo de característica y no puedo dejar pasar ni un solo enumerador de marcadores de bit sin extender el típico método HasFlag o como_queráis_llamarlo a la clase que los utiliza, siempre y cuando sea posible, y por tanto una forma de extender la clase Cliente para la comprobación de marcadores seria la que he utilizado para confeccionar el ejemplo de este post, es decir:

   1: public static class ClienteExtensions

   2: {

   3:     public static string HasFlagVerbose(this Program.Cliente cliente, Program.FlagEnums flag)

   4:     {

   5:         return string.Format("Checking {2} for {0}: \nCaracteristica \t[{1}] \n{2} \t[{3}] \nHence \t\t[{4}]\n",

   6:                              cliente.Nombre,

   7:                              Convert.ToString(((int)cliente.Caracteristicas), 2).PadLeft(8, '0'),

   8:                              flag,

   9:                              Convert.ToString(((int)flag), 2).PadLeft(8, '0'),

  10:                              Convert.ToString((int)(cliente.Caracteristicas & flag), 2).PadLeft(8, '0'));

  11:     }

12:

  13:     public static bool HasFlag(this Program.Cliente cliente, Program.FlagEnums flag)

  14:     {

  15:         return (cliente.Caracteristicas & flag) == flag;

  16:     }

  17: }

Con lo que el cuerpo del programa que he ejecutado para mostrar los resultados seria:

   1: public class Program

   2:     {

3:

   4:         static void Main(string[] args)

   5:         {

   6:             Cliente cliente = new Cliente

   7:                                   {

   8:                                       IdProvincia = 1,

   9:                                       Tipo = TypicalEnums.Option1,

  10:                                       Caracteristicas = FlagEnums.Option2 | FlagEnums.Option5,

  11:                                       //Caracteristicas = 00000010        | 00001000           = 00001010

  12:                                       Nombre = "Cliente 1",

  13:                                       VolumenNegocio = 10.0m

  14:                                   };

15:

  16:             //comprobamos q realmente tiene FlagEnums.Option5

  17:             if ((cliente.HasFlag(FlagEnums.Option5)))

  18:                 Console.WriteLine(cliente.HasFlagVerbose(FlagEnums.Option5));

19:

  20:             //comprobamos q realmente NO tiene FlagEnums.Option4

  21:             if (!(cliente.HasFlag(FlagEnums.Option4)))

  22:                 Console.WriteLine(cliente.HasFlagVerbose(FlagEnums.Option4));

23:

  24:             //quitamos FlagsEnums.Option5

  25:             cliente.Caracteristicas = cliente.Caracteristicas ^ FlagEnums.Option5;

26:

  27:             //comprobamos q hemos quitado FlagEnums.Option5

  28:             if (!(cliente.HasFlag(FlagEnums.Option5)))

  29:                 Console.WriteLine(cliente.HasFlagVerbose(FlagEnums.Option5));

30:

  31:             Console.ReadKey();

  32:         }

  33:     }

A partir de aquí… posibilidades infinitas ;-))

Más info:

http://msdn.microsoft.com/es-es/library/cc138362.aspx

Actualizando HTC Dream de Movistar a Cupcake (Android 1.5)

José Miguel Torres — Sat, 14 Nov 2009 21:58:27 GMT

Pues ejerciendo el falso y sobrevalorado “derecho” de Canje de Puntos después de contribuir durante más dos años a aumentar las arcas de Telefónica para que, cada vez más vayan subsituyendo mano de obra en los departamentos de atención telefónica por maquinaria automática absurda, adquirí el viernes, y no voy a entrar a explicaros todos los pasos que he realizado para conseguirlo, pues empezaría a blasfemar, un HTC Dream tras pagar 239pavos e hipotecar mi futuro dos años con Movistar.

La decisión de compra se debió a que mi flamante HTC HD con Windows Mobile tuvo un pequeño percance. Mi relación con el soporte técnico de HTC no lo detallaré pues convertiría este post en un manifiesto anti-multinacionales tecnológicas.

La cuestión es que tras empezar a utilizar el HTC Dream de Movistar y familiarizarme un poco con Android (gracias al Centro de Soporte Telefónico del Maestro Alejandro Mezcua ;-) ) me cercioré de que la versión de Android que suministra este terminal, además de estar basado en Android 1.1, está algo capada. Por ejemplo, no puedo sincronizar contactos. Manda huevos. Buscando, encontré en http://and.roid.es un post de un tal Rick el cual explicaba paso por paso la actualización del HTC Dream de Movistar a Cupcake con lo que me puse manos a la obra.

Escribo este post para animar a los que no están muy seguros de si actualizar o no. En comparación, tras instalar Android 1.5, encuentro, además de la posibilidad de sincronización de Agenda, Contactos y Correo (menos mal), muchas otras aplicaciones que no vienen de serie, como por ejemplo uso de la Videocámara, además de algún Widget que otro. Además en el propio proceso de actualización se actualiza la radio (firmware), lo cual sí he notado, especialmente en cobertura.

Actualización

Seguid los pasos tal y como indica Rick en su post. Únicamente hay una error en la combinación de teclas que enumera para reiniciar el dispositivo en Fastboot, que es Home+Back en lugar de alt + back. Aseguraros de descargaros todos los componentes antes de todo. La guía hace referencia al SDK del Android 1.5 r1 y la última es la r3, pero es trivial.

Recomendable descargarse el FastBoot desde la Web de HTC e instalarla en un directorio de la raíz, al poder ser dentro de un subdirectorio del SDK pues se tiene que ejecutar desde la línea de comandos. Tras reiniciar el dispositivo en modo FastBoot no te resultará muy difícil seguir las instrucciones pues además de estar en castellano las opciones son claras. Si no quieres reiniciar el dispositivo en varias ocasiones y debido a que tienes que utilizar la SD para copiar los archivos update.zip (del cupcake y del firmware) no estaría de más tener un lector de tarjetas microSD he ir copiando y/o renombrando archivos.

No olvidéis actualizar el firmware. Yo me equivoqué y descargué y renombre un archivo zip de recursos el cual tenia la radio, con lo que tras ejecutarlo con Fastboot me dio un error; únicamente hay que comprimir en update.zip la carpeta radio.

Tras la actualización del cupcake y de la radio, no tuve que hacer nada más si utilizas la ROM de Ricky. El teclado funcionan perfectamente y la conexión APN de movistar viene configurada.

SQL Server –> Sync <- SQL Azure = Proyecto Huron muestra sus cartas!

José Miguel Torres — Wed, 04 Nov 2009 22:19:55 GMT

Ayer se presentó en el SQL Pass Conference, en Seattle, las primeras imágenes del proyecto “Huron” el cual permitirá la sincronización de orígenes de datos SQL Server con SQL Azure.

En breve, Microsoft pondrá a disposición del público la primera CTP así como un add-in para SQL Server Management Studio. La idea es proporcionar un Wizard para la creación de un contexto de sincronización para que posteriormente SQL Agent sea el encargado de ejecutar las sincronización de ambos proveedores.

Probablemente el próximo PDC hayan más noticias.

Aquí van una imágenes.

GroupBy con LINQ to Objects

José Miguel Torres — Thu, 29 Oct 2009 23:05:00 GMT

El agrupamiento de un conjunto de datos mediante LINQ, ya sea mediante la extensión de IEnumerable o IQueryable, tiene una serie de características las cuales me gustaría comentar aquí.

Para explicar un poco las posibilidades del agrupamiento mediante la extensión GroupBy voy a exponer un ejemplo con LINQ to Objects y para ello, primero, definiremos una clase sencilla que represente la entidad Cliente.

public class Cliente
        {
            public int IdProvincia { get; set; }
            public int Tipo { get; set; }
            public string Nombre { get; set; }
            public decimal VolumenNegocio { get; set; }

            public override string ToString()
            {
                return string.Format("\t\t-> Cliente: {0} - Provincia:{1} - Tipo: {2} - Vol.:{3}e\n",
                                     Nombre, IdProvincia, Tipo,VolumenNegocio);
            }
        }

Como se puede observar no es más que una clase con 4 propiedades implícitas y el método ToString() sobrescrito para poder mostrar por la consola la información de un objeto iterado del tipo Cliente.

Vamos a generar una lista de clientes mediante una lista genérica de la siguiente forma:

//inicializamos lista de clientes
var list = new List<Cliente>
               {
                   new Cliente {IdProvincia = 1, Nombre = "Cliente1", Tipo = 10, VolumenNegocio = 100.00m},
                   new Cliente {IdProvincia = 2, Nombre = "Cliente2", Tipo = 20, VolumenNegocio = 20.00m},
                   new Cliente {IdProvincia = 3, Nombre = "Cliente3", Tipo = 20, VolumenNegocio = 230.00m},
                   new Cliente {IdProvincia = 3, Nombre = "Cliente4", Tipo = 20, VolumenNegocio = 500.00m},
                   new Cliente {IdProvincia = 1, Nombre = "Cliente5", Tipo = 30, VolumenNegocio = 10.00m},
                   new Cliente {IdProvincia = 2, Nombre = "Cliente6", Tipo = 10, VolumenNegocio = 750.00m},
                   new Cliente {IdProvincia = 1, Nombre = "Cliente7", Tipo = 20, VolumenNegocio = 340.00m},
                   new Cliente {IdProvincia = 1, Nombre = "Cliente8", Tipo = 20, VolumenNegocio = 170.00m}
               };

La intención es agrupar esta lista de clientes por la provincia, a la cual pertenecen, a través de la propiedad IdProvincia del tipo int. Para ello, en primer lugar, echaremos un vistazo a la extensión GroupBy que incorpora la clase System.Linq.Enumerable. Dicha extensión presenta las siguientes sobrecargas:

public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);

public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
     Func<TKey, IEnumerable<TSource>, TResult> resultSelector);

public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
     Func<TSource, TElement> elementSelector);

public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
     IEqualityComparer<TKey> comparer);

public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
     Func<TKey, IEnumerable<TSource>, TResult> resultSelector,
     IEqualityComparer<TKey> comparer);

public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
     Func<TSource, TElement> elementSelector,
     Func<TKey, IEnumerable<TElement>, TResult> resultSelector);

public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
     Func<TSource, TElement> elementSelector,
     IEqualityComparer<TKey> comparer);

public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
     Func<TSource, TElement> elementSelector,
     Func<TKey, IEnumerable<TElement>, TResult> resultSelector,
     IEqualityComparer<TKey> comparer);

En todas ellas existen un denominador común, el parámetro keySelector del tipo Func<TSource, TElement> que determina el valor de tipo TKey por el cual se agrupara la lista. Por otro lado GroupBy puede retornar un objeto del tipo IEnumerable<TSource> si se especifica el parámetro resultSelector (tipo Func<TSource, TKey>) o bien un objeto del tipo IEnumerable<IGroupingKey<TKey, TElement>> para todos los demás. Vamos centrarnos en éste último por ahora.

Manejando resultados IEnumerable<IGroupingKey<TKey, TElement>>

Si el agrupamiento se realiza sobre una lista de elementos iterativos o “IEnumerables” es obvio que el resultado, otra lista de subelementos agrupados por una clave del tipo TKey, sea otra lista de elementos iterativos de ahí que el tipo resultante sea IEnumerable<T>. La singularidad esta en el tipo genérico en la iteración del valor retornado el cual es del tipo IGroupingKey<TKey,TElement> y vamos a ver el porqué. Lo que LINQ hará ante un GroupBy es realizar un recorrido completo por la lista y seleccionará todos los elementos del tipo TElement de una misma clave (TKey). Por consiguiente el resultado será una lista del agrupamiento de elementos definidos por la interfaz IGroupingKey<TKey,TElement>, en la que almacenará la clave y el conjunto de elemento agrupados por el valor de dicha clave, respetivamente en cada tipo genérico. Veamos un ejemplo.

En nuestra lista de clientes vamos a agrupar los elementos por el identificador de provincia definido por Cliente.IdProvincia. Para ello definiremos una variable del tipo IEnumerable<IGroupingKey<int,Cliente> pues el tipo de datos de agrupamiento es del tipo int (propiedad IdProvincia) y el elemento a agrupar es del tipo Cliente, por tanto:

IEnumerable<IGrouping<int, Cliente>> groupByProv = 
    from cliente in list group cliente by cliente.IdProvincia;

O lo que es lo mismo:

var groupByProv = list.GroupBy(cliente => cliente.IdProvincia);

Ahora la variable groupByProv posee una lista de todas las clave/agrupaciones realizadas. De hecho podemos comprobarlo de la siguiente forma:

foreach (var cProv in groupByProv)//cProv es del tipo IEnumerable<IGrouping<int, Cliente>>
{
    Console.WriteLine(
        string.Format("Provincia {0}, {1} clientes", cProv.Key, cProv.Count()));
}

Cuyo resultado por pantalla seria:

La variable implícita cProv posee tanto la clave utilizada (IdProvinicia) como la iteración de los clientes agrupados por dicha propiedad, de forma que podría ser recorrida de igual forma.

foreach (var cProv in groupByProv)//cProv es del tipo IEnumerable<IGrouping<int, Cliente>>
{
    Console.WriteLine(
        string.Format("Provincia {0}, {1} clientes", cProv.Key, cProv.Count()));

    foreach(var cliente in cProv)
        Console.WriteLine(cliente.ToString());
}

Y el resultado:

Sin embargo podríamos rizar aún más el rizo y agrupar, de nuevo, cada una de las agrupaciones por el tipo de cliente. De esta forma tendríamos una primera agrupación según la IdProvincia del cliente y por cada uno, una agrupación por tipo de cliente de la siguiente forma:

   1: foreach (var cProv in groupByProv)//cProv es del tipo IEnumerable<IGrouping<int, Cliente>>

   2: {

   3:     Console.WriteLine(string.Format("Provincia {0} ", cProv.Key));

4:

   5:     IEnumerable<IGrouping<int, Cliente>> groupByTipo = cProv.GroupBy(cliente => cliente.Tipo);

6:

   7:     foreach (var cTipo in groupByTipo)

   8:     {

   9:         Console.WriteLine(string.Format("\tTipo {0} \n", cTipo.Key));

10:

  11:         foreach (var cliente in cTipo)

  12:             Console.WriteLine(cliente.ToString());

  13:     }

  14: }

Lo que hemos hecho en el ejemplo anterior es aprovechar la iteración del primer agrupamiento para volver a generar un extensión GroupBy pero en esta ocasión con la propiedad Cliente.Tipo (int) como TKey. El resultado:

Manejando resultados IEnumerable<TSource>

Como comenté anteriormente, GroupBy puede devolver una iteración de tipo IEnumerable<TSource> indicando en la sobrecarga el parámetro resultSelector. Para ver este ejemplo, en base a la lista de cliente generada anteriormente, vamos a mostrar, por ejemplo, para cada una de las provincias (agrupamiento) el número total de clientes, el valor máximo, mínimo y medio de la propiedad Cliente.VolumenNegocio (decimal) de modo que nos ofrecerá información, por cada provincia, de los valores máximo, mínimo y medio del volumen de negocio de los clientes.

Para ello utilizaremos la sobrecarga:

   1: System.Linq.Enumerable.GroupBy<TSource, TKey, TResult>(

   2:    this System.Collections.Generic.IEnumerable<TSource>,

   3:    System.Func<TSource,TKey>,

   4:    System.Func<TKey,System.Collections.Generic.IEnumerable<TSource>,TResult>)

La implementación será:

   1: var groupByInfo = list.GroupBy(

   2:     cliente => cliente.IdProvincia, //seguimos con el agrupamiento por provinicia

   3:     (provincia, clientes) => new //retornamos un tipo anónimo

   4:         {

   5:             //con info sobre el agrupamiento

   6:             Key = provincia,

   7:             Count = clientes.Count(),

   8:             Min = clientes.Min(c => c.VolumenNegocio),

   9:             Max = clientes.Max(c => c.VolumenNegocio),

  10:             Avg = clientes.Average(c => c.VolumenNegocio)

  11:         });

El primer lugar, el tipo de la iteración de retorno es del tipo anónimo y es por ello que nos basamos en una variable implícitamente tipada (var). El primer parámetro (línea 2) es del tipo keySelector que vimos anteriormente y como dije es común en todas las sobrecargas pues es el valor clave de agrupamiento. Seguidamente el segundo parámetro (líneas 3-11), del tipo Func<int,IEnumerable<Cliente>,anonymous type> es donde se proyectará el resultado del agrupamiento.

Iteramos y mostramos los resultados.

   1: foreach (var res in groupByInfo)

   2:     Console.WriteLine(

   3:         string.Format("Provinicia:{0}\n\tCount:{1}\n\tMin Volumen:{2}\n\tMax Volumen:{3}\n\tAvg:{4}"

   4:                       , res.Key, res.Count, res.Min, res.Max, res.Avg));

En total 3 iteraciones con sus respectivas “estadísticas”:

El código completo:

namespace LINQGroupingBy
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    class Program
    {
        static void Main(string[] args)
        {
            //Ejemplo para LINQ to Objects

            //inicializamos lista de clientes
            var list = new List<Cliente>
                           {
                               new Cliente {IdProvincia = 1, Nombre = "Cliente1", Tipo = 10, VolumenNegocio = 100.00m},
                               new Cliente {IdProvincia = 2, Nombre = "Cliente2", Tipo = 20, VolumenNegocio = 20.00m},
                               new Cliente {IdProvincia = 3, Nombre = "Cliente3", Tipo = 20, VolumenNegocio = 230.00m},
                               new Cliente {IdProvincia = 3, Nombre = "Cliente4", Tipo = 20, VolumenNegocio = 500.00m},
                               new Cliente {IdProvincia = 1, Nombre = "Cliente5", Tipo = 30, VolumenNegocio = 10.00m},
                               new Cliente {IdProvincia = 2, Nombre = "Cliente6", Tipo = 10, VolumenNegocio = 750.00m},
                               new Cliente {IdProvincia = 1, Nombre = "Cliente7", Tipo = 20, VolumenNegocio = 340.00m},
                               new Cliente {IdProvincia = 1, Nombre = "Cliente8", Tipo = 20, VolumenNegocio = 170.00m}
                           };


            //obtenemos todos los clientes agrupados por provincias
            var groupByProv = list.GroupBy(cliente => cliente.IdProvincia);

            //tambien se puede expresar como:
            //
            //IEnumerable<IGrouping<int, Cliente>> groupByProv = 
            //    from cliente in list group cliente by cliente.IdProvincia;

            foreach (var cProv in groupByProv)//cProv es del tipo IEnumerable<IGrouping<int, Cliente>>
            {
                Console.WriteLine(
                    string.Format("Provincia {0}, {1} clientes", cProv.Key, cProv.Count()));

                foreach(var cliente in cProv)
                    Console.WriteLine(cliente.ToString());
            }

            Console.ReadKey();

            foreach (var cProv in groupByProv)//cProv es del tipo IEnumerable<IGrouping<int, Cliente>>
            {
                Console.WriteLine(string.Format("Provincia {0} ", cProv.Key));

                IEnumerable<IGrouping<int, Cliente>> groupByTipo = cProv.GroupBy(cliente => cliente.Tipo);

                foreach (var cTipo in groupByTipo)
                {
                    Console.WriteLine(string.Format("\tTipo {0} \n", cTipo.Key));

                    foreach (var cliente in cTipo)
                        Console.WriteLine(cliente.ToString());
                }
            }

            Console.ReadKey();
            Console.Clear();

            //volvemos a agrupar
            var groupByInfo = list.GroupBy(
                cliente => cliente.IdProvincia, //seguimos con el agrupamiento por provinicia
                (provincia, clientes) => new //retornamos un tipo anónimo
                    {
                        //con info sobre el agrupamiento
                        Key = provincia,
                        Count = clientes.Count(),
                        Min = clientes.Min(c => c.VolumenNegocio),
                        Max = clientes.Max(c => c.VolumenNegocio),
                        Avg = clientes.Average(c => c.VolumenNegocio)
                    });

            //mostramos los resultados
            foreach (var res in groupByInfo)
                Console.WriteLine(
                    string.Format("Provinicia:{0}\n\tCount:{1}\n\tMin Volumen:{2}\n\tMax Volumen:{3}\n\tAvg:{4}"
                                  , res.Key, res.Count, res.Min, res.Max, res.Avg));

            Console.ReadKey();

        }

        public class Cliente
        {
            public int IdProvincia { get; set; }
            public int Tipo { get; set; }
            public string Nombre { get; set; }
            public decimal VolumenNegocio { get; set; }

            public override string ToString()
            {
                return string.Format("\t\t-> Cliente: {0} - Provincia:{1} - Tipo: {2} - Vol.:{3}e\n",
                                     Nombre, IdProvincia, Tipo, VolumenNegocio);
            }
        }
    }
}

Nokia lleva a los tribunales al iPhone por violación de hasta 10 patentes

José Miguel Torres — Fri, 23 Oct 2009 07:05:00 GMT

Y es que el 22 de octubre no sólo fue noticia el lanzamiento mundial de Windows 7. Nokia, por su parte, denunció ante los tribunales de EEUU a Apple por violar hasta 10 patentes que incorpora su teléfono móvil iPhone.

Por todos es sabido del liderazgo de Nokia en el mercado mundial de telefonia móvil, dónde practicamente 4 de cada 10 dispositivos vendidos en el mundo salen de la factoria finlandesa. Lo que probablemente no esté en la luz publica es que Nokia, quien ha llegado a invertir hasta 40 Billones de € en I+D, posee muchas de las patentes en telefonia móvil quién comparte con hasta 40 empresas del todo el mundo bajo contratos de colaboración.

Con todas excepto con Apple (supuestamente). Por lo visto los de Cupertino (California) han incorporado características al su dispositivo móvil al modo de Duty Free. Encriptación, comunicaciones inhalambricas, seguridad o reconocimiento de voz son algunas de las patentes que (supuestamente) Apple ha violado.

Tambien cabe decir que Nokia ha presentado su primer semestre del año con datos negativos despues de más de una decada. Esta bajada se debe al mercado que ha conseguido tanto por el iPhone como su Marketplace y algunos expertos/analistas en mercados tecnologicos apunta a ésta como la causa principal de esta demanda.

De todas formas, el caso no se ejecutará hasta el 2011. A ver que pasará....

Microsoft Sync Framework 2.0 (Novedades de la nueva versión y adopción por SharePoint 2010 y Windows 7)

José Miguel Torres — Mon, 19 Oct 2009 22:26:00 GMT

Se acaba de liberar la versión 2.0 de Microsoft Sync Framework. Esta esperadísima nueva versión de Sync Framework además de aportar nuevas características y mejorar (según dicen, habrá que probarlo) en cuanto a rendimiento, también es noticia por la adopción por parte de Windows 7 y Microsoft Office/SharePoint 2010.

Respecto a Windows 7, MS Sync Framework 2.0 será la plataforma de sincronización utilizada por Device Stage, nueva característica del sistema operativo que pretende ser el punto de conexión con los dispositivos móbiles. De modo que la sincronización de tareas, contactos y demás items se sincronizaran con cualquier orígenes de datos.

Por lo que respecta a SharePoint 2010, Sync Framework 2.0 jugará un papel importante en cuanto a la sincronización de Office Workspace (Groove) y SharePoint. Además, el propio servidor de SharePoint 2010 expondrá parte de las API de Sync Framework 2.0 para poder crear proveedores personalizados para integrar datos al propio SharePoint.

Sync Framework ofrece mejoras sustanciales respecto a la versión anterior:

Core Components

Incorpora el filtrado flexible en el que se permite de forma dinámica el filtro de un conjunto de datos mediante una especie de negociación entre proveedores durante la sincronización.
- Nuevos tipos y propiedades:
  - Tipos implementados por los proveedores:
  - Tipos implementados por Sync Framework:
Se ha mejorado el manejador de conflictos.
Se ha añadido una API para la conversión de tipos de datos entre orígenes de forma que se pueden utilizar diferentes tipos de datos de una columna en tabla del proveedor remoto y otro tipo de datos para proveedor local.
- Los nuevos tipos y propiedades de la API son:
Se incluye el servicio de aplicación de cambios (Change Application Service).
Ahora Sync Framework permite la traza de cualquier componente durante la sincronización generándose archivos .tmf para poder ser estudiados posteriormente.

Sync Services for ADO.NET

Ahora ya sí (al fin) Sync Services for ADO.NET ofrece un proveedor de datos para SQL Server Express, además de los ya existentes SQL Server y SQL Server Compact. Para todos ellos con sus correspondientes adaptadores con lo que prácticamente no requeriremos escribir ningún comando de consulta o modificación.
Nueva API la sincronización de datos en batch, resolviendo los difíciles escenarios (en ocasiones irresolubles) que comportaba la utilización de batching en la versión 1.0. Además se ha optimizado de forma que podemos configurar el espacio máximo que un conjunto de cambios puede ocupar en memoria lo cual optimizará, y mucho, el rendimiento sobretodo en las inicializaciones de una sincronización. Esta característica será muy bien recibida por la comunidad .NET Compact Framework cuando aparezca la siguiente versión para dispositivo móviles.
Habilita las tareas de mantenimiento para por ejemplo limpiar los metadatos.
Dos opciones de inicialización de datos: inicialización por sincronización normal (de una base de datos ya inicializada) o bien inicialización instantánea de una base de datos SQL Server Compact 3.5.

[OT] Tatuajes geeks

José Miguel Torres — Tue, 13 Oct 2009 21:57:00 GMT

Impresionante documento trágico gráfico el que os traigo. En este mismo portal de geeks.ms se mostró no hace mucho una imagen de un tatuaje realmente curioso.

Pues por lo visto hay alguien que no se ha conformado únicamente con dos tag:

Incluso alguna ha hecho su propia interpretación:

Pero no solo de HTML vive el geek. Ahí va un poquito de C:

Y un “Hola Mundo!”

También hay lugar para los binarios:

Y un poco de código encriptado:

Lo que tampoco podía faltar son los Fan Boys, empezando por los Linuxeros:

Pasando por los Appleros.

Googleros…

Yahooeros

Y por supuesto de los Microsofteros

Otros mas de principios, orgullosos de lo que son:

Los visionarios:

Los inconformista:

Bloggeros:

También tienen cabida “los del hierro” (hardware)

Y el mas de lo mas. Los auténticos geeks. Los que viven este mundillo como ninguno y sin duda uno de mis favoritos… los que se tatúan la Pantalla Azul de la Muerte en el brazo!!!! Que Grande!!!

En fín, ahí queda el tema.

Salud!

Del Modelo de Error Humano en las organizaciones TIC a los papanatas con corbata

José Miguel Torres — Thu, 08 Oct 2009 21:23:00 GMT

La industria aeronáutica invierte cada año una gran suma de dinero en una de las áreas más importantes, la seguridad. Pese a los fundamentos matemáticos y físicos en los que se basa la ingeniería aeronáutica, así como en otros campos de la ingeniería, los errores y los encadenamientos de actos de fortuitos suceden, lo que provocan grandes desastres casi siempre humanas.

Componentes electrónicos, mecánicos, computacionales, hidráulicos, una aeronave es un conjunto de dispositivos diseñados al milímetro dentro de una estructura física cuya finalidad no es únicamente la de volar, sino hacerlo de la forma más segura. Muchos de estos componentes y dispositivos, por no decir todos, requieren de un constante plan de mantenimiento para prevenir anomalías. Pese a ello, dichos componentes fallan y ante cualquier situación de fallida una aeronave puede seguir volando. El caso más conocido es el de los motores a reacción. Cualquier aeronave puede seguir volando si en pleno vuelo uno de los reactores deja de funcionar.

Pese a la alta fiabilidad de sus componentes, ocurren catástrofes aéreas dónde intervienen varios factores y de los cuales, además como piedra angular, la mayoría tienen como origen el factor humano. En realidad y a grosso modo se distinguen los siguientes factores:

Factores humanos a Más del 50%
- Relacionados con el piloto
- Otros
Factores meteorológicos
Factores mecánicos
Otros factores

Más allá del dato puramente estadístico, lo que destaca es que más de la mitad de factores tienen un origen directamente humano. Los propios sistemas de equipamiento de la aeronave están diseñados para actuar y corregir dichos errores. Por ejemplo, los sistemas TCAS (Traffic alert and Collision Avoidance System) de las aeronaves son dispositivos que detectan, con antelación, peligro de colisión con otra aeronave en circulación equipada con TCAS. El TCAS no únicamente alerta sino que también propone una solución "negociada" con la otra aeronave (más concretamente con su TCAS) de forma que mientras a una aeronave le indicará que ascienda a la otra le indicara que descienda, evitando así la colisión. Por tanto estaríamos hablando de un sistema de defensa de errores provenientes de la persona, bien de los controladores aéreos o bien de los propios pilotos, por ejemplo.

En aeronavegación, todas las aeronaves en con rumbo entre 000 y 179 tienen una altitud o Nivel de Vuelo impar (FL330, FL350, FL370) y las aeronaves con rumbo entre 180-359 tienen un Nivel de Vuelo par (FL340, FL360, etc.). Básicamente y hablando en llano, nunca dos aeronaves chocaran "de frente" mientras estas se mantienen en altitud de crucero adecuado.

En base a esta regla básica de aeronavegabilidad, las colisiones cuando el avión está en altitud de crucero son sencillamente imposibles. Sin embargo durante esta fase (Crucero) es común el cambio del Nivel de Vuelo aumentándose o disminuyéndose según las condiciones meteorológicas o técnicas (ahorro de combustible) así como por razones ajenas e indicadas por el Control de zona (ATC) y es ahí dónde empiezan a haber los primeros riesgos, riesgos que se multiplican cuanto más cerca están de la fase de despegue o aproximación al aeropuerto de destino, debido al tráficos y a las variables de entorno.

Si nos lo ponemos a pensar parece incrédulo que dos aviones comerciales choquen a más de 12.000 metros de altura en la fase de crucero y más con componentes como el TCAS ¿verdad?, pues desgraciadamente se han producido colisiones de aeronaves a una altitud de 36.000 pies (FL360).

El Modelo de Error Humano o Swiss Cheese Model

El modelo de error humano o Swiss Cheese Model fue acuñado por primera vez por el británico James T. Reason, quién es conocido cariñosamente como Swiss Cheese Man. Este modelo es utilizado en el análisis de riesgo de los sistemas humanos y también es conocido como el Efecto de Actos Acumulativos o el Modelo de Reason.

El Modelo de Error Humano parte de las premisas:

Los humanos no somos infalibles
Los errores son esperables

Es decir un error es una consecuencia de un acto preliminar (factores sistemáticos) no como un acontecimiento causal. En este modelo se representan las debilidades humanas como los agujeros de las lonchas del queso de gruyere catalogadas en cuatro niveles de errores:

Influencias organizacionales
Control de riesgos
Condiciones previas a actos inseguros
Los actos inseguros en sí

De esta forma, en el modelo se dibuja un escudo defensivo representadas por lonchas y cuyo objetivo no es el de desvelar quién se equivocó sino cómo y por que las defensas fallaron.

El uso metafórico del queso de gruyere no únicamente responde a la idea de las lonchas y sus agujeros y su representación, pues en dicho modelo los agujeros o debilidades humanas cambian, entre loncha y loncha, de forma, tamaño y posición y responden a la subjetividad de dichas debilidades. Gracias a esto se pueden prevenir “trayectorias lineales accidentales” debido a que se puede detectar una debilidad común en todas las defensas. La representación esquemática equivaldría a que de todas las lonchas de queso representando una capa de seguridad, todas tienen un punto común de debilidad por el que un acto casual puede ocurrir sin que haya ni una sola capa de seguridad que pueda evitarlo. Esto responde a errores o actos lineales.

El caso es que en un accidente intervienen diferentes factores y pese a que este modelo está ampliamente aceptado (es de origen psicológico), en muchos campos no únicamente de la ingeniería sino también de la medicina, los accidentes ocurren y cuando eso sucede tenemos la obligación de averiguar los factores que han fallado y han convergido en un desastre.

Sistemas informáticos

La propia organización es la encargada de planificar y ejecutar sus propios sistemas de defensa y en la industria de la informática, de la misma forma que en otras industrias, dicha organización se sustenta en perfiles de mayor a menor responsabilidad. Ninguno de estos perfiles están exentos de responsabilidad y todos y cada uno de ellos forman una parte importante de los mecanismos de defensa.

Es signo de fracaso las acusaciones de culpa por parte de los perfiles de más alta responsabilidad hacia los que están en la base del organigrama funcional de la organización. Son intolerables las tendencias a interpretar los actos de modo que confirmen las preconcepciones por parte de los perfiles de más alta responsabilidad dado que en la mayoría de los casos no son más intentos de exculpación. No debemos recordar nuestras propias decisiones como mejor de lo que realmente fueron y sobreestimarlas por encima del contexto de organización así como evitar el Efecto Foco, es decir desviar la predicción de resultados. En definitiva sesgar la información o los actos en base a prejuicios personales.

Contextualizando el Modelo de Error Humano en el ámbito informático, un error o falla es el resultado de la superposición de debilidades de los recursos humanos de una organización más las de la propia organización.

Como recursos humanos existen una multitud de categorías profesionales que abarcan desde los más experimentados (Arquitectos, Jefes de proyecto, Directores IT) a los recién licenciados/graduados (programadores/analistas junior, operadores). Todos y cada uno de ellos deben saber cuáles son sus limitaciones y responsabilidades y éstas deben ser tenidas en cuentas por las personas inmediatamente superior en el eslabón del organigrama organizativo y así sucesivamente. Cualquier acto producido que derive en una fallida debe ser contextualizado en base a si fue una equivocación (descuido, una distracción, una desconcentración, un error al seguir las reglas), un riesgo o un dolo.

Las fallas de organización son aquellas cuyo origen las encontramos en el eslabón más alto del organigrama corporativo y la no actuación y prevención de estas fallas se propagan hacia los recursos inmediatamente inferiores del organigrama. Uno de los errores más graves que se cometen es el de la persuasión de recursos de nivel más bajo quedando impunes los de más alto nivel. Un error producido en un programador tiene su origen en los eslabones más altos de la organización. Todo esfuerzo dirigido al reconducir o castigar un recurso de bajo nivel bajo el pretexto de solución sin haber hecho lo propio desde un nivel más elevado, sencillamente será en vano.

Los orígenes de este tipo de fallas organizacionales se encuentran en el liderazgo. Se entiende como liderazgo como el conjunto de cualidades que definen el comportamiento de una persona y que intervienen positivamente en el ambiente laboral de un colectivo. Respeta y serás respetado.

Por otro lado, y siguiendo el hilo de fallas organizacionales, es importante crear una estructura jerárquica y equilibrada de mandos intermedios. Pese a que la experiencia es un grado, el "él lleva más tiempo que tú" es pretexto erróneo (sesgo). La selección y formación del personal así como la comunicación del mismo es uno de los procedimientos que menos importancia se les da, más son indirectamente improductivas y costosas. Por otra parte la calidad y el diseño de equipos así como las presiones operativas y/o comerciales de la propia organización con los clientes derivan en muchos casos, como factor de fallida de origen organizacional.

En busca del “TCAS” informático

Existen multitudes de mecanismos lógicos y físicos que debemos tener presente en todos los campos de las tecnologías de la información y comunicación. En caso del TCAS expuesto en la entradilla de este post tiene una interpretación libre dentro de nuestro campo. Cualquier componente lógico puede ayudarnos a evitar allí donde las debilidades humanas no pueden alcanzar pero también existen doctrinas dentro de la gestión de proyectos que contemplan nuestras limitaciones y las cuales TODAS se basan en la idea de equipo y perfiles y que abarcan y responde al termino CALIDAD.

Mi Opinión

Me preocupa especialmente la fabricación de ataúdes profesionales que algunos responsables de alto nivel llevan a cabo con sus subordinados debido a la falta de motivación y de formación. Esto deriva en una muerte lenta de la carrera profesional de los trabajadores que muchas veces olvidan la atención que (especialmente en un campo dónde tan rápidamente evolucionan las tecnologías como lo es en el campo de la informática) el propio futuro profesional de un individuo requiere. Básicamente existen tres puntos en los que un empleado presta especial importancia por este orden:

Las pretensiones económicas
El ambiente de trabajo. Disfrutar con lo que se hace.
Su carrera profesional. Es decir la evolución personal dentro de su profesión.

Las descompensación exagerada de algunos de estos tres puntos (especialmente los dos últimos) será la sentencia a muerte (de su carrera profesional se entiende) de un empleado lo cual será catastrófico, primero para el propio empleado y segundo para la propia organización.

Pero, ¿Qué pasa con esos tipos de amplia experiencia que bajo la corbata dirigen y planifican la vida profesional de todos sus empleados?

En primer lugar, jamás sentiré más respeto por un compañero uniformado, por el simple hecho de serlo, que por otro cuya apariencia, sin ser violenta, esté fuera del estereotipo empresarial o social, esté por encima o no de mí. El respecto se gana con la confianza y la confianza se gana con oportunidades. En el momento en que un profesional empieza a tener mayores responsabilidades y mayor gente a su cargo automáticamente se otorga un rango de superioridad y poseedor de la verdad absoluta. Lo que dice él es lo correcto, porque lo dice él y por que la propia organización así permite ejercerlo. No hay lugar a discusión, su razón así como su responsabilidad, son superiores a los de los demás pero sin embargo (y curiosamente) es inversamente proporcional a sus excusas en caso de errores. El marrón se lo come el último y la verdad es que no se me ocurre nada más cobarde y ruin. Del que piensa y actúa así, no le deberé jamás ningún respeto.

Asumir las responsabilidades, defender a capa y espada a sus subordinados, confiar y respetar y recibir lo mismo, otorgar oportunidades y ayudar a descubrir sus debilidades y virtudes. Todo esto es trabajo humano, no productivo directamente pero que forja colectivos “indestructibles”, camaraderías de profesionales excelentes. El hoy por ti y mañana por mí. El “yo cubro tus espaldas”. El evitar el afán de protagonismo. Todo ello deriva en un EQUIPO. Un EQUIPO con mayúsculas pues se otorgan palabrerías de este tipo a colectivos que ni siquiera llegan a ser meros colegas profesionales sobre los que por encima suyo no hay más que un fósil profesional que oculta sus fracasos con su protagonismo inoportuno.

Si no se cumplen los requisitos humanos y éticos es imposible construir cualquier modelo de defensa. Sencillamente todo lo que toque dicha organización estará sentenciado a muerte y seguramente se llevará por delante a alguien (en el mejor de los casos).

¡Muerte a la hipocresía! ¡Viva el sacrificio!

¡Más de 200 asistentes registrados en el Code Camp Tarragona 2009!

José Miguel Torres — Tue, 06 Oct 2009 22:24:00 GMT

Pues si, por encima de nuestras estimaciones iniciales, el Code Camp Tarragona 2009 se postula como uno de los eventos de comunidad más importantes del año 2009. Más de 30 sesiones y 30 speakers y con 9 patrocinadores y 3 colaboraciones el Code Camp Tarragon 2009 tiene todos los ingrendientes para ser todo un referente.

No hay escusas. Asistentes de Madrid, Sevilla, Galicia, Bilbao, Valencia, Malaga, Albacete,,, prácticamente desde todos los rincones de España van a estar con nosotros.

Un fin de semana en un Hotel de 4 estrellas en las espectaculares playas de La Pineda con los mayores expertos de .NET y de MONO de todo el país a nuestra disposición. ¿Que más podemos pedir?

¡Anímate y haznos compañia!

Más info: www.codecamp.es

Listado de recursos de desarrollo para Windows Mobile 6.5

José Miguel Torres — Mon, 05 Oct 2009 20:52:00 GMT

A continuación detallo un conjunto de recursos para Windows Mobile 6.X/6.5:

Titulo	Tipo	Descripción
Programming for Windows Mobile 6.5	Artículo	Presenta todos los recursos Online para Windows Mobile 6.5
Developing Web Applications for Internet Explorer Mobile 6 on Windows Mobile 6.5	Artículo	Como sacar el máximo provecho a las nuevas características del navegador Internet Explorer Mobile de Windows Mobile 6.5.
Developing Widgets for Windows Mobile 6.5	Artículo	Desarrollar Widgets para Windows Mobile 6.5.
Creating Location-Aware Applications for Windows Mobile Devices	Artículo	Desarrollo de aplicaciones basadas en los Servicios Basados en Localización para Windows Mobile 6.x.
Creating a Compelling UI for Windows Mobile and the Microsoft .NET Compact Framework	Artículo	Aprende a utilizar las API’s de la plataforma Windows Mobile® para aumentar la experiencia de usuario.
Selecting a Windows Mobile API - .NET Compact Framework and Win32	Artículo	Este artículo habla acerca de Microsoft® Win32® API y las APIs de Microsoft .NET Compact Framework (NETCF) para Windows Mobile® 6 y posterior.
Getting Started with Building Windows Mobile Solutions with Visual Studio and Windows Mobile 6 SDK	Artículo	Como empezar en el desarrollo de aplicaciones para Windows Mobile® utilizando las mismas herramientas que entornos Desktop con Microsoft® Visual Studio® 2008, y específicamente para Microsoft .NET Compact Framework 3.5. También describe como utilizar las herramientas contenidas en el Windows Mobile SDK.
Optimizing Query and DML Performance with SQL Server Compact Edition 3.5 and SqlCeResultSet	Artículo	Comparación en la inserción y manipulación de filas utilizando Microsoft® SQL Server® Compact Edition 3.5 SP1, con un especial enfoque para el usuario acerca de cómo utilizar los objetos SqlCeResultSet.
Programming Microsoft Synchronization Services for ADO.NET (Devices)	Artículo	Una de las características más importantes de Microsoft® SQL Server® Compact Edition 3.5 SP1 es el soporte a Microsoft Synchronization Services for ADO.NET. Esta tecnología de sincronización permite la sincronización de diferentes orígenes de datos para entornos dos, N capas y arquitecturas orientadas a Servicios.
Porting the Amplitude Application from the iPhone to a Windows Mobile Device – a Case Study	Artículo	Case de estudio documentado de portación de aplicación iPhone a dispositivo Windows Mobile 6.5.
Application Verifier	Blog post	Detalles acerca de los pasos necesarios para la certificación de una aplicación al nuevo Marketplace.
GAPI Deprecation	Blog post	El Games API (GAPI) está obsoleto y este post habla de alternativas.
patterns & practices: Mobile Application Blocks - Community Release (was solution factory)	Codigo	Permite a los desarrolladores desarrollar aplicaciones mobile basadsa en VS2008, .NET CF 3.5 y WM6.1. Basado en el block de Mobile Client Software Factory v1, July 2006 e incluye mejoras realizadas por Microsoft Dynamics Mobile PU.
Using Gestures in Windows Mobile 6.5	Documentación	Documentación para la nueva API de Windows Mobile para el reconocimiento de trazas, Gesture API de Windows Mobile 6.5.
Windows Mobile 6 Professional and Standard Software Development Kits Refresh	Descarga	Requisito para Windows Mobile 6.5 Developer Toolkit (DTK)
Windows Mobile 6.5 Developer Tool Kit	Descarga	Windows Mobile 6.5 Developer Tool Kit (documentación, emuladores,…).
6.5 Developer Resource Kit: (External Order Page)	DVD
	FAQ	FAQ de Marketplace
‘How Do I’ videos	Videos
Ramp Up, Windows Mobile 6	Webcasts & Hands on labs	Programa RampUp para desarrollo con Windows Mobile 6.x
Windows Mobile Webcasts	Webcasts	Dos webcast específicos para el nuevo API de Gesture.
Fluid - Windows Mobile 6.x Touch Controls	Codigo	Libreria para .NET 2.0 para Windows Mobile 6.0/6.1 con controles Touch.
Windows Mobile Line of Business Solution Accelerator 2008	Descarga	Windows Mobile Line of Business Solution Accelerator es un ejemplo de aplicación Windows Mobile que muestra el uso de diferentes tecnologias (WCF, Sync Services, multi idioma, etc.) en una misma aplicación.

[SyncComm] Nueva versión 0.95 en Codeplex

José Miguel Torres — Fri, 04 Sep 2009 21:35:00 GMT

Con un poco de retraso, pues tenia pensado publicar esta versión a principios de agosto, acabo de publicar la nueva versión (0.95) de SyncComm. Como novedades:

Nueva gestión de excepciones
Corregidos algunos BUGs
Mas flexibilidad en el uso de las propiedades de los enlaces para HttpBinding y CompressedBinding.
Modificados los namespace

Nueva gestión de excepciones

SyncComm aporta una forma de propagación de excepciones en el proceso de sincronización mediante Sync Services for ADO.NET y el proveedor remoto de sincronización expuesto en un servicio WCF. Básicamente, el proxy generado por la herramienta de generación netcfsvcutil.exe y que se utilizó, con algunas modificaciones para llevar a cabo las sincronizaciones, en las versiones iniciales, no procesaba las excepciones o mensajes fault propagados por el servicio WCF. Siguiendo la Guia WCF para desarrolladores Mobile, publicada también en codeplex, mi primer acercamiento fue el de utilizar el proyecto Mobile.ServiceModelEx expuesto por los autores, el cual solucionaba en gran medida toda la gestión de excepciones entre el servicio WCF y el terminal móvil. Sin embargo, únicamente era válido para enlaces cuya versón de mensaje fuera MessageVersion.Soap11, o mejor dicho, la implementación para otras versiones de mensaje no está implementada. El problema es que SyncComm utilitza un enlace con compresión, mediante GZip encoder, y cuya versión de mensaje SOAP es MessageVersion.Soap12WSAddressing10. Después de algunos intentos de comunicación con los autores, todos sin éxito, decidí implementar dicha características para ambas versiones de mensajes SOAP y pese a que no está tan avanzada como Mobile.ServiceModelEx, lo cierto es que cubre los requisitos necesario para la propagación eficiente de cualquier tipo de anomalía durante el proceso de sincronización y la posterior captura y proceso desde el cliente.

Ahora seriamos capaces de propagar mensajes de error desde el servicio WCF de la siguiente forma:

   1: catch (SqlException sqlex)

   2: {

   3:     Guid id = Guid.NewGuid();

4:

   5:     //display detailed exception information on console

   6:     Notification.Invoke(DateTime.Now,

   7:         string.Format ("Exception {0}: {1}", id.ToString(), sqlex.Message));

8:

   9:     //throw and exception for being catch by client

  10:     throw new FaultException<string>(sqlex.Message, new FaultReason(

  11:                     new FaultReasonText("SQL Server is not available. Please try later.")),

  12:         FaultCode.CreateSenderFaultCode(id.ToString(), "urn:synccomm.com/2009/07/ISyncService"));

13:

14:

  15: }

  16: catch (Exception e)

  17: {

  18:     Guid id = Guid.NewGuid();

19:

  20:     //display detailed exception information on console

  21:     Notification.Invoke(DateTime.Now,

  22:         string.Format ("Exception {0}: {1}",id.ToString(),e.Message));

23:

  24:     throw new FaultException<string>(e.Message, new FaultReason(

  25:                     new FaultReasonText("SyncService unavailable. Contact SyncService support.")),

  26:         FaultCode.CreateSenderFaultCode(id.ToString(), "urn:synccomm.com/2009/07/ISyncService"));

27:

  28: }

Capturarlos desde la aplicación .NET Compact Framework como exepción del tipo CFFaultSyncException, dejando los tipos CommunicationException y Exception, para excepciones relativas a la comunicación y otros tipos de excepciones, respectivamente.

   1: catch (CFFaultSyncException faultEx)

   2: {

   3:     Cursor.Current = Cursors.Default;

4:

   5:     //

   6:     MessageBox.Show(string.Format("FaultCode: {0}\r\nFaultReason: {1}\r\nHasDetail: {2}",

   7:         faultEx.FaultCode, faultEx.FaultMessage, faultEx.HasDetail));

   8: }

   9: catch (CommunicationException communicationException )

  10: {

  11:     //is the emulator cradled? does it reach SyncService endpoint?

  12:     MessageBox.Show(communicationException.Message);

  13: }

  14: catch (Exception e)

  15: {

  16:     //something is not configured properly

  17:     MessageBox.Show(e.Message);

  18:     //HResult -2146233087 maybe database must be reinitialize

19:

  20: }

De forma que podemos mostrar un mensaje más amigable por pantalla mientras registramos el error técnico (opcional) para su posterior estudio. Además, todas las excepciones (representadas por la clase CFFaulSyncException) tienen un identificador único (System.Guid) lo cual permite registrar dicha excepción tanto en el servidor como en el cliente:

Si deseáis información más detallada aquí.

Corregidos algunos Bug

Como toda nueva versión, se han corregido varios Bugs, tanto registrados desde el site del proyecto como encontrados durante el proceso de desarrollo. El más significativo es el encontrado en los scripts.sql de generación del esquema de seguimiento de modificaciones para bases de datos que utilizan mecanismos de seguimiento personalizados.

Mas flexibilidad en el uso de las propiedades de los enlaces para HttpBinding y CompressedBinding.

Una de las peticiones de algunos desarrolladores fue la posiblidad de incrementar el tamaño máximo del mensaje, el cual se realiza a través de una de las propiedades del enlace. Como tal, se han creado dos métodos en ClientBase.cs los cuales gestionan todas las propiedades relativas los enlaces de la comunicación con WCF. En el siguiente ejemplo podemos ver uno de ellos. Básicamente se agrupa en un mismo método la forma en la que se va crear el enlace al canal de comunicación expuesto por WCF, de forma que la simple modificación de las propiedades como MaxReceiveMessageSize para el enlace de compresión se concentran en un único método. Lo mismo sucede para el enalce básico mediante HttpBinding.

   1: //NOTE:

   2: //set compressed endpoint binding custom properties here

   3: public static System.ServiceModel.Channels.Binding CreateCompressionBinding()

   4: {

   5:     // Create a CustomBinding

   6:     var customBinding = new CustomBinding();

   7:     // Create a compression binding element

   8:     var compressionBindingElmnt = new CompressionMessageEncodingBindingElement();

   9:     // ..and add to the custom binding

  10:     customBinding.Elements.Add(compressionBindingElmnt);

11:

  12:     // Create an HttpTransportBindingElement and add that as well

  13:     var httpBindingElement = new HttpTransportBindingElement();

14:

15:

  16:     //TODO

  17:     //Set here desired values. Take care to match such values

  18:     //in app.config in SyncComm host project

  19:     //max buffer size

  20:     //httpBindingElement.MaxBufferSize = int.MaxValue;

  21:     //max received message size

  22:     //httpBindingElement.MaxReceivedMessageSize = long.MaxValue;

  23:     //max buffer pool size

  24:     //httpBindingElement.MaxBufferPoolSize = long.MaxValue;

25:

  26:     customBinding.Elements.Add(httpBindingElement);

27:

  28:     return customBinding;

29:

  30: }

Por consiguiente y debido a que en versiones anteriores estos objetos se instanciaban desde la aplicación .NET CF Windows Form(AppMobileSync) y ahora han pasado al la librería (también .NET CF) SyncComm.Proxy.dll se ha aprovechado para que la instanacia del objecto SyncComm.Proxy.ServiceClient sea mas sencilla desde AppMobileSync. Ahora únicamente debemos indicar la dirección del EndPoint y su respectivo “tipo de enlace”. Dicho “tipo de enlace” se representa mediante el enumerador:

   1: namespace SyncComm.Proxy

   2: {

   3:     /// <summary>

   4:     /// Specify constants defining which endpoint binding to use

   5:     /// </summary>

   6:     public enum BindingType

   7:     {

   8:         /// <summary>

   9:         /// Use basic endpoint binding

  10:         /// </summary>

  11:         Basic,

  12:         /// <summary>

  13:         /// Use compressed endpoint binding

  14:         /// </summary>

  15:         Compressed

  16:     }

  17: }

Y por lo tanto la instancia de un objeto SyncComm.Proxy.ServiceClient será tan sencillo como:

   1: //NOTE: For compressed endpoint binding use this

   2: var endPoint = new EndpointAddress("http://10.0.2.15:9999/SyncService/GZip");

   3: var s = new ServiceClient(endPoint, BindingType.Compressed);

4:

   5: //NOTE: For basic endpoint use this

   6: var endPoint = new EndpointAddress("http://10.0.2.15:9999/SyncService/Basic");

   7: var s = new ServiceClient(endPoint, BindingType.Basic);

En lugar de como se hacía en versiones anteriore:

   1: // Create a CustomBinding

   2: var customBinding = new CustomBinding();

   3: // Create a compression binding element

   4: var compressionBindingElmnt = new CompressionMessageEncodingBindingElement();

   5: // ..and add to the custom binding

   6: customBinding.Elements.Add(compressionBindingElmnt);

7:

   8: // Create an HttpTransportBindingElement and add that as well

   9: var httpBindingElement =

  10:                     new HttpTransportBindingElement();

  11: customBinding.Elements.Add(httpBindingElement);

  12: // Set endpoint

  13: var endPoint = new EndpointAddress("http://10.0.2.15:9999/SyncService/GZip");

://10.0.2.15:9999/SyncService/GZip");

  14: #endregion

15:

  16: // Create the WCF proxy using the custom binding

  17: var s = new ServiceClient(customBinding,endPoint);

Modificados los namespace

Por último, se han modificado todos los namespace de los contratos WCF que antes eran inexistente. Ahora todos pasan a ser urn:synccomm/07/2009.

Dispositivo Windows Mobile 6.5 a partir del 6 de octubre

José Miguel Torres — Tue, 01 Sep 2009 14:12:00 GMT

Ya es oficial. Apartir del 6 de octubre empezaran a ver la luz la nueva "saga" de dispositivos Windows Mobile 6.5.

Se trata de la nueva versión anunciada en el pasado Mobie World Conference del pasado mes de febrero que tuvo lugar en Barcelona, junto a la nueva propuesta de Microsoft para el mercado de aplicaciones, Microsoft Marketplace, el cual ya se encuentra abierto a registros de nuevas aplicaciones.

Por lo que a España y Latino América respecta, las operadoras de telefonía móvil que ofrecerán estos nuevos dispositivos serán Orange y Vodafone en España y TIM Brasil así como fabricantes como HTC, LG Electronics, Samsung, Acer, Toshiba y Sony Ericsson los cuales lanzaran nuevas versiones de sus ya conocidos dispositivos como el Touch Diamond 2, Touch Pro 2, Omnia, etc.

¡¡¡Participa en el CodeCamp Tarragona 2009!!!

José Miguel Torres — Thu, 02 Jul 2009 13:56:00 GMT

Miembros y coordinadores de los grupos de usuarios Second NUG, Spain.NET, LoNetCamp, Andorra.NET, BCNDEV.NET y CatDotNet hemos unido nuestras fuerzas en la organización conjunta de un codecamp que se llevará a cabo los dias 17 y 18 de octubre en Vila-Seca, Tarragona.

Con más de tres meses de trabajo a nuestras espaldas, y con la colaboración de Microsoft Ibérica, vamos a llevar a cabo dos días de charlas didácticas siguiendo el manifiesto codecamp: sesiones hechas por la comunidad hacia la comunidad.

Como novedad, CodeCamp Tarragona 2009 incluirá un track específico de MONO con lo que durante el fin de semanas podremos intercambiar opinones y experiencias entre las comunidades MSDN y MONO de toda España sobre la tecnología .NET.

Si estáis interesados:

Si queréis saber mas, echadle un vistazo a la página Web oficial del codecamp. Inscríbete en el Pre-Registro.
Para colaborar, proponer sesiones o dejar vuestras opiones hacedlo desde el Foro Oficial, que hemos habilitado para tal fin.
También podéis encontrarnos en Facebook o seguirnos por Twitter.

Seguiremos informando!!!

[SyncComm] Componentes WCF de comunicación para Sync Services for ADO.NET for devices

José Miguel Torres — Mon, 22 Jun 2009 21:55:00 GMT

Dentro de los requisitos que debemos tener en cuenta en el desarrollo de soluciones de sincronización de datos para plataformas Windows Mobile utilizando los servicios Sync Services for ADO.NET 1.0 SP1 se encuentra la comunicación entre el propio dispositivo móvil, donde albergamos tanto el agente de sincronización como el proveedor de sincronización local, y el servidor dónde reside el proveedor de sincronización remoto el cual exponemos a través de un servicio Web o WCF.

Para el uso de WCF en .NET Compact Framework, el equipo de desarrollo de Microsoft Sync Framework publicó en su blog unos trucos para la configuración de este tipo de aplicaciones. En dicho post se describen los puntos que se han de seguir para la correcta exposición de un proveedor remoto en WCF.

A partir de esa idea, empecé a desarrollar unas librerías de forma que pudieran ser reutilizadas y sirvieran, a su vez, como punto de partida para todos aquéllos interesados en este tipo de aplicaciones. Dichas librerías se encuentran bajo el proyecto SyncComm y pueden ser descargadas, código abierto, desde CodePlex.

SyncComm es un proyecto que cuenta además con la colaboración de Cesar Fong y el cual pretende ser un punto de partida, como dije anteriormente, para el desarrollo de soluciones de sincronización para dispositivos móviles. Este proyecto viene acompañado de una aplicación muy básica de ejemplo y por el momento SyncComm está en fase Beta, esperando poder aportar otras características interesantes como la seguridad o la gestión de excepciones, entre otras. Seguiremos informando. ;-))

SyncComm [http://synccomm.codeplex.com]

Purposes

SyncComm is intended to be used as starter point with Sync Services for ADO.NET 1.0 for devices. SyncComm shows how to implement the WCF communication layer based on Microsoft Sync Framework team's tips. See: http://blogs.msdn.com/sync/archive/2008/07/14/using-wcf-for-communcation-in-a-mobile-sync-application.aspx

Technologies

Related Resources

Documentation
In order to make using of compression encoders for WCF’s Endpoint it will be necessary to download:
- *Microsoft.Samples.Indigo.GzipEncoder* project
- GZipEncoder project --> You will find this project at <InstallationPath>\WCF\Extensibility\MessageEncoder\Compression\CS\GZipEncoder after executing WCF_WF_Samples.exe.

SyncComm: Projects descriptions

Basically, SyncComm has two projects for both client (WCF Service Proxy) and server (WCF Service) sides. Moreover, a Service Host Console for hosting WCF Service, DbServerSyncProvider demo project and Windows Forms application for Windows Mobile 5.0 is provided (it also works over Windows Mobile 6.0, Windows Mobile 6.1 and Windows Mobile 6.5).

Image1.- SyncComm architecture

SyncComm projects

SyncComm.Services: contains the WCF Service definition (ISyncService) needed for any solution based on n-tier Sync Services for ADO.NET. This project may be used for your own project by adapting remote provider application class to your database schema and requirements. (See Customizing SyncComm components for your own project below)
SyncComm.Services.Host: hosts WFC Service into basic Console application. It could be replaced by either IIS, WinForms app, Windows Service or WAS.
SyncApp.RemoteProvider: This project contains the remote sync provider class for SQL Server database sample as well as AppRemoteProvider helper class that simplify DBRemoteProvider extended class. However, the purpose of this class is to get familiarized with this kind of solution. Is strongly recommended you use your own approach according to Microsoft guidelines you would find on Sync Service for ADO.NET 1.0 SP1 library.
GZipEncoder: Optional. Not provided within SyncComm. Necessary for WCF Compression. See Related Resources above.

SyncApp projects

SyncComm.Mobile: This class library (targeted on Windows Mobile 5.0 SDK) contains WCF Service proxy class. It could be used in others projects as is, without additional modifications whether no changes are applied on SyncComm.Service.ISyncService service contract.
AppMobileSync: This Windows Form Application consumes the WCF Service through such proxy exposed in SyncComm.Mobile. This application demonstrates how to hand a couple of sync tables in bidirectional and uploadonly modes.
Microsoft.Samples.Indigo.GzipEncoder: Optional. Not provided within SyncComm. Necessary for WCF Compression. See Related Resources above

Database

Database schema used in this project is based on script you would find in Microsoft Sync Framework “How to’s” library’s topics. It only contains a couple of tables for demonstrating bidirectional and uploadonly sync modes.
Note that three database four files are provided within SyncApp.RemoteProvider project.

database schema.sql: Creates a database named wcfSyncSamplesDb, and a couple of tables named Sales.Customer and Sales.CustomerContact.
enablingChangeTracking.sql: These scripts enable Change Tracking for wcfSyncSamplesDB database and for Sales.Customer and Sales.CustomerContact with default 2 days retention.
enablingCustomTracking.sql: Configures both tables in order to provide a custom change tracking for non SQL Server 2008 data providers.
testData.sql: Populates Sales.Customer and Sales.CustomerContact tables.

Setting up solution

For getting started the solution you may follow next steps.

Create database and database objects. Execute database file scripts in the following order.
1. Execute database schema.sql for creating database and objects.
2. Execute either enablingChangeTracking.sql or enablingCustomTracking.sql depending on what change tracking type your application will run at.
  1. enablingChangeTracking.sql for SQL Server 2008.
  2. enablingCustomTracking.sql for others.
3. Populate Sales.Customer after change tracking is enabled by executing testData.sql.
Change database connection string on SyncApp.RemoteProvider -> Settings.settings. (See Image 2)
Set your local IP/host name in app.config file from SyncComm.Service.Host project. (See Code 1)
If you wish to use Compression make sure both client and server related GZipEncoder project are referenced.
Set ISyncServices base endpoint address up in AppMobileSync project. (See Code 2 Method SyncNow in Form1.cs)
Recall to cradle your emulator/device and make sure it reaches endpoint address from IEMobile. Configure your Windows Firewall appropriately for enabling incoming calls for specified port. (Default port 9999). This also could be useful http://msdn.microsoft.com/en-us/library/ms733768.aspx
Execute both SyncComm.Service.Host and AppMobileSync apps. (See Image 4)

Image 2.- Database Connection String

      <service behaviorConfiguration="ISyncServiceBehavior" name="SyncComm.Service.SyncService">
        <endpoint address="Basic" binding="basicHttpBinding" name="BasicEndPoint"
          contract="SyncComm.Service.ISyncService" />
        <endpoint
          address ="/GZip"
          binding="customBinding"
          bindingConfiguration="BufferedHttpSampleServer"
          bindingName="BufferedHttpSampleServer"
          contract="SyncComm.Service.ISyncService"/>
        <host>
          <baseAddresses>
            <!-- Set here Service Host name/IP -->
            <add baseAddress="http://10.0.2.15:9999/SyncService" />
          </baseAddresses>
        </host>
      </service>
    </services>

Code 1.- app.config file from SyncComm.Service.Host project.

// Create a CustomBinding
var customBinding = new CustomBinding();
// Create a compression binding element
var compressionBindingElmnt = new CompressionMessageEncodingBindingElement();
// ..and add to the custom binding
customBinding.Elements.Add(compressionBindingElmnt);

// Create an HttpTransportBindingElement and add that as well
var httpBindingElement =
     new HttpTransportBindingElement();
customBinding.Elements.Add(httpBindingElement);
// Set WCF Service hosted name/IP endpoint *here*
var endPoint = new EndpointAddress("http://10.0.2.15:9999/SyncService/GZip");

Code 2.- Method SyncNow in Form1.cs

Image 4.- Service Host Console Application

Customizing SyncComm components for your own project

Configure your database appropriately. Take a look at the following link for further information. http://msdn.microsoft.com/en-us/library/bb726006.aspx NOTE: Modify uspGetNewBatchAnchor Stored Procedure for validating CHANGE_TRACKING_MIN_VALID_VERSION for your own tables._
Create your own Remote Sync Provider class (DBRemoteProvider). Keep in mind sync modes you would need to use for each table. You may use AppRemoteProvider class but is strongly recommended using custom Stored Procedures instead of sentences generated by SyncAdapterBuilder class.
Host SyncService on well-known IP address and pass it on SyncClient class constructor, in the client side. You may use other Service Host platform instead of console app provided by this sample.
If you need to configure binding behavior take in care WCF limitations for .NET Compact Framework.
Refer SyncComm.Mobile.dll assembly from your .NET CF application. Configure SyncAgent at your own discretion but don't forget to set up the tables with the sync modes you configured on server side before.

IMPORTANT: This sample is provided "as is", without warranty of any kind, express or implied. Suggestions, comments or whatever are welcomed at Discussion Pane

Must Have Tools para Windows Mobile

José Miguel Torres — Thu, 11 Jun 2009 19:49:00 GMT

Cesar Fong está recopilando un conjunto de herramientas indispensables para el desarrollo de aplicaciones para Windows Mobile. Sin duda un excelente recurso, ¡¡Gracias César!!

La lista del Windows Mobile Developer