Lluís Franco on Geeks.ms : C#, Codigo

Parallel Series: La clase estática Parallel

Lluis Franco — Tue, 14 Feb 2012 10:32:46 GMT

Acabo de publicar otro post relacionado con las ‘Parallel Series’:

3 métodos para los reyes elfos bajo el cielo

Hoy quiero hablaros de la clase estática Parallel. Esta clase provee soporte para paralelizar bucles y regiones, y al igual que PLINQ su uso es muy sencillo. Cabe destacar que está especialmente optimizada para iteraciones, y que en este contexto se desenvuelve un poco mejor que PLINQ. No hay una diferencia significativa en tiempos absolutos, pero puede verse perfectamente si utilizamos el magnífico profiler de Visual Studio 2010. No obstante, pueden existir situaciones en las que si se necesita afinar mucho el rendimiento en iteraciones, y aquí es dónde tiene más sentido utilizar dos de los tres métodos de esta clase: For y ForEach. Al tercero lo llamaremos Cirdan y apenas aparecerá en esta historia (en realidad me refiero a Invoke pero tampoco aparecerá por aquí)...

Podéis acceder al artículo completo aquí:

http://lluisfranco.com/2011/06/26/parallel-series-la-clase-esttica-parallel/

Un saludo,

Parallel Series: Video – 02 PLINQ

Lluis Franco — Mon, 13 Feb 2012 08:44:29 GMT

Acabo de publicar otro vídeo de las las ‘Parallel Series’. Os dejo aquí también el enlace:

http://lluisfranco.wordpress.com/2011/07/01/parallel-series-video-02-plinq/

En este segundo vídeo de las Parallel Series haremos un breve recorrido por las principales características de Parallel LINQ.

Un saludo,

Luces, cámara… Action!

Lluis Franco — Fri, 10 Feb 2012 16:30:11 GMT

Acabo de publicar otro post relacionado con las ‘Parallel Series’. Os dejo aquí también el enlace:

http://lluisfranco.com/2012/02/08/luces-camara-action/

Un saludo,

Nacen las Parallel Series

Lluis Franco — Wed, 08 Feb 2012 12:55:00 GMT

Como ya os prometí a algunos de vosotros, he empezado a publicar una nueva serie que promete ser la más larga de las que he publicado hasta ahora. El tema a tratar va a ser la programación paralela mediante la Task Parallel Library incorporada en .NET 4.0 y Visual Studio 2010.

Cuento con la ventaja de haber estado creando material durante el último año y medio, en el que he publicado algunos documentos, varios vídeos y hasta un webcast con los chicos de SecondNug. Todo este material y alguno más que tengo en mente formará parte de las Parallel Series, que serán publicadas en mi otro blog y no aquí, porque la publicación cruzada entre WordPress y Community Server es un autentico drama.

Sin embargo, prometo avisar aquí cada vez que publique un nuevo post se la serie. De momento tengo unos cinco o seis artículos publicados (la serie posiblemente llegará a los 20) y mi intención es ir publicando al menos uno por semana, y si puedo dos mucho mejor :-)

Os dejo con el índice de contenidos de la serie:

Índice de contenidos

Y algunos de los artículos ya publicados (y los que faltan):

Índice de contenidos de las Parellel Series

El Alfa (Prólogo)
Un poco de historia
Aclarando conceptos base
Video: 01 Bases
PLINQ: Parallel LINQ
Video: 02 PLINQ
Parallel static class
Video: 03 Parallel Class
Tasks, la 8ª maravilla
Video: 04 Tasks
Problemas de concurrencia
Video: 05 Concurrent collections
El depurador: Tu fiel amigo
Video: Debugging & profiling
Webcast con los chicos de SecondNug
Materiales y presentaciones de mis eventos
C# futures: async & await

Artículos relacionados

A medida que vaya publicando en el otro blog iré actualizando también este de aquí.

Un saludo!

PD – Me encantaría recibir feedback vuestro, así que se agradecerán comentarios de todo tipo (en el otro blog).

Materiales del Webcast de ayer sobre Programación Paralela

Lluis Franco — Wed, 30 Nov 2011 21:34:00 GMT

Edit (07/12/2011): Ya se ha publicado el webcast, por si algun insensato lo quiere ver.
(recomiendo 'Presentación de alta fidelidad de Microsoft Office Live Meeting'):
http://www.secondnug.com/EventosDesarrollo/tabid/57/Default.aspx

:-)
Hola de nuevo,Como ya os había anunciado anteriormente, ayer realizamos un webcast con los chicos de SecondNug sobre programación paralela.

