Materials event Office365 Rest API

O365

Hola de nou,

Us deixo els materials de l’event que vàrem fer divendres passat sobre la nove API Rest per accedir a Office365. Val a dir que tot i que li falten un parell de funcionalitats (que vindran en els propers mesos) per fi tenim una alternativa plenament funcional als antics Exchange Web Services (EWS). Amb l’avantatge de que és més molt més rápida (x20 com a mínim).

O365RestApiLogin

És important senyalar que el trick és paginar entre els resultats que ens retorna la API, com varem veure en el projecte d’exemple:

public static async Task<IEnumerable<Contact>> GetContacts()
{
    var cnames = new List<Contact>();
    var page = 0;
    var client = await EnsureClientCreated();
    var contactsResults = await client.Me.Contacts.Where(p => p.DisplayName != null).ExecuteAsync();
    var cl = contactsResults.CurrentPage.ToList();
    cnames.AddRange(addContactsCurrentPageToList(cl));
    while(cl.Count > 0)
    {
        page++;
        contactsResults = await client.Me.Contacts.Where(p => p.DisplayName != null).Skip(50 * page).ExecuteAsync();
        cl = contactsResults.CurrentPage.ToList();
        cnames.AddRange(addContactsCurrentPageToList(cl));
    }
    return cnames;
}

private static List<Contact> addContactsCurrentPageToList(
    List<IContact> contactsResults)
{
    var contacts = new List<Contact>();
    contacts.AddRange(contactsResults.Select(p => new Contact()
    {
        BusinessPhone1 = p.BusinessPhone1,
        CompanyName = p.CompanyName,
        DisplayName = p.DisplayName,
        EmailAddress1 = p.EmailAddress1,
        HomePhone1 = p.HomePhone1,
        JobTitle = p.JobTitle,
        Manager = p.Manager,
        MobilePhone1 = p.MobilePhone1,
        Title = p.Title
    }));
    return contacts;
}

O365RestAPiContracts

Aquí teniu el projecte publicat al meu Onedrive.

Enjoy! :)

Webcast: Mejora el rendimiento con Programación Paralela

El próximo 29 de Noviembre montaremos un webcast con los chicos de SecondNug sobre programación paralela.

banner_parallel

La idea es empezar mostrando el porqué de la programación paralela: Que es? Cómo hemos llegado a esta singularidad? Y en que casos puede sernos útil -que son muchos más de los que os podéis imaginar-. Además, como vais a ver en el webcast esto cada vez va a ir a más. Y no sólo a largo plazo… pero no os quiero avanzar mucho más, mejor ya lo veréis :-D

image image

A partir de las 19h30 empezaremos nuestro viaje por las principales características de la nueva Task Parallel Library (TPL). Comenzaremos por una breve introducción para asentar algunos conceptos (y para picaros el gusanillo), y posteriormente pasaremos a hacer demos por un tubo. Que al fin y al cabo somos developers y es lo que nos gusta!

foro_parallel

Puedes registrarte aquí:
https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032498453&Culture=es-AR 

Nos vemos pronto,

L

PD – Mi idea era llamarlo ‘Paralelízate o muere’ pero tal vez era un poco demasiado bestia… o no? Júzgalo tu mismo :-)

Sharpwhere over the rainbow…

…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.

mojo1

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

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.

GetPropADUser

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);
    }
    properties.Sort();
    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,

[Video] Parallel Series 01–Bases

Hola a tots,

Acabo de publicar un preview del primer dels (al menys) 6 vídeos sobre programació paral·lela amb .NET Framework 4.0.

De moment el podeu trobar aquí a youtube (encara no està publicat a Channel9), ja que encara és possible que canvií alguna cosa.

Com és el primer de la sèrie us agrairia una mica de feedback, que us sembla, coses a millorar, etc.

Merci i espero que us agradi :-)

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

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:

EM1

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:

Vale, ahora si que aparece:

using CustomExtensions;

EM2

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:

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

Particularmente 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! :-)