Tengo que deciros que realmente me lo pasé como un enano, tanto que de hecho ya se me han ocurrido un par de ideas para otros eventos de este tipo :-D

En estos momentos todavía no se puede descargar el evento grabado aunque me comentan que es cuestión de pocas horas, de modo que en cuanto esté disponible editaré este post y os dejaré la dirección por si algún insensato se lo quiere descargar.

Por mi parte, como ha habido bastante gente que me ha preguntado por la presentación y -sobre todo- por el código, os dejo en enlace para que lo descarguéis y juguéis con él. Y si tenéis alguna mandarme un mensaje o mejor, un tweet ;)

En la solución he incluido algunos de los ejemplos que no dió tiempo de ver, como una comparativa secuencial versus paralelo al calcular la serie de FIbonacci, o algunos ejemplos sobre las colecciones concurrentes. Particularmente os recomiendo darle un vistazo al ejemplo de uso de las BlockingCollection.

No hay copyright de ningún tipo, así que podéis hacer con él lo que queráis (aunque si os apetece mandarme un jamón, no os diré que no :-P). En fin, espero que os sirva para introduciros en este apasionante mundo de la TPL.

Si no funciona el frame de arriba también podéis acceder haciendo click en este enlace.

Un saludo y nos vemos,

Sharpwhere over the rainbow…

Lluis Franco — Wed, 16 Feb 2011 16:55:37 GMT

…skies are blue :-)

Si, se que el título del post está ‘pillado’ con pinzas, pero de lo que trata este post es de “cómo utilizar una brocha para pintar el interior de un control con varios niveles de degradado“, o sea “pintar un control Label con los colores del arco iris” :-D

Que? Ya habéis terminado de reíros?

Pues ahora os cuento el porqué se me ha ocurrido todo esto: Resulta que un proyecto en el que estoy trabajando, se muestran unas barras de progreso de color azul que indican el % de realización de unos presupuestos. Después de mirarlas un rato y ver lo ‘sosas’ que quedaban, he pensado que le podía dar un toque de color, aprovechando que pronto va a ser el día del orgullo friki.

A que es bonito, verdad? :-)

Vale, pues hacer esto con WPF es trivial mediante GradientStops, pero, oooohhhh… este proyecto es WinForms. Pero tranquilos, el viejo y bueno namespace ‘System.Drawing.Drawing2D’ dispone de alguna sorpresa, como la clase ColorBlend, que permite definir un array de colores y posiciones para realizar degradados de colores. Anda mira, me ha salido un pareado! :-D

Total, que partiendo del evento Paint de cualquier control (en el que se obtienen como argumentos el contexto gráfico y el rectángulo del área a pintar), he creado una pequeña clase que permite especificar los distintos colores de degradado para el mismo:

public class MultiGradientRectangle

    public Graphics Graphics { get; set; }

    public Rectangle Rectangle { get; set; }

    public List<Color> ColorPoints { get; set; }

    public int PercentCompleted { get; set; }

    public MultiGradientRectangle(Graphics graphics, Rectangle rectangle)

        Graphics = graphics;

        Rectangle = rectangle;

        ColorPoints = new List<Color>();

    public void DrawMultiGradientRectangle()

        if (PercentCompleted == 0) return;

        if (ColorPoints.Count == 0) return;

        List<float> myPositions = new List<float>();

        float colordistance = 1f / (ColorPoints.Count - 1f);

        for (int i = 0; i < ColorPoints.Count; i++)

            myPositions.Add(colordistance * i);

        ColorBlend blend = new ColorBlend();

        blend.Colors = ColorPoints.ToArray();

        blend.Positions = myPositions.ToArray();

        using (LinearGradientBrush brush = new LinearGradientBrush(

            Rectangle, Color.Black, Color.White, 0, false))

            brush.InterpolationColors = blend;

            Graphics.FillRectangle(brush, Rectangle);

        //algo falta aquí... :-)

Ahora creamos un formulario con un control pictureBox (en realidad puede ser cualquiera) y nos suscribimos a su evento Paint.

public Form1()

    InitializeComponent();

    pictureBox1.Paint += pictureBox1_Paint;

void pictureBox1_Paint(object sender, PaintEventArgs e)

    drawMultiGradient(e.Graphics, e.ClipRectangle, 50);