Redimensionar imágenes, convertirlas a byte array y viceversa (con transparencia)

El título del post es algo largo, pero resume un problema que me volvía de cabeza desde hace un tiempo, y que no era capaz de resolver… hasta hoy.

Cuando trabajamos con imágenes en una aplicación suele ser muy común almacenarlas en una base de datos. En el caso que me ocupa, al ser imágenes con una resolución bastante alta, un requisito es que éstas deben almacenarse a distintas resoluciones. Sin embargo, antes de continuar con el tema permitidme un paréntesis:

<PARENTESIS MODE = “on”>

Sé que existen bastantes detractores de ésta práctica, que suelen preferir guardar las imágenes en disco, pero esto a mi juicio conlleva una serie de inconvenientes:

  1. Pérdida de atomicidad: Mezclamos un sistema transaccional con un sistema de ficheros no transaccional (y no, de momento no recomiendo usar transacciones en el sistema de ficheros, al menos si no queréis quedaros calvos en el proceso). De modo que como no disponemos de un mecanismo transaccional, debemos implementar mecanismos de sincronización ‘a manija’ entre la base de datos y el sistema de ficheros, con todo lo que conlleva.
  2. Problemas al hacer copias de seguridad: Ya que mediante el SQL Server agent podemos planificar copias periódicas de la base de datos, pero no de los ficheros asociados. Así pues, hay que copiar los ficheros manualmente o lanzando un proceso desde nuestra aplicación.
  3. También suele argumentarse que si guardamos las imágenes en la base de datos, el tamaño de la base de datos puede incrementarse mucho y degradarse el rendimiento (recordar que SQL Server Express ‘sólo’ admite bases de datos de hasta 10GB). Esto no es cierto, ya que desde la versión 2008 existe la posibilidad de utilizar FILESTREAM, que permite almacenar los datos de un campo en el sistema de ficheros, obteniendo así lo mejor de ambos mundos.

<PARENTESIS MODE= “off”>

Vale, sigamos con el tema.

Como os decía, en el proyecto que me ocupa actualmente un requisito muy importante es almacenar distintas resoluciones de una imagen en la base de datos mediante FILESTREAM. Para ello, hay que redimensionar cada una de las imágenes y convertirlas en un array de bytes, para luego almacenarlas en un campo de tipo BLOB, concretamente varbinary(MAX). Posteriormente cuando queremos recuperar una imagen, se lee el array de bytes y se transforma otra vez en imagen para visualizarla por pantalla, imprimirla, o lo que sea…

Redimensionar imagenes

Cuál es el problema entonces? Existen multitud de ejemplos en Internet acerca de cómo redimensionar imágenes:

public Image ResizeImage(Image oldImage, int targetHeightSize)
{
    Size newSize = calculateDimensions(oldImage.Size, targetHeightSize);
    using (Bitmap newImage = new Bitmap(newSize.Width, newSize.Height,
        PixelFormat.Format24bppRgb))
    {
        using (Graphics canvas = Graphics.FromImage(newImage))
        {
            canvas.SmoothingMode = SmoothingMode.AntiAlias;
            canvas.InterpolationMode = InterpolationMode.HighQualityBicubic;
            canvas.PixelOffsetMode = PixelOffsetMode.HighQuality;
            canvas.DrawImage(oldImage, new Rectangle(new Point(0, 0), newSize));
            using (MemoryStream m = new MemoryStream())
            {
                newImage.Save(m, ImageFormat.Jpeg);
                return (Image)newImage.Clone();
            }
        }
    }
}

El código anterior funciona bien en casi todos los casos, pero no cuando la imagen a redimensionar contiene partes transparentes, ya que las partes transparentes aparecen en negro. Esto es así porque la información de transparencia de una imagen se almacena en el canal alfa, y en el código anterior al crear el nuevo Bitmap estamos usando explícitamente el valor ‘Format24bppRgb’ de la enumeración PixelFormat, que almacena 8 bits para cada color primario.

images_fail