private static void drawMultiGradient(Graphics g, Rectangle rect, int percent)

    MultiGradientRectangle mgrect = new MultiGradientRectangle(g, rect);

    mgrect.PercentCompleted = percent;

    mgrect.ColorPoints.Add(Color.Red);

    mgrect.ColorPoints.Add(Color.Orange);

    mgrect.ColorPoints.Add(Color.Yellow);

    mgrect.ColorPoints.Add(Color.LightGreen);

    mgrect.ColorPoints.Add(Color.Green);

    mgrect.DrawMultiGradientRectangle();

Así, podemos crear tantos puntos intermedios como queramos, sólo tenemos la limitación del buen gusto.

Sin embargo falta algo, verdad? Efectivamente, en la captura de pantalla puede verse perfectamente que las barras de progreso se ‘rellenan’ sólo hasta el porcentaje alcanzado. Si es un 0% no hay degradado, si es un 50% sólo hasta la mitad, y así…

Como veis, falta un fragmento de código en el método DrawMultiGradientRectangle. Os dejo como ejercicio mostrar únicamente el relleno hasta el % especificado mediante la propiedad ‘PercentCompleted’. A ver que solución es la más chula ;-)

Un saludo desde Andorra, nos vemos!

PD – Podéis decir lo que queráis acerca del diseño, se admiten todo tipo de críticas (otra cosa es que os haga caso :-P)

[HowTo] Obtener el valor de una propiedad de usuario en LDAP

Lluis Franco — Wed, 09 Feb 2011 10:44:33 GMT

El motivo

A raíz de una pregunta que me lanzó ayer mi colega Ricardo, hoy vamos a ver cómo obtener el valor de una propiedad de un usuario del directorio activo de la organización. Esto de por si, no tiene ningún secreto, basta con utilizar las clases contenidas en el namespace System.DirectoryServices. Lo que sí tenemos que tener muy claro, es el nombre de esa propiedad dentro del esquema del LDAP de nuestra organización.

Por ejemplo, para obtener el mail, la propiedad a utilizar es mail, obvio, no? Sin embargo en otras ocasiones no siempre es así. Por ejemplo, el nombre de la propiedad que nos devuelve el teléfono de un usuario es telephoneNumber, el código postal es postalCode, pero por ejemplo la propiedad que nos devuelve los apellidos, no es surname, sino sn, o el nombre del usuario está definido como sAMAccountName. En resumen, muchas de las propiedades están definidas con unos nombres… como decirlo? Muy cachondos :-P

Obtener los atributos de una clase

A todo esto ¿Cómo podemos obtener los nombres de los atributos de un usuario del LDAP en tiempo de ejecución? Easy –> Buscando la definición de la clase user en el esquema de nuestro LDAP y obteniendo su catálogo de propiedades (básicas + extendidas):

public static List<string> GetUserLDAPProperties(string LDAPUrl)

    List<string> properties = new List<string>();

    ActiveDirectorySchema adSchema = ActiveDirectorySchema.GetCurrentSchema();

    ActiveDirectorySchemaClass userSchema =

        default(ActiveDirectorySchemaClass);

    ActiveDirectorySchemaPropertyCollection propertiesCollection =

        default(ActiveDirectorySchemaPropertyCollection);

    userSchema = adSchema.FindClass("user");

    propertiesCollection = userSchema.MandatoryProperties;

    foreach (ActiveDirectorySchemaProperty prop in propertiesCollection)

        properties.Add(prop.Name);

    propertiesCollection = userSchema.OptionalProperties;

    foreach (ActiveDirectorySchemaProperty prop in propertiesCollection)

        properties.Add(prop.Name);

    return properties;

De este modo obtenemos los nombres de las propiedades, con lo que ya sabemos los nombres de los atributos de un usuario de nuestro LDAP. Así pues, a partir del nombre de la propiedad que deseamos obtener, del identificador de seguridad de un usuario, y del nombre del dominio, ahora si vamos a ser capaces de obtener el valor de ese atributo para un usuario de nuestro LDAP (siempre que tenga ese atributo definido, claro):

public static string GetNTAccountProperty(string sid, string domain, string propertyToLoad)

    if (string.IsNullOrEmpty(sid)) throw new ArgumentNullException();

    if (string.IsNullOrEmpty(domain)) throw new ArgumentNullException();

    if (string.IsNullOrEmpty(propertyToLoad)) throw new ArgumentNullException();

    string ldapDomainName = GetLDAPDomainName(domain);

    using (DirectoryEntry entries = new DirectoryEntry(ldapDomainName))

        string filter = string.Format(

            "(&(objectCategory=person)(objectClass=user)(objectSID={0}))", sid);

        DirectorySearcher searcher = new DirectorySearcher(entries, filter);

        searcher.PropertiesToLoad.Add(propertyToLoad);

        searcher.PropertiesToLoad.Add("objectSID");

        SearchResult result = searcher.FindOne();

        if (!result.Properties.Contains(propertyToLoad))

            throw new ActiveDirectoryObjectNotFoundException(

                string.Format("Property '{0}' not found on NTAccount '{1}'",

                propertyToLoad, sid));

        return result.Properties[propertyToLoad][0].ToString();