En su lugar, debemos utilizar el valor ‘Format32bppRgb’ que almacena 8 bits para cada color primario más 8 bits para el canal alfa. También podemos omitir el formato en el constructor y pasar sólo el ancho y alto, ya que por defecto se usará el valor ‘Format32bppRgb’ en caso que no sea suministrado.

De todos modos, el código anterior es sólo a efectos de ilustrar el ejemplo, ya que para redimensionar una imagen es mucho más sencillo usar el método ‘GetThumbnailImage’ de la clase ‘Image’:

public static Image ResizeImage(this Image oldImage, int targetSize)
{
    Size newSize = calculateDimensions(oldImage.Size, targetSize);
    return oldImage.GetThumbnailImage(newSize.Width, newSize.Height, () => false, IntPtr.Zero);
}

Convirtiendo imágenes a bytes y viceversa

También existen multitud de ejemplos acerca de convertir imágenes a matrices y a la inversa. Veamos algunos ejemplos:

1) Mediante un MemoryStream: en este ejemplo se vuelca la imagen en un stream en memoria, y posteriormente se transforma en un array.

public static byte[] ConvertImageToByteArray(System.Drawing.Image imageIn)
{
    using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
    {
        imageIn.Save(ms, ImageFormat.Jpeg);
        return ms.ToArray();
    }
}
public static Image ConvertByteArrayToImage(byte[] byteArrayIn)
{
    using (System.IO.MemoryStream ms = new System.IO.MemoryStream(byteArrayIn))
    {
        Image returnImage = Image.FromStream(ms);
        return returnImage;
    }
}

Resultaría muy sencillo si no fuese porque al convertir la imagen a un array volvemos a tener el problema de las transparencias.

2) Otro método es utilizar código unsafe para copiar literalmente los bits de la imagen a un array:

private unsafe byte[] BmpToBytes_Unsafe(Bitmap bmp)
{
    BitmapData bData = bmp.LockBits(new Rectangle(new Point(), bmp.Size),
        ImageLockMode.ReadOnly,
        PixelFormat.Format32bppArgb);
    int byteCount = bData.Stride * bmp.Height;
    byte[] bmpBytes = new byte[byteCount];
    Marshal.Copy(bData.Scan0, bmpBytes, 0, byteCount);
    bmp.UnlockBits(bData);
    return bmpBytes;
}
       
private unsafe Bitmap BytesToBmp_Unsafe(byte[] bmpBytes, Size imageSize)
{
    Bitmap bmp = new Bitmap(imageSize.Width, imageSize.Height);
    BitmapData bData = bmp.LockBits(new Rectangle(new Point(), bmp.Size),
        ImageLockMode.WriteOnly,
        PixelFormat.Format32bppArgb);
    Marshal.Copy(bmpBytes, 0, bData.Scan0, bmpBytes.Length);
    bmp.UnlockBits(bData);
    return bmp;
}

Sin duda éste método ofrece un mayor rendimiento, y además al especificar el formato ‘Format32bppArgb’ nos soluciona el problema de las transparencias, pero resulta que nos crea otro problema: Para posteriormente poder revertir el array a imagen necesitamos conocer el tamaño de la imagen original, y eso no es demasiado práctico.

AL final la solución ha sido mucho más simple y porque no, mucho más elegante: Usando un simple TypeConverter.ConvertTo:

public static byte[] ConvertImageToByteArray(System.Drawing.Image imageIn)
{
    return (byte[])TypeDescriptor.GetConverter(imageIn).ConvertTo(imageIn, typeof(byte[]));
}

images_success

En fin, espero que si alguien ha estado en la misma situación que yo, al menos este post le resuelva un poco la vida :-)

Saludos desde Andorra a punto de cerrar el año,

HowTo: ¿Como saber si el usuario actual es administrador del dominio?

Nota: Es una pregunta que me encuentro de forma recurrente en los foros de desarrollo, así que lo apunto aquí para tener una referencia.

El escenario

Cuando desarrollamos una aplicación de escritorio, puede ser interesante saber a qué grupos pertenece el usuario que está ejecutando nuestra aplicación, para mostrar / ocultar / permitir / revocar ciertas acciones, u opciones. Por ejemplo, yo acostumbro a tener un botón en la barra de estado de mis aplicaciones que permite cambiar la cadena de conexión, y evidentemente, solo está visible cuando el usuario pertenece al grupo “Administradores del dominio”.

privileges_thumb

IsInRole

Para ello, el objeto WindowsPrincipal dispone de un método IsInRole, que nos dirà si un usuario pertenece a un grupo determinado. Genial, además este método tiene varias sobrecargas, de modo que podemos usarlo pasando el RID, SID, el nombre e incluso una constante basada en la enumeración WindowsBuiltIOnRole.

De modo que para saber si nuestro usuario es administrador local, basta con hacer esto:

WindowsPrincipal wp = new WindowsPrincipal(WindowsIdentity.GetCurrent());
return wp.IsInRole(WindowsBuiltInRole.Administrator);

Sencillo, verdad? A partir del usuario que ejecuta nuestra aplicación (válido también en caso de impersonación), creamos un objeto Principal e invocamos al método pasándole el grupo contra el que deseamos validar.

El problema de esta enumeración es que como su nombre indica, sólo contempla los grupos locales. Así que si queremos saber si pertenece a un grupo del dominio parece que tendremos que buscar el SID del grupo, o el nombre, y hardcodearlo ‘a mano’ en nuestra aplicación.

Feo verdad? Pues la verdad es que si, muy feo… vamos a investigar un poco más, a ver si encontramos otra forma.

Nota: Por motivos de rendimiento, para determinar la función del usuario se recomienda utilizar la sobrecarga de IsInRole(SecurityIdentifier) como sobrecarga preferible.

Ahora vamos a generar el SID del grupo de adminstradores del dominio y ya podemos volver a probar el método IsInRole:

WindowsPrincipal wp = new WindowsPrincipal(WindowsIdentity.GetCurrent());
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.AccountDomainAdminsSid, null);
return wp.IsInRole(sid);

Ops! Nuestro gozo en un pozo… se necesita informar el segundo argumento del constructor para el SID del grupo:

DomainSidError_thumb

DomainSid

¿Y que kkgrnn$# representa que es este identificador? Pues según pone en la ayuda del constructor, debe proporcionarse el SID del dominio para que el constructor pueda devolver algunos identificadores de WellKnownSidType, entre los cuales está el de los administradores del dominio.