Métodos de apoyo

Muchas de éstos métodos utilizan el nombre de nuestro LDAP en el siguiente formato: LDAP://DC=local,DC=miempresa,DC=com

Así que aquí tenéis una función que lo obtiene a partir del nombre del dominio:

public static string GetLDAPDomainName(string domainName)

    StringBuilder sb = new StringBuilder();

    if (string.IsNullOrEmpty(domainName)) throw new ArgumentNullException();

    string[] dcItems = domainName.Split(".".ToCharArray());

    sb.Append("LDAP://");

    foreach (string item in dcItems)

        sb.AppendFormat("DC={0},", item);

    return sb.ToString().Substring(0, sb.ToString().Length - 1);

Que a su vez se obtiene de este otro método:

public static string GetDomainName()

    return IPGlobalProperties.GetIPGlobalProperties().DomainName;

Proyecto de ejemplo

Hay algunas cosillas más, como la obtención de los usuarios del LDAP que (para no hacer el post más ‘tocho’ :-P) no hemos visto en el post. Podéis descargar el proyecto de ejemplo completo desde skydrive en esta ubicación:

http://cid-f3a970280830b5fe.office.live.com/self.aspx/MSDN%20Samples/TestLDAP.zip

Uffff… al final me ha salido un post más largo de lo que yo quería, pero bueno, espero que os sirva de algo :-)

Saludos desde Andorra,

[Debate] Nombre de Namespaces en métodos extensores ¿Y tu que opinas?

Lluis Franco — Thu, 13 Jan 2011 12:19:00 GMT

Ayer, a raíz de un post del colega Javier Torrecilla sobre métodos extensores, unos cuantos de nosotros entre los que estaban el propio Javier y Jorge Serrano nos enzarzamos en una discusión en twitter acerca del mejor modo de declarar nuestros métodos extensores.

Pongamos un ejemplo: Supongamos que queremos crear un método extensor para comprobar si un valor está entre dos valores (el clásico between de toda la vida).

Agrego una clase llamada ExtensionMethods a mi proyecto, o a otro proyecto mi solución y agrego este código:

namespace CustomExtensions

    public static class ExtensionMethods

        public static bool Between<T>(this T @value, T min, T max) where T : IComparable<T>

            return @value.CompareTo(min) >= 0 && @value.CompareTo(max) <= 0;

Suponiendo que estamos en un proyecto de tipo WinForms, si queremos utilizar este método extensor sobre un valor de tipo int basta con ir a cualquier formulario y llamar al método between sobre un valor de este tipo. Por ejemplo:

Oops! Que pasa? Por que no aparece el método extensor? Bueno, como ya os habréis dado cuenta el método extensor está declarado dentro de un namespce llamado ‘CustomExtensions’, que es distinto al namespace del formulario en el que lo estoy probando, con lo que no podemos usarlo directamente si previamente no hacemos un using:

using CustomExtensions;

Vale, ahora si que aparece:

Bien. Esto en si no es nada del otro mundo, pero la cuestión es que si deseamos evitar declarar el using (tenéis que pensar que este método extensor lo podéis reutilizar en 1000 proyectos distintos), no tenemos otra opción que:

Declarar el método extensor en un namespace que se llame igual que el namespace en el que se va a usar.
Declarar el método extensor en un namespace que se llame igual que el namespace del tipo que estamos extendiendo.
Pasar de todo y llamarlo al namespace como queramos, y que a la hora de usarlo debamos usar un using para agregarlo.

Particularmente, al extender tipos básicos (string, int) soy partidario del segundo punto, de modo que si vamos a extender elementos de tipo IComparable, en lugar de usar el namespace ‘CustomExtensions’ prefiero usar el nombre del namespace que contiene la definición de este tipo, o sea ‘System’:

namespace System

    public static class ExtensionMethods

        public static bool Between<T>(this T @value, T min, T max) where T : IComparable<T>

            return @value.CompareTo(min) >= 0 && @value.CompareTo(max) <= 0;

Pero ese es mi punto de vista, tu que opinas? Twitteros manifestaos! :-)