Dicho de otro modo, o sabemos el SID de nuestro dominio o todo lo anterior no vale para nada… :-(

¿Y cómo podemos saber el SID de dominio? Después de buscar un ratito, lo único que he encontrado es una utilidad de consola llamada PsGetSid, que forma parte de las PSTools del inefable Mark Russinovich. Basta descargar esta utilidad y ejecutarla desde la consola de este modo para saber el SID de nuestro dominio (el nombre de dominio en formato “microsoft.com” o “net.volvo.com”):

DomainSidConsole_thumb

Sin embargo, me niego a tener que hacer esto para saber el identificador del dominio. Así que vamos a probar si podemos recuperar esta propiedad del esquema de AD mediante un DirectoryEntry. Para ello utilizaremos la clase Domain:

Domain d = Domain.GetDomain(new DirectoryContext(DirectoryContextType.Domain, getDomainName()));
using (DirectoryEntry de = d.GetDirectoryEntry())
{
    byte[] domSid = (byte[])de.Properties["objectSid"].Value;
    string sdomainSid = sIDtoString(domSid);
    Console.WriteLine(sdomainSid);
}

Aquí necesitaremos dos funciones de apoyo, la primera nos devuelve el nombre del domino, y la segunda transforma el array de bits del SID en su representación textual:

public static string getDomainName()
{
    return IPGlobalProperties.GetIPGlobalProperties().DomainName;
}

public static string sIDtoString(byte[] sidBinary)
{
    SecurityIdentifier sid = new SecurityIdentifier(sidBinary, 0);
    return sid.ToString();
}

A todo esto el valor de la variable sdomainSid es el esperado!!! :-D

Poniéndolo todo junto

Al igual que el alegre bandolero, también soy un fanático de los métodos extensores, así que vamos a encapsular todo esto en un método que extienda la clase WindowsIdentity. Aquí va todo el código junto:

using System.DirectoryServices;
using System.DirectoryServices.ActiveDirectory;
using System.Net.NetworkInformation;
using System.Security.Principal;
 
namespace Alpha.Code
{
    public static class SecurityExtensions
    {
        public static bool IsDomainAdmin (this WindowsIdentity identity)
        {
            Domain d = Domain.GetDomain(new
                DirectoryContext(DirectoryContextType.Domain, getDomainName()));
            using (DirectoryEntry de = d.GetDirectoryEntry())
            {
                byte[] bdomSid = (byte[])de.Properties["objectSid"].Value;
                string sdomainSid = sIDtoString(bdomSid);
                WindowsPrincipal wp = new WindowsPrincipal(identity);
                SecurityIdentifier dsid = new SecurityIdentifier(sdomainSid);
                SecurityIdentifier dasid = new SecurityIdentifier(
                    WellKnownSidType.AccountDomainAdminsSid, dsid);
                return wp.IsInRole(dasid);
            }
        }
 
        public static string getDomainName()
        {
            return IPGlobalProperties.GetIPGlobalProperties().DomainName;
        }
 
        public static string sIDtoString(byte[] sidBinary)
        {
            SecurityIdentifier sid = new SecurityIdentifier(sidBinary, 0);
            return sid.ToString();
        }
    }
}

Y la forma de usarlo es tan sencilla como esto:

if (WindowsIdentity.GetCurrent().IsDomainAdmin())
{
    //Acciones a realizar si el usuario es administrador de dominio...
}

Un saludo desde las frías tierras de Andorra :-)

Materiales de la charla sobre computación paralela en BcnDev

Hola de nuevo,

Después de la charla del viernes en BCNDEV, lo prometido es deuda. Os comenté que había realizado las demos en forma de un pequeño proyecto web, para no tener que ir con un pedazo-de-pepino a hacer las demos (más que nada porque no lo tengo :-P). Así que sólo quiero dejaros el enlace al proyecto que usé para las demos de la TPL, por si alguno las quiere probar:

http://cid-f3a970280830b5fe.office.live.com/embedicon.aspx/AndorraDotNet/Events/DemoParallelWeb.zip

Os recuerdo que si el proyecto lo probáis en una máquina virtual poco paralelismo vais a ver, pero publicarlo en el host o en cualquier estación con varios cores y veréis la diferencia de rendimiento. En algunos casos no hay mucha ganancia, pero en algunos otros la diferencia es de 5 a 1 o más.

Aprovecho para dejaros la versión más reciente de la presentación, y os prometo que no la voy a actualizar más :-) que bastante lo he hecho en los últimos días:

Saludos a todos,

HowTo: Crear una pantalla de inicio (splash screen)

Nota: Otro post en respuesta a una pregunta bastante habitual en los foros MSDN: ¿Cómo crear una pantalla de inicio para mi aplicación?

He creado un pequeño proyecto de ejemplo, que pueda servir como plantilla base para que cada uno se lo personalice para su aplicación. Este proyecto tiene lo básico: Un formulario sin bordes con una imagen, una barra de progreso, una etiqueta para el título, otra para ir mostrando mensajes, y un botón por si se desea cancelar la carga del programa (al estilo Office 2010).

SplashScreen

Él proyecto es muy sencillo y lo podéis descargar desde aquí:

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

La pantalla de inicio utiliza un thread para mostrar los diferentes mensajes al cargar, ya que así no se bloquea la aplicación (y la barra de progreso). Esto es así porque en el proyecto de ejemplo, al cargar la pantalla de inicio se lanza un segundo hilo que llama a un método ‘initApplication’, y desde éste método simulamos varios procesos largos (en realidad de un segundo cada uno), y cada vez que se inicia uno de ellos hay que cambiar el mensaje:


public void initApplication()
{
    Thread.Sleep(DEFAULT_TIME);
    this.Invoke((MethodInvoker)(() => setMessage("Searching for updates...")));
    Thread.Sleep(DEFAULT_TIME);
    this.Invoke((MethodInvoker)(() => setMessage("Connecting to database...")));
    Thread.Sleep(DEFAULT_TIME);
    this.Invoke((MethodInvoker)(() => setMessage("Connecting to services...")));
    Thread.Sleep(DEFAULT_TIME);
    this.Invoke((MethodInvoker)(() => setMessage("Loading settings...")));
    Thread.Sleep(DEFAULT_TIME);
    this.Invoke((MethodInvoker)(() => setMessage("Loading user preferences...")));
    Thread.Sleep(DEFAULT_TIME);
    this.Invoke((MethodInvoker)(() => setMessage("Starting application...")));
    Thread.Sleep(DEFAULT_TIME);
    if (this.InvokeRequired) this.Invoke(new Action(finishProcess));
}

Recordar que desde un hilo que no sea el hilo principal, en .NET no se puede actualizar la interfaz de usuario directamente. En su lugar debemos usar el método Invoke. En el ejemplo anterior llamamos a un método ‘setMessage’ que se encarga de mostrar el texto en la etiqueta correspondiente. Para poder llamar a este método mediante Invoke tenemos dos opciones: Podemos usar un MethodInvoker o un Action, en nuestro caso usaremos el primero, ya que un Action se usa cuando no hay paso de parámetros, y este método precisa de un parámetro con el mensaje a mostrar:

public void setMessage(string msg)
{
    messageLabel.Text = msg;
}

Una vez finalizado el proceso de carga, se cierra el formulario y se devuelve un DialogResult = Ok. Por otro lado si en cualquier momento de la carga el usuario ha pulsado el botón ‘close’, se hace lo mismo pero devolviendo un DialogResult = Cancel:

private void finishProcess()
{
    this.DialogResult = System.Windows.Forms.DialogResult.OK;
    this.Close();
}

void closeButton_Click(object sender, EventArgs e)
{
    this.DialogResult = System.Windows.Forms.DialogResult.Cancel;
    this.Close();
}

Como veis el proyecto es muy sencillo, sólo debéis recordar un detalle importante: En una aplicación WinForms el punto de entrada a la misma se define en el método estático Main del Program.cs, y aquí hay una línea que inicializa el formulario inicial de nuestra aplicación:

Application.Run(new fMain());

Lo primero que solemos pensar es que aquí deberíamos lanzar el formulario fSplashScreen, y al cerrarlo mostrar el formulario principal, verdad? Pues no, no podemos hacer eso. El motivo no es otro que este formulario inicial va a definir el ciclo de vida de nuestra aplicación, y si lo cerramos, cerramos la aplicación. Ya se que en VB puede cambiarse este comportamiento, pero entre nosotros… hacerlo siempre me ha parecido una chapuza :-)

Así pues, aquí lanzaremos el formulario principal, y éste, al cargarse (mientras todavía no es visible) lanzará la pantalla de inicio de forma modal y esperará el valor de retorno. Si al cerrarse la pantalla de bienvenida el valor de retorno es Ok, continúa la carga y muestra el formulario principal, en caso contrario cierra el formulario principal y con por ende la aplicación:

void fMain_Load(object sender, EventArgs e)
{
    showSplashScreen();
}

private void showSplashScreen()
{
    using (fSplashScreen fsplash = new fSplashScreen())
    {
        if (fsplash.ShowDialog() == System.Windows.Forms.DialogResult.Cancel)
            this.Close();
    }
}

Espero que sirva como ejemplo a todos aquellos que desean tener una pantalla de inicio para sus aplicaciones.
Un saludo!

Andorra, Noviembre 2010