El blog de Lluis Franco : 2008

Windows Server 2008 R2 RTM (y también Windows 7!)

lfranco — Thu, 23 Jul 2009 09:13:00 GMT

Acabo de leer en el blog del equipo de Windows Server que hoy la R2 del 2008 ha alcanzado el estado RTM (Release to Manufacturing), de modo que el producto ya está listo par enviar a fábrica. Se espera que en unos días esté disponible para partners en MSDN y TechNet, posteriormente para Partners y finalmente para el gran público:

Las fechas son:

MSDN/Technet: W7 Aug 6, R2 Aug 14
Partner Network: W7 Aug 16, R2 Aug 19
Action Pack: Aug 23 (W7 & R2)
Volume Licensing (SA): W7 Aug 7, R2 Aug 19

Tengo muchas ganas de probar las nuevas capacidades de virtualización, espero poder escribir sobre ellas en los días siguientes a su publicación, siempre que el project se respete y pueda dedicarme un poco a I+D, que últimamente no me han dado demasiado tiempo.

Os dejo con el artículo original:

Wednesday, July 22, 2009 6:40 AM WindowsServer

Windows Server 2008 R2 Reaches the RTM Milestone!

The acronym stands for Release to Manufacturing, and it means this latest release of Windows Server 2008 R2 is now blessed by engineering as ready for the manufacturing process. We're talking final code. Sun shining, birds singing, children dancing in the streets.

With evaluation software available for download in the first half of August and the full product available to customers with Software Assurance in the second half of August, RTM is more than just an engineering milestone. Occurring in lock-step with the release of the Windows 7 RTM, these two platforms are now ready for our partners to start testing and installing on their hardware. And that lock-step isn't a coincidence, it's a design goal.

Customers using Windows Server 2008 R2 and Windows 7 in their enterprises has been Microsoft's intent from the first day programmers touched fingers to keyboards. Let's look at the highlights:

HAPPY ADMINISTRATORS

It's Christmas for server and desktop administrators with Windows Server 2008 R2's updated management tools, including:

Hyper-V and Live Migration - still the big stars. R2's Hyper-V enables a complete server virtualization solution available out-of-the-box. Live Migration allows server administrators to migrate VMs between physical machines with no perceived downtime for current server connections and work streams. That means a more dynamic datacenter and more agility in meeting new business needs For more information on Hyper-V in R2, check out today's in-depth post on the Virtualization Team blog.
File Classification Infrastructure - FCI lets you manage your data based on its characteristics, including things like file type, user credentials and even content. Based on this kind of criteria, FCI can assign data different access restrictions, store it in different locations or simply push it into an entirely customized lifecycle scheme - all done automatically via policy. For me, this is one of the most exciting new features in R2.
Active Directory and Pervasive PowerShell - 240 new PowerShell cmdlets and several management consoles (including a new Active Directory interface) have been built on top of PowerShell. Active Directory has also been enhanced with the Active Directory Recycle Bin as well as AD Group Policy objects that give desktop administrators deeper capabilities when it comes to managing Windows 7 clients.
IIS 7.5 - The latest edition of Internet Information Server also sports updated management tools as well as application serving capabilities that now including support for PHP and .NET on Server Core installations.
Server Scalability - Not only is R2 Microsoft's first 64-bit-only operating system, it also supports up to 256 logical processors in a single server as well as all the latest CPU technologies. And, R2 has support for advanced storage technologies, including SAN management and solid state hardware.

HAPPY USERS

I'll leave it to the Windows 7 team to evangelize the many advantages that Windows 7 has as a standalone operating system (click here for the Windows 7 RTM announcement). But we server guys love it because combined with Windows Server 2008 R2 we can provide features I've never seen before in another client-server platform.

DirectAccess, for example, provides secure, always-on access to corporate networks no matter from what network a client might be connecting. Better yet, it provides a two-way relationship allowing desktop admins to manage clients the same way whether they're local or remote.
BranchCache allows users in remote offices to cache corpnet data locally, providing a better work experience for remote workers while simultaneously lowering expensive WAN bandwidth costs.
Remote Desktop and Applications - Windows Server 2008's Terminal Services has now evolved into R2's Remote Desktop Services, and it integrates so tightly with Windows 7 that administrators will be able to roll out virtualized applications and even entire desktop environments without users being able to tell that these tools aren't running locally. It's fast and can even be managed via policy. Very cool stuff.

LOWER BUDGETS

Power efficiency and power management were priorities for R2. The power efficiency improvements help you save power automatically - without additional steps or configuration. An improved processor power management engine, storage power management improvements, tick skipping, core parking, and timer coalescing all contribute to improved power efficiency.

While licensing topics are a bit arcane, those of you already running Windows Server 2008 should know that you don't need new Client Access Licenses (CALs) when updating to Windows Server 2008 R2, which helps make for a cost-effective upgrade.

I'm out of space and have only scratched the surface of what you'll find in R2. You can follow the buzz about R2 and Windows 7 on Twitter via the #Windows hashtag.

For those evaluating the software for near-term deployment, make sure to visit the Windows Server 2008 R2 Resource Center, our TechNet Resource Center as well and also our Application Compatibility page. And as always, send us your feedback when you're testing the software. Happy testing,

--Oliver Rist

Technical Product Manager

** crossposting desde el blog de Lluís Franco en geeks.ms **

LINQ to SQL (SQL compaq también existe!)

lfranco — Tue, 24 Feb 2009 12:58:00 GMT

Esta mañana mi colega de penurias Toni Sala me preguntaba acerca de las posibilidades de usar LINQ to SQL con bases de datos SQL Compaq. Efectivamente, se puede hacer, es algo que probé en su momento y no había utilizado más. Sin embargo, lo que si que recordaba era que no es tan evidente como con sus hermanos mayores.

Bueno, al lío. Para este ejemplo vamos a usar la BD de ejemplo Northwind.sdf que instala Visual Studio 2008 (en mi caso la tengo ubicada en ‘C:\Archivos de programa\Microsoft SQL Server Compact Edition\v3.5\Samples’).

Una vez creado el proyecto de ejemplo (en mi caso lo llamaré ‘SqlCompaqLINQ’), creamos una carpeta ‘Data’ dentro de nuestro proyecto y agregamos la BD a nuestro proyecto mediante ‘Project/Add existing Item’:

Hasta aquí todo normal, pero la diferencia de SQlCompaq respecto a sus hermanos mayores está en que si ahora creamos un DataContext e intentamos arrastrar una tabla sobre él, aparecerá un mensaje de error un poco descorazonador:

No pasa nada, para estos casos podemos ir directamente a la herramienta SqlMetal (ya sabéis lo del poder del metal :-P), y generar el correspondiente fichero DBML mediante la línea de comandos. Para ello abrimos la consola de Visual Studio y ejecutamos el siguiente comando (desde nuestra carpeta ‘Data’):

SqlMetal.exe Northwind.sdf /dbml:NorthwindCE.dbml

Esto generará el diseñador con las clases correspondientes a las tablas de la BD de SQL Compaq, que a continuación agegaremos a nuestro proyecto también mediante ‘Project/Add existing Item’:

Ahora basta con crear una instancia del diseñador, generar nuestra instrucción LINQ to SQL y ¡a jugar!:

using SqlCompaqLINQ.Data;

...

string path = "Data Source=|DataDirectory|\\Data\\Northwind.sdf";

using(Northwind dc = new Northwind(path))

    var customers = from c in dc.Customers

                    orderby c.CompanyName

                    select c;

    listBox1.DataSource = customers.ToList();

    listBox1.DisplayMember = "CompanyName";

    listBox1.ValueMember = "CustomerID";

Un saludo desde Andorra,

** crossposting desde el blog de Lluís Franco en geeks.ms **

Tip: Mostrar objetos relacionados en DevExpress GridControl

lfranco — Fri, 23 Jan 2009 12:15:00 GMT

:-)
Hola de nuevo,

Hoy os voy a mostrar un pequeño tip, muy útil si trabajáis con este fantástico control.

En muchas ocasiones nos encontramos con la necesidad de mostrar una serie de registros de una tabla, y también queremos mostrar información de otras tablas relacionadas. En estos casos existen varias soluciones: Leer los datos de ambas tablas con una instrucción JOIN en la base de datos y mostrar la información extendida en el grid, agregar a la vista un ‘ColumnEdit’ de tipo ComboBox o LookUpEdit y cargar los datos de la tabla relacionada, interceptar el evento ‘CustomColumnDisplayText’ de la columna y mostrar los valores que deseemos, y unos cuantos más que no comentaremos aquí.

Sin embargo existe una solución mucho más sencilla (aunque no he encontrado nada de documentación al respecto). Se trata de extender la propiedad FieldName de la columna siguiendo el esquema de nuestro DataContext (LINQ to SQL) o Model (LINQ to EF).

Partiendo de la base de que disponemos de un modelo o un contexto de datos como el siguiente:

Y deseamos obtener el resultado siguiente (observar que las columnas ‘Category’ y ‘Supplier’ muestran valores de las tablas relacionadas):

Pues es tan sencillo (*) como establecer la propiedad FieldName de la columna, escribiendo el nombre del campo completo incluyendo los nombres de los objetos relacionados (en nuestro caso Category.CategoryName y Supplier.CompanyName). Nota: Es posible extender esto encadenando las clases de nuestro modelo (yo por lo menos he llegado a encadenar hasta 4 tablas).

Y lo que más me gusta de esta solución respecto a las otras es que permite incluso el filtrado de los resultados, algo que cuando hacemos interceptando el evento ‘CustomColumnDisplayText’ no es posible.

En fin, si alguien no conocía este tip y usa este control, espero que le sea útil…

Saludos desde Andorra,

Nota: Olvidé mencionar que esta solución es idela para aquellos formularios de consulta, no en modo de entrada de datos (entonces usaríamos un LookUpEdit).

(*) Supongo que es necesario que esté activada la carga diferida, algo que en LINQ to SQL es así de forma predeterminada, aunque no en EF.

** crossposting desde el blog de Lluís Franco en geeks.ms **

Material del evento: Asentando las bases

lfranco — Tue, 30 Dec 2008 10:34:04 GMT

Ayer tuvimos el último evento del año en AndorraDotNet. Mientras llegan las fotos que hicieron algunos de los asistentes, aprovecho para publicar el material del evento, tanto la presentación como los proyectos de ejemplo.

La presentación la encontraréis aquí:

Y la solución de Visual Studio aquí:

Gracias por todo y nos vemos pronto!

** crossposting desde el blog de Lluís Franco en geeks.ms **

Series: Resumen de los enlaces

lfranco — Thu, 23 Oct 2008 08:24:52 GMT

Últimamente estoy recibiendo bastantes correos preguntándome cosas acerca de las series de posts que publiqué hace un tiempo. Os dejo aquí un resumen de los enlaces y el código fuente disponible en ellas. Ya estaba todo publicado pero de forma dispersa, así que aquí lo teneis todo juntito.

Aviso: Todas las series son ejemplos reales que muestran cómo realizar algunas de las tareas cotidianas (o no tanto) mediante C#. En ningún caso pretenden ser aplicaciones reales, de modo que deben tomarse como lo que realmente son: Meros ejemplos didácticos.

Acceder a la caché de Internet Explorer

Resumen:

Ejemplo de cómo crear un servicio de Windows que monitoriza la caché de archivos temporales de Internet Explorer y exporta un fichero log a una ubicación remota (por si el usuario decide vaciar la caché). Contiene ejemplos de cómo usar las API de acceso a la caché, cómo serializar objetos, realizar impersonation, y cómo crear y distribuir un servicio de Windows.

Artículos:

Acceder a la caché de Internet Explorer (I)
Acceder a la caché de Internet Explorer (II)
Acceder a la caché de Internet Explorer (III)
Acceder a la caché de Internet Explorer (IV)
Acceder a la caché de Internet Explorer (V)

Código de ejemplo:

Accediendo al directorio activo de la organización desde .NET

Resumen:

Ejemplo de cómo crear una aplicación Windows que accede al directorio activo de la organización. Contiene ejemplos de cómo validar unas credenciales (usuario y password) en un dominio, cómo realizar impersonation para ejecutar nuestra aplicación con los credenciales de otro usuario, recuperar los nombres de las propiedades del objeto user del AD, y cómo obtener información y los grupos a los que pertenece el usuario actual.

Artículos:

Accediendo al directorio activo de la organización desde .NET (I)
Accediendo al directorio activo de la organización desde .NET (II)
Accediendo al directorio activo de la organización desde .NET (III)
Accediendo al directorio activo de la organización desde .NET (IV)

ADO.NET Data Services – Entrevista en Channel 9

lfranco — Wed, 22 Oct 2008 07:40:27 GMT

En este vídeo, Beth Massi entrevista a Saaid Kahn (Program Manager de Visual Studio Pro Tools team) y nos muestra cómo crear aplicaciones de n capas usando ADO.NET Data Services (Astoria) y el Entity Data Model.

ADO.NET Data Services (Astoria) in Visual Studio 2008 SP1

Absolutamente recomendable darle una ojeada. Dura poco más de un cuarto de hora y vale la pena.

** crossposting desde el blog de Lluís Franco en geeks.ms **

El Guille community Tour 2008 pasó por Andorra…

lfranco — Fri, 17 Oct 2008 09:24:45 GMT

…y no he podido escribir nada hasta ahora… aisssss!

La verdad es que he estado missing durante unos dias debido a que tengo una punta de trabajo terrible. Espero volver a dar un poco más la vara tanto aquí como el los foros online, de los que también he estado un poco desconectado.

Pero a lo que iba: El pasado lunes 13 en AndorraDotNet tuvimos la suerte de poder contar con dos ponentes de lujo: El Guille y David Salgado de Microsoft. Guille nos habló de las novedades de VB 9.0 como no podía ser de otra manera, y hubieron muchos ‘piques’ entre los defensores de VB y de C#, con lo que nos reímos mucho.. David nos regaló una fantástica demo de cómo construir una aplicación Web mediante ASP.NET, en la que empezamos con una solución en blanco y fue creando poco a poco los diversos elementos del proyecto. Por cierto, que sepas que ya me la han pedido!!!

Al final de la sesión tuvimos el típico sorteo de regalos, en el que algunos afortunados se fueron con un regalo entre las manos.

La audiencia estuvo sobre las casi 60 personas con perfiles muy diferentes, y aunque me hubiese gustado ver más gente de empresa (ya os tiraré de las orejas a los que no pudísteis asistir) no estuvo nada mal. Por nuestra parte seguiremos trabajando intentando cambiar la situación del país, ya que sigue siendo muy difícil hacer ver a los empresarios que la formación es un recurso vital para la buena marcha de un negocio (si, parece mentira pero hay mucha gente que todavía no lo tiene claro). Si queremos avanzar no hay que escatimar en formación y en I+D. Es por el bien del país!

Un agradecimiento especial al colega Jan Arbona de TSCP por su colaboración en el evento, y por habernos tirado un cable en los momentos de estrés.
Gracias a todos y os espero en el próximo evento que ya estamos preparando!

** crossposting desde el blog de Lluís Franco en geeks.ms **

MVP Open Day 2008 - Game over

lfranco — Sun, 05 Oct 2008 13:17:52 GMT

Otra vez en el tren de vuelta a casa. No puedo dejar de experimentar una sensación de deja vu, como cada vez que viajo a Madrid en busca de aquellos que son como yo. Entenderme, no me considero un bicho raro ni mucho menos, lo que sucede es que vivo en un país de apenas 60.000 habitantes, un número que apenas llenaría la mitad de un estadio de fútbol moderno, y que la mayoría de pueblos grandes o ciudades pequeñas de España sobrepasan de largo. Joer, si Cuenca (con todo el respeto) tiene más habitantes :-)

Y claro, los números salen solos: De toda esta población hay poca gente del mundo de desarrollo de software, y menos todavía que tenga la misma pasión por el desarrollo que puedo tener yo. Sólo un pequeño pueblo de irreductibles galos resiste ahora y siempre al invasor. Bueno, no es exactamente así, pero seguro que me entendéis :-P. Me estoy refiriendo a que gracias a la gente del grupo de usuarios de andorradotnet, que comparte mi misma pasión por la plataforma .NET se me hace más llevadero el estar tan desconectado (físicamente, que no realmente) de otros profesionales del tema.

De este modo cuando voy a Madrid un par de veces al año, a uno de estos eventos en los que hay un nivelazo técnico importante, me hace disfrutar cada momento como un enano. Te pones a charlar con cualquiera sobre sobre arquitectura, características de nuestros lenguajes favoritos, favoritismos y manías que todos tenemos en nuestro trabajo, etc. Y como encima lo puedes hacer todo delante de una cerveza, hace que te sientas en el paraíso... Porque de eso se trata, somos tan freaks que cuando nos vamos de fiesta a tomar unas copas terminamos hablando de ciertas cosas que hacen que las mesas de al lado te miren con cara de "de dónde se han caído estos tíos". Eso si, lo pasamos como enanos, jejeje...

Pero no me quiero ir por las ramas, que esto de estar en el tren sin wifi, y con dos horas por delante puede hacer que se me valla la olla un rato. De hecho este post es para comentar lo requetebien que lo he pasado en el MVP Open Day de este año.

Hemos tenido de todo: Sesiones técnicas de las buenas, contacto directo con profesionales de todas las áreas de Microsoft (siempre tienes alguna pregunta para un experto en SQL Server, de Server System, etc.), te encuentras con viejos amigos y haces de nuevos, conoces gente nueva interesante. También saludas a la gente de la casa que ya conoces desde hace años, sales a tomar algo, acabas en la barra de un bar con dos (o tres) copas de más discutiendo de buen rollo con un colega acerca de si en este caso es mejor aplicar herencia o implementar interfaces, y vuelves al hotel con unas risas y habiendo aprendido un par de cosas.

Espero tener tiempo para ir desgranando algunas de las cosas que hemos visto en esta jornada, de momento os dejo con algunos de los momentos más interesantes de este evento. Ahora voy a seguir preparando los últimos detalles del próximo evento de andorradotnet dentro de 10 días.

Compañeros: Espero no tener que esperar otro año para veros de nuevo. Así que os amenazo con montar algún otro evento en andorradotnet para que subáis a verme o a dar alguna charla. Estáis avisados...

Ahora voy a dedicar 10 minutos a ver el paisaje a más de 300 Km/h y dejar volar la imaginación... nos vemos.

** crossposting desde el blog de Lluís Franco en geeks.ms **

Otro año más dando la vara

lfranco — Wed, 01 Oct 2008 16:24:03 GMT

Alguien de Microsoft se ha equivocado o le ha dado al botón que no era. Acabo de recibir un correo de mvpaward de dice así:

Enhorabuena. Nos complace presentarle el programa de nombramiento MVP de Microsoft® de 2009. Este nombramiento se concede a los líderes excepcionales de la comunidad técnica que comparten de forma activa su experiencia de alta calidad y de la vida real con otras personas.

Reconocido por MVP por 6º año consecutivo… WOW! No se si me lo acabo de creer… :-)

La verdad es que desde tuve la suerte de entrar en el programa (hace 6 pero parece que haga un siglo, por tal y cómo ha cambiado mi vida desde entonces :-P), he tenido la gran suerte de poder conocer un montón de gente fantástica, tanto dentro como fuera de Microsoft. Y a decir verdad está resultando una gran experiencia a nivel personal y profesional, ya que me ha permitido conocer profesionales como la copa de un pino, y además hacer amigos de los que duran toda una vida.

Además, mañana salgo para Madrid para participar en el MVP Open Day de este año, y tengo unas ganas tremendas de rencontrarme con todos los demás. En estos eventos las sesiones técnicas son impresionantes, pero es que además lo pasamos de miedo en las cenas, bautizos, etc.

Para muestra un botón:

Bautizo de un MVP:
http://es.youtube.com/watch?v=KNwA7QlvKvk

Fotos de varios eventos:
MVP Summit 2005 (27/09/2005 - 01/10/2005)
MVP Open day (19/05/2005 - 20/05/2005)
MVP Open day (11/11/2004 - 12/11/2004)
MVP Open Day (27/05/2004 - 28/05/2004)

Nos vemos en las comunidades online!
Saludos desde Andorra,

** crossposting desde el blog de Lluís Franco en geeks.ms **

Folder size: Primer contacto

lfranco — Fri, 08 Aug 2008 12:09:51 GMT

Harto de buscar dónde se iba el espacio de mi disco duro, y con la sensación de que estaba malgastando un porrón de bytes (y os aseguro que no es en peliXculas), me puse a diseñar una herramienta que me mostrase lo que ocupa cada una de las carpetas de mi ordenador. De esto hace un par de días, y la verdad es que me he liado la manta a la cabeza :-P y al final el resultado es este:

Está enteramente escrito en C# 3.0 y aunque el funcionamiento es más sencillo que el mecanismo de un botijo (al fin y al cabo sólo recorre una estructura de carpetas y va procesando archivos), el resultado me gusta. Para compensar su sencillez le he añadido una interfaz cool (al menos para mí :-P), multithreading en la búsqueda, que a su vez hace uso de llamadas al FindFirstFile y FindNextFile para mejorar la performance... Aunque seguro que mi amigo el rano, belmonte de pro, me dice que si quiero ver performance me deje de tonterías y vuelva al C++ duro. Y os juro y perjuro que ya no me acuerdo de cómo se cocinaba con punteros. Además el resultado puede imprimirse o también exportar a Excel o PDF, y también muestra una lista de posibles errores producidos durante el análisis de la(s) carpeta(s), que mayormente son de acceso a ciertos elementos de sistema (o ubicaciones de red con permisos NTFS).

Si a alguien le apetece probarlo os lo podéis instalar desde esta ubicación:

http://utilities.ordeeno.com/foldersize/

El único requisito es el Framework 3.5, y si no lo tenéis instalado el programa de instalación muy amablemente lo hará por vosotros (eso si, tarda un ratito).

La licencia es beerware, lo cual quiere decir que si te gusta y lo usas... deberás invitarme al menos a una cerveza. Y si es con papas, mejor que mejor!

Bye @ home,

PD - Lo he probado en XP y Vista Ultimate y de momento no le he encontrado ningún bug grave, pero si vosotros lo hacéis podéis contactar conmigo aquí.

** crossposting desde el blog de Lluís Franco en geeks.ms **

VBTeam - How Do I Videos (WPF Forms over Data)

lfranco — Fri, 18 Jul 2008 08:00:48 GMT

Beth Massi del equipo de VB, ha publicado nuevos videos en el sitio “How Do I” Videos — Visual Basic. En este caso se trata de dos videos que muestran cómo crear formularios basados en datos en Windows Presentation Foundation usando Visual Studio 2008.

How Do I: Create a Simple Data Entry Form in WPF?

#1 | How Do I: Create a Simple Data Entry Form in WPF?
(24 minutes, 32 seconds)

#2 | How Do I: Display Data in a List in WPF?
(11 minutes, 47 seconds)

El link en: http://msdn.microsoft.com/en-us/vbasic/bb466226.aspx#wpfdata

Si no conoceis el sitio “How Do I” Videos darle un vistazo, que merece la pena y mucho... :-)

** crossposting desde el blog de Lluís Franco en geeks.ms **

HowTo: LDAP, obtener propiedades de la clase user

lfranco — Wed, 16 Jul 2008 16:23:42 GMT

Hace poco publicaba una actualización del método getUserLDAProperties de la clase LDAPservices. Esta función se encarga de recuperar todas las propiedades de la clase 'user' definidas en el esquema del AD de la organización.

La verdad es que dicha corrección no me terminaba de satisfacer. Así que después de bucear un poco por el modelo de objetos del namespace System.DirectoryServices.ActiveDirectory he encontrado un método más elegante, y que además permite acceder a más propiedades opcionales (algo que la anterior versión no permitía).

Os dejo aquí el código y en cuando tenga un minuto actualizo el código fuente de LDAPServices en skydrive.

public static List<string>

    getUserLDAPProperties(string LDAPURL)

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

    ActiveDirectorySchema objADSchema = ActiveDirectorySchema.GetCurrentSchema();

    ActiveDirectorySchemaClass objADUserSchema;

    ActiveDirectorySchemaPropertyCollection objADPropertiesCollection;

    objADUserSchema = objADSchema.FindClass("user");

    objADPropertiesCollection = objADUserSchema.MandatoryProperties;

    foreach (ActiveDirectorySchemaProperty objADSchemaProperty in objADPropertiesCollection)

        properties.Add(objADSchemaProperty.Name);

    objADPropertiesCollection = objADUserSchema.OptionalProperties;

    foreach (ActiveDirectorySchemaProperty objADSchemaProperty in objADPropertiesCollection)

        properties.Add(objADSchemaProperty.Name);

    return (from p in properties orderby p select p).ToList();

Nos vemos!

** crossposting desde el blog de Lluís Franco en geeks.ms **

¿Goodbye Dictionary?

lfranco — Tue, 15 Jul 2008 09:07:45 GMT

Corrección al artículo (16/07/2008):

Todas las mediciones de tiempo efectuadas en las compartivas entre listas y diccionarios han sido mal efectuadas y no son válidas. Porqué? Porque a un servidor se le olvidó 'resetear' el cronómetro del StopWatch entre una medición y otra (ay, ay, ay...), de modo que los tiempos tomados para el objeto dictionary incluyen también los de la lista, y por eso son mucho mayores de lo esperado.

Un 'pequeño' olvido pero que afecta totalmente al sentido del post, ya que la conclusión del post era que acceder a un elemento de un diccionario NO era más rápido que acceder a un elemento de una lista, cuando la realidad es que SI lo es... y mucho. Siento haber publicado lo contrario y aquí me retracto.

De este error puedo sacar varias conclusiones:

Revisar: Acostumbrarme a revisar más en profundidad lo que publico. He usado infinidad de veces el objeto StopWatch y no es nuevo para mi, así que todavía me duele más haberme olvidado de reiniciar el crono... Muchas gracias por el comentario Steven.
No hacer tantas cosas al mismo tiempo: La verdad es que cuando escribí el post estaba haciendo varias cosas al mismo tiempo, entre las cuales me encontraba realizando unas pruebas para una aplicación, y al medir los tiempos me quedé muy sorprendido y empecé a escribir el post sin detectar el error en mi código.
Todos nos equivocamos: Eso es evidente, y cualquiera puede cometer un error como este. Lo malo es que en lugar de escribir el post rápidamente y publicarlo, debería haberlo dejado para revisarlo hoy... pero lo hecho hecho está.
Hay que aprender de los errores: Prefiero hacer algo y equivocarme a no hacer nada y no equivocarme. Con todo, espero aprender algo de todo esto, porque todos seguimos aprendiendo día a día (y malo del día que no lo hagamos).

Pero vamos con la corrección. Los nuevos tiempos si agregamos un watch.Reset(); antes de empezar a tomar los tiempos del diccionario son los siguientes:

Compare load 100000 items in List vs. Dict. (ms.)
List: 678,4068
Dict: 759,5071

Compare get one item by key in List vs. Dict. (ms.)
List: 0,3645
Dict: 0,0058

Compare verify one item by key in List vs. Dict. (ms.)
List: 0,2748
Dict: 0,0058

La conclusión es que cargar datos en un diccionario es sólamente un poco más lento que cargarlos en una lista. mientras que es mucho más rápido acceder a los elementos que contiene (del orden 50 veces más rápido aproximadamente). Evidentemente esto justifica sobradamente el uso de diccionarios.

Bueno... Tal vez el título del artículo ahora debería quedar como "¿Goodbye Dictionary? ¡Hola melón!" :-P

Saludos desde Andorra,

Fin de la corrección al artículo

El artículo original (15/07/2008):

Generics

La aparición del framework 2.0 nos trajo una grata sorpresa: La aparición de Generics, que nos proveía por fin de un conjunto de colecciones fuertemente tipadas, que mejoraban mucho el rendimiento al evitar el uso de boxing y unboxing, y permitían un código mucho más legible, elegante, así como detectar y prevenir muchos errores en tiempo de compilación.

Desde ,entonces, de todos los distintos tipos de colecciones genéricas, en el 90% de los casos he usado estos dos: List y Dictionary. El primero de ellos es obviamente una lista de objetos <T>, algo de uso cotidiano, y el segundo es el equivalente genérico del viejo diccionario, que permite guardar una colección de elementos y una clave para acceder a ellos <TKey>, <TValue>:

Dictionary<int, CPItem> dict = new Dictionary<int, CPItem>();

Este tipo diccionario es ideal para almacenar una serie de objetos (por ejemplo clientes que provienen de una BD) y poder acceder a uno de ellos a través de su campo clave o identificador, sea éste del tipo que sea (por ejemplo en el caso anterior la clave es de tipo int):

CPItem item2 = dict[24];

De este modo, es muy sencillo acceder a un elemento de la colección a través del valor de su identificador (no confundir con su posición dentro de la lista). Sin embargo y a pesar de su innegable potencia, hay un par de cosas que no me gustan de los diccionarios:

Siempre es más lento cargar los objetos en un diccionario que en una lista (del orden de 2 a 1 aproximadamente)
Un diccionario no es serializable 'per se' (al menos sin hacer trucos), y esto SI puede ser un problema.

Sin embargo, tiene la gran ventaja frente a la lista de que permite acceder de forma casi instantánea a un elemento de la misma, y además contiene métodos que permiten verificar si la colección contiene un elemento, ya sea por clave o por valor.

List vs. Dictionary

Veamos un ejemplo rápido, declaramos una clase con algunos miembros de diversos tipos de datos (para tener de todo un poco) y usamos esta clase para cargar varios objetos en una lista y un diccionario respectivamente:

class CPItem

    const int max = 1000000;

    public int propInt { get; set; }

    public string propString { get; set; }

    public DateTime propDateTime { get; set; }

    public bool propBool { get; set; }

    public double propDouble { get; set; }

    public CPItem(int propint)

        Random r = new Random(max);

        propInt = propint;

        propString = string.Format("Item {0}", propint.ToString("000000"));

        propDateTime.AddDays(propint);

        propBool = propint <= 0.5 ? false : true;

        propDouble = r.NextDouble() * max;

Declaramos los dos objetos genéricos:

List<CPItem> list = new List<CPItem>();

Dictionary<int, CPItem> dict = new Dictionary<int, CPItem>();

Y a continuación usamos un StopWatch para medir los tiempos de carga de 100.000 elementos... y podremos observar una gran diferencia:

private void LoadListDict()

    const int max = 100000;

    Stopwatch watch = new Stopwatch();

    list.Clear();

    watch.Start();

    for (int i = 1; i <= max; i++)

        list.Add(new CPItem(i));

    watch.Stop();

    TimeSpan ts1 = watch.Elapsed;

    dict.Clear();

    watch.Start();

    for (int i = 1; i <= max; i++)

        dict.Add(i, new CPItem(i));

    watch.Stop();

    TimeSpan ts2 = watch.Elapsed;

    this.ResultsTextBox.Text = string.Format(

        "Compare load {0} items in List vs. Dict. (ms.)\r\nList: {1}\r\nDict: {2}",

        max.ToString(),

        ts1.TotalMilliseconds.ToString(),

        ts2.TotalMilliseconds.ToString());

En mi estación estos son los tiempos promedio de carga después de ejecutar 5 veces:

Compare load 100000 items in List vs. Dict. (ms.)
List: 737,1392
Dict: 1479,4486

Bien, está claro que si hay que elegir entre ambos hay que tener un buen motivo para escoger el diccionario... ¡ya que la lista es el doble de rápida!

LINQ to objects

Con la aparición de VS2008 y del framework 3.5, aparecen las expresiones de consulta. Éstas nos permiten manipular colecciones de objetos en memoria, para filtrarlos, ordenarlos y agruparlos según nuestras necesidades.

Así que es posible que nos preguntemos ¿es necesario el uso de diccionarios, si ahora disponemos de LINQ para manejar listas? Es decir, si puedo cargar los datos en una lista genérica y acceder mediante LINQ to objects a un elemento, o a un subconjunto de éstos... ¿qué sentido tiene usar un dictionary?

Uhm... Pues supongo que el rendimiento podría ser un factor, ya que según la documentación de este objeto: Retrieving a value by using its key is very fast, close to O(1), because the Dictionary<(Of <(TKey, TValue>)>) class is implemented as a hash table. O dicho de otro modo: Recuperar un valor utilizando su clave es muy rápido, porque la clase Dictionary se implementa como una tabla hash.

Ya sabía yo que había un buen motivo para usar un diccionario: Debe ser más mucho más rápido al acceder a un objeto a través de su clave que extraerlo de una lista mediante LINQ... seguro! .... ¿o tal vez no?

Hagamos un par de pruebas:

A) Cuanto tardamos en recuperar a un elemento a través de su clave:

private void GetOneItemByKey(int keyvalue)

    if (list.Count == 0 || dict.Count == 0) LoadListDict();

    Stopwatch watch = new Stopwatch();

    watch.Start();

    CPItem item1 = (from l in list where l.propInt == keyvalue select l).Single();

    watch.Stop();

    TimeSpan ts1 = watch.Elapsed;

    watch.Start();

    CPItem item2 = dict[keyvalue];

    watch.Stop();

    TimeSpan ts2 = watch.Elapsed;

    this.ResultsTextBox.Text = string.Format(

        "Compare get one item by key in List vs. Dict. (ms.)\r\nList: {0}\r\nDict: {1}",

        ts1.TotalMilliseconds.ToString(),

        ts2.TotalMilliseconds.ToString());

En mi estación estos son los tiempos promedio de carga después de ejecutar 5 veces:

Compare get one item by key in List vs. Dict. (ms.)
List: 3,8518
Dict: 3,8566

Pues parece que ambos tiempos son iguales. Es más, acceder a la colección a través de LINQ ¡es incluso un poquito más rápido! Uhm, vaya... bueno, veamos el segundo ejemplo antes de sacar conclusiones:

B) Cuanto tardamos en verificar si existe un elemento a través de su clave:

private void VerifyOneItemByKey(int keyvalue)

    if (list.Count == 0 || dict.Count == 0) LoadListDict();

    Stopwatch watch = new Stopwatch();

    watch.Start();

    var items = from l in list where l.propInt == keyvalue select l;

    bool v1 = (items.Count() == 0);

    watch.Stop();

    TimeSpan ts1 = watch.Elapsed;

    watch.Start();

    bool v2 = dict.ContainsKey(keyvalue);

    watch.Stop();

    TimeSpan ts2 = watch.Elapsed;

    this.ResultsTextBox.Text = string.Format(

        "Compare verify one item by key in List vs. Dict. (ms.)\r\nList: {0}\r\nDict: {1}",

        ts1.TotalMilliseconds.ToString(),

        ts2.TotalMilliseconds.ToString());

En mi estación estos son los tiempos promedio de carga después de ejecutar 5 veces:

Compare verify one item by key in List vs. Dict. (ms.)
List: 3,906
Dict: 3,9111

Pues parece que en este caso ambos tiempos son también iguales. Entonces definitivamente NO ES MÁS RÁPIDO UTILIZAR UN DICCIONARIO PARA ACCEDER A LOS ELEMENTOS QUE CONTIENE A TRAVÉS DE SU CLAVE:

Carga	Recuperar elemento	Existe elemento

Conclusión

Pues sinceramente, si no es más rápido el acceso a un diccionario, pero es más lento en su carga y encima no es serializable... ¿en qué casos podemos seguir usando diccionarios en lugar de listas?

Espero vuestras opiniones,

** crossposting desde el blog de Lluís Franco en geeks.ms **

Corrección función getUserLDAPProperties

lfranco — Thu, 10 Jul 2008 09:01:18 GMT

Corrección aplicable al post:

http://geeks.ms/blogs/lfranco/archive/2008/07/08/accediendo-al-directorio-activo-de-la-organizaci-243-n-desde-net-iv.aspx

Ayer estuve revisando una de las funciones de la librería LDAPservices, que se encarga de devolver los nombres de las propiedades del objeto usuario dentro del AD. Hoy os publico una corrección, ya que observé que la función no devolvía correctamente todos los nombres de propiedades.

Este bug es producido porque en la función se utiliza un objeto DirectorySearcher para devolver todos los objetos de tipo usuario en el AD, a continuación lee los nombres de las propiedades del primer usuario encontrado y los inserta en una colección. A continuación la función no continúa procesando el resto de usuarios, ya que deberían tener las mismas propiedades, no? Pues no. Para mi sorpresa resulta que sólo se devuelven aquellas propiedades del usuario que han sido informadas:

public static List<string>

    getUserLDAPProperties(string LDAPURL)

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

    DirectoryEntry entries = new DirectoryEntry(LDAPURL);

    DirectorySearcher searcher = new DirectorySearcher(

        entries, "(&(objectCategory=person)(objectClass=user))");

try

        foreach (SearchResult result in searcher.FindAll())

            foreach (string property in

                result.GetDirectoryEntry().Properties.PropertyNames)

                properties.Add(property);

            break;

    catch (Exception ex)

        throw ex;

    return properties;

Para solucionar este bug, hay que procesar las propiedades de todos los usuarios, quedando el código de la función así como sigue:

foreach (SearchResult result in searcher.FindAll())

    foreach (string property in

        result.GetDirectoryEntry().Properties.PropertyNames)

        if(!properties.Contains(property)) properties.Add(property);

Como veis, se suprime el break que terminaba el bucle y se añade una condición para que se agreguen a la colección sólo aquellos nombres de propiedad que no se han agregado previamente.

Saludos y happy coding!!!

** crossposting desde el blog de Lluís Franco en geeks.ms **

Accediendo al directorio activo de la organización desde .NET (III)

lfranco — Fri, 04 Jul 2008 15:45:18 GMT

En vista a que bastante gente me ha pedido si puedo publicar ya el código del proyecto de ejemplo, he decidido publicarlo ahora en lugar de esperar al último post de la serie. En caso que se realicen variaciones en el código, las publicaré posteriormente.

Aquí lo teneis, publicado en skydrive (*):

(*) En ocasiones, al realizar cross-posting a otros blogs desde el original de geeks.ms, tal vez no aparezca correctamente el enlace a skydrive. Si es así, os recomiendo que visitéis el post original en geeks.ms y realicéis la descarga desde éste.

En el post anterior, os dije que en el siguiente (este post) mostraríamos cómo realizar la suplantación (Impersonate) de usuario de Windows para ejecutar nuestra aplicación con otras credenciales. Sin embargo, como ésto ya lo mostré en otro post de una serie anterior, lo doy por explicado y así avanzamos un poco más.

System.Net.NetworkInformation

Antes de entrar al trapo, un pequeño apunte. Apuntaros este espacio de nombres, que hemos utilizado para obtener algunos datos básicos para el proyecto, y que contiene un montón de métodos que devuelven información muy interesante sobre el tráfico y estadísticas de red.

LDAPServices

Vamos a ir comentando algunas de los métodos que proporciona esta clase. Como os comenté son todos estáticos, por lo que no es necesario instanciar un objeto para invocarlos. Empecemos:

sIDtoString - Trabajando con el AD constantemente vamos a encontrarnos con los llamados SID (identificadores de seguridad). Este método se encarga de transformar un SID (array de bytes) en una cadena de texto que pueda ser mostrada al usuario.

public static string

    sIDtoString(byte[] sidBinary)

    SecurityIdentifier sid = new SecurityIdentifier(sidBinary, 0);

    return sid.ToString();

getNTAccountName - Devuelve el nombre del objeto dentro del AD a partir de su SID. Por ejemplo, a partir de un identificador de seguridad como {S-1-5-12-7623811015-3361044348-030300820-1013} retorna un string con formato: 'DOMINIO\NombreObjeto'.

public static string

    getNTAccountName(string wksid)

    SecurityIdentifier sid = new SecurityIdentifier(wksid);

    NTAccount account = (NTAccount)sid.Translate(typeof(NTAccount));

    return account.Value;

getADUserMemberOf - Devuelve un diccionario con los grupos a los que pertenece un usuario. Espera un argumento de tipo token de seguridad (habitualmente utilizaremos el WindowsIdentity.GetCurrent().Token) y el diccionario genérico devuelto es de tipo <string, IdentityReference>.

public static Dictionary<string, IdentityReference>

    getADUserMemberOf(IntPtr logonToken)

    Dictionary<string, IdentityReference> groups =

        new Dictionary<string, IdentityReference>();

    WindowsIdentity user = new WindowsIdentity(logonToken);

    IdentityReferenceCollection irc = user.Groups;

    foreach (IdentityReference ir in irc)

        groups.Add(getNTAccountName(ir.Value), ir);

    return groups;

(*) Al ir escribiendo el artículo me he dado cuenta de que esta función podría ser optimizada, aprovechando algunas de las nuevas características de C# 3.0, incorporadas en Visual Studio 2008. De modo que podría ser re-escrita del siguiente modo ¡en tan sólo 3 líneas!

public static Dictionary<string, IdentityReference>

    getADUserMemberOf2(IntPtr logonToken)

    WindowsIdentity user = new WindowsIdentity(logonToken);

    var groups = from g in user.Groups select g;

    return groups.ToDictionary(p => getNTAccountName(p.Value));

¿Menudo cambio, verdad? Observar el uso de:

Inferencia de tipos (var)
Palabras clave de consulta (from, in, select)
Expresiones lambda en la llamada al método extensor ToDictionary (p => getNTAccountName(p.Value))

La verdad es que en cuanto empiezas a usar estas mejoras te 'enganchan'. No sabeis la cara de bobo que se me queda cuando a veces abro el editor de VB6.0 (si, habéis oído bien) para realizar alguna modificación en aplicaciones que todavía no se han migrado a .NET (y lo que les queda... :-P).

Hasta aquí algunos de los métodos que contiene la clase LDAPServices. En el próximo post veremos cómo obtener la lista de propiedades de un objeto user dentro del directorio activo, así cómo realizar búsquedas de objetos dentro del directorio.

No vemos pronto,

** crossposting desde el blog de Lluís Franco en geeks.ms **

How to: Cómo insertar un WinForm dentro de un control TabPanel

lfranco — Tue, 01 Jul 2008 12:10:32 GMT

:-)
Hoy he visto en el foro de VB una duda que planteaba Tito, acerca de la posibilidad de usar un entorno de formularios hijos dentro de un TabPanel (al estilo del editor de Visual Studio). No es la primera vez que veo esta duda, así que le he dedicado un ratillo y aquí publico una posible solución.

De este modo podemos tener un formulario que actúa como contenedor de otros, pero sin utilizar MDI (que por otra parte me parece ya bastante pasado de moda :-P). La técnica a usar muy sencilla y lo único que hacemos es cada vez que creamos un form, creamos también un objeto TabPage e insertamos el formulario dentro de la nueva pestaña. La única cosa que tenemos que tener en cuenta es establecer la propiedad TopLevel del nuevo formulario 'hijo' a False, ya que de otro modo recibiremos un error.

Una muestra:

Private Sub ShowForm()

    Dim r As New Random()

    Static i As Integer

    i += 1

    Dim key As String = "f" + i.ToString()

    'Crea el nuevo form (copia de form2)

    Dim f As New Form2

    f.BackColor = Color.FromArgb(r.Next(0, 255), r.Next(0, 255), r.Next(0, 255))

    f.Text = String.Format("Nuevo form {0}", i)

    'Crea el tab que lo contiene

    Me.Tabs.TabPages.Add(key, f.Text)

    f.TopLevel = False

    f.FormBorderStyle = Windows.Forms.FormBorderStyle.None

    f.Dock = DockStyle.Fill

    Me.Tabs.TabPages(key).Controls.Add(f)

    Me.Tabs.SelectedTab = Me.Tabs.TabPages(key)

    'Asigna el nuevo form al tag del tabpage

    Me.Tabs.TabPages(key).Tag = f

    'Por si desde el propio form quieres cerrar y eliminar el tab

    f.Tag = Me.Tabs.TabPages(key)

    f.Show()

End Sub

Podeis descargar el proyecto de ejemplo desde:

Y para los que siempre me tiráis los puntosycoma en cara, lo he realizado en VB (eh Jorge? :-D).
Un saludo desde Andorra!

** Modificación (02/07/2008) para agregar un menú contextual a las pestañas **

A petición de Carlos. De este modo es puede cerrar la pestaña actual o todas las pestañas menos la que estamos viendo ahora. El menú es un objeto ContextMenuStrip, de modo que es totalmente extensible para agregar vuestra propia funcionalidad.

La nueva versión está disponible en:

Saludos,

** crossposting desde el blog de Lluís Franco en geeks.ms **

Accediendo al directorio activo de la organización desde .NET (II)

lfranco — Mon, 30 Jun 2008 13:53:07 GMT

En el post anterior vimos que en ocasiones nuestra aplicación deberá acceder a los datos que contiene el directorio activo de nuestra organización, ya sea para buscar elementos, validar credenciales, etc.

Hoy nos centraremos en los objetos del framework que nos permiten realizar esto, empezando por el objeto WindowsIdentity, que nos acompaña desde la versión 1.0 del framework, y que representa un usuario de Windows.

WindowsIdentity

Representa un usuario de Windows. Dispone de un método GetCurrent() que devuelve una referencia al usuario de Windows que está ejecutando la aplicación y que por defecto será el usuario actual de Windows.

En nuestro ejercicio vamos a utilizar este objeto para mostrar en la barra de estado algo de información sobre el usuario actual. El nombre y token, así como el contexto de suplantación y diversa información cómo si está autenticado, es de sistema, etc.

El código es muy sencillo y para usarlo sólo debemos tener en cuenta haber importado el espacio de nombres System.Security.Principal:

private void RefreshUserInformation()

    WindowsIdentity user = WindowsIdentity.GetCurrent();

    lblUser.Text = string.Format("User: {0}", user.Name);

    lblToken.Text = string.Format("Token: {0}", user.Token.ToString());

    lblImpersonating.Text = string.Format("Impersonating: {0}", user.ImpersonationLevel.ToString());

    lblIsAnonymous.Text = string.Format("Is Anonymous: {0}", user.IsAnonymous.ToString());

    lblIsAuthenticated.Text = string.Format("Is Authenticated: {0}", user.IsAuthenticated.ToString());

    lblIsGuest.Text = string.Format("Is Guest: {0}", user.IsGuest.ToString());

    lblIsSystem.Text = string.Format("Is System: {0}", user.IsSystem.ToString());

    if (sec.ImpersonationContext == null)

        cmdImpersonateApplicationAsUser.Enabled = true;

        lblUser.ForeColor = Color.Black;

        lblImpersonating.ForeColor = Color.Black;

    else

        cmdImpersonateApplicationAsUser.Enabled = false;

        lblUser.ForeColor = Color.Red;

        lblImpersonating.ForeColor = Color.Red;

    cmdUndoImpersonation.Enabled = !cmdImpersonateApplicationAsUser.Enabled;

Lo único a destacar es que en caso de que exista suplantación (ImpersonationContext distinto de nulo), mostraremos algunos campos en color rojo, para destacar que este usuario es distinto del que inició sesión en Windows.

LDAPServices

En este proyecto he creado una clase que proporciona una serie de funcionalidades comunes, su nombre es LDAPServices y encapsula una serie de métodos estáticos, para facilitar el trabajo con LDAP. En los próximos posts detallaremos el uso de estos métodos:

SecurityContext

También aparece la clase llamada SecurityContext que ya hemos visto en la serie de posts sobre acceder a la caché de IE, que encapsula toda la lógica necesaria para impersonar nuestra aplicación y que se ejecute con otras credenciales de usuario de Windows.

Esta clase expone una propiedad de tipo WindowsImpersonationContext que devuelve información sobre si está realizando suplantación, y que en caso afirmativo permite terminarla mediante el método Undo(). También expone dos métodos LogonUser y ImpersonateUser, que permiten respectivamente validar unas credenciales de usuario contra un dominio y empezar un contexto de suplantación.

En el próximo post veremos cómo realizar esta suplantación y cómo recabar más información del usuario actual (por ejemplo a que grupos de Windows pertenece el usuario actual).

Hasta entonces!

** crossposting desde el blog de Lluís Franco en geeks.ms **

Heroes happen {here} -> AndorraDotNet

lfranco — Thu, 26 Jun 2008 14:09:11 GMT

Hemos vuelto a liarla!

El pasado 7 de Junio se celebró otro evento en AndorraDotNet en las instalaciones de FIMARGE (gracias de nuevo por la sala). En él tratamos de mostrar las novedades de Visual Studio 2008, en un evento al más puro estilo de la serie Heroes happen {here}. La agenda estaba bastante apretada y de hecho aunque la sesión pasó de las tres horas nos dejamos por ver algunas cosillas, pero de este modo las guardaremos para futuros eventos... que ya tenemos alguno en mente, verdad pilluelos?

La sesión transcurrió como a mí me gusta, con mucha participación por parte de la gente (incluso en una ocasión tuve que aclarar que una pregunta no había estado preparada de antemano, jeje...), y tuve la gran suerte que todas las demos salieron bien. Incluso una que se realizó íntegramente picando código 'al vuelo', cosa que ya sabéis que no siempre sale bien :-D, pero en esta ocasión todo salió a pedir de boca.

La parte del sorteo estuvo muy divertida, ya que improvisamos un sistema en el que cada asistente tenía 3 números y podía tocarle más de un regalo, pero para evitarlo establecimos como norma que si a uno le tocaba otro premio tenía la posibilidad de escoger entre el nuevo o el que ya tenía, y esto animó bastante la cosa, hasta el punto que aquello parecía más un bingo que un sorteo de goodies y licencias.

Como ya os anuncié, os dejo los materiales para su descarga (son libres para usarlos como queráis, bajo licencia jabugoware).

La presentación PPTX:

El código fuente con las demos (*):

(*) Incluye el código del sorteo. Para que podáis comprobar que se efectuó limpiamente :-P

Al terminar unos cuantos nos fuimos a cenar y continuamos con la charla pero en un ambiente más distendido, y como siempre terminamos hablando los más viejos contando batallitas de cuando la informática era algo nuevo, y cada uno se tenía que documentar como buenamente podía... que tiempos aquellos.

En fin, muchas gracias a los que asististeis, y a todos los que no pudisteis venir os invito a hacerlo a la próxima.
Un saludo desde Andorra,

PD - Os pido disculpas por haber tardado un tiempo en publicarlo, pero me he tomado unos días para reflexionar.

** crossposting desde el blog de Lluís Franco en geeks.ms **

Accediendo al directorio activo de la organización desde .NET (I)

lfranco — Wed, 11 Jun 2008 18:16:35 GMT

Creo que me estoy aficionando a las series ~~de posts no de la tele~~, ya que acabo de terminar la serie de artículos acerca de cómo acceder a la caché de Internet Explorer y ya estoy planteándome una nueva, sobre acceder al directorio activo mediante una aplicación realizada con C#. Esta serie, al igual que la anterior intentará ser lo más directa y práctica posible, y del mismo modo al final de la serie publicaré el código completo del ejemplo para su descarga.

El motivo...

...de esta serie es porque tanto en los foros como en los grupos de notícias, es muy común encontrar preguntas muy variadas acerca de cómo acceder a LDAP desde una aplicación .NET. Así que me he planteado empezar una serie de posts en los que mostraremos varios ejemplos: Mostrar información del usuario actual de Windows, averiguar los grupos a los que pertenece, validar credenciales contra un dominio para saber si son correctas, impersonar nuestra aplicación para que se ejecute con las credenciales de otro usuario, buscar usuarios o grupos en LDAP, extraer la lista de propiedades del objeto usuario, etc.

¿LDAP o Directorio Activo?

Antes de empezar quiero hacer una aclaración: ¿Es lo mismo LDAP que Directorio Activo? No, no es lo mismo.

LDAP es el acrónimo de (Lightweight Directory Access Protocol) que es es un protocolo a nivel de aplicación que permite el acceso a un servicio de directorio ordenado y distribuido para buscar diversa información en un entorno de red. Habitualmente se utiliza para acceder a la información almacenada de usuarios, grupos y equipos de una organizació y existen muchas implementaciones de este protocolo, desde Microsoft hasta Novell pasando por Red Hat, iPlanet u OpenLDAP.

El directorio Activo o AD es la implementación de LDAP realizada por Microsoft en su família Windows Server. Al igual que LDAP permite acceder a distintos tipos de objetos almacenados que representan los elementos de la organización. Cada uno de estos objetos tendrá atributos que permiten identificarlos en modo unívoco (por ejemplo, los usuarios tendrán campo "nombre", campo "email", etc..., las impresoras de red tendrán campo "nombre", campo "fabricante", campo "modelo", campo "usuarios que pueden acceder", etc). Toda esta información queda almacenada en Active Directory replicándose de forma automática entre todos los servidores que controlan el acceso al dominio.

Situaciones cotidianas

Nosotros los desarrolladores, como creadores de aplicaciones que deben coexistir en un entorno corporativo, cada vez nos encontramos en más ocasiones en las que nuestra aplicación debe utilizar los usuarios y grupos del AD de la empresa, en lugar de almacenar una base de datos propia de usuarios y grupos. Incluso me atrevería a decir que la frontera entre una aplicación madura, de uso corporativo, y que se integre con otras aplicaciones y servicios, a veces estriba en detalles como éste.

Hoy en día cada vez más empresas disponen de la figura del administrador del AD, que gestiona todos los datos de los empleados de la misma, de modo que ¿para que van a mantener otra base de datos con los usuarios de una aplicación, si éstos ya existen en el AD? Incluso puede ser peor ¿os imagináis cuántas aplicaciones funcionan de este modo? ¿Debemos mantener X bases de datos de usuarios por X aplicaciones? Esto puede ser el caos... ¡imaginaos la de datos duplicados que existen y lo difícil que resulta mantenerlos!

Gracias al .NET framework, hoy en día podemos integrar nuestras aplicaciones con el AD de la empresa, de forma que podamos aprovechar la ventaja de contar con un repositorio centralizado. De este modo podremos dejar en manos del administrador del AD la creación de usuarios, grupos y cómo se relacionan entre ellos, y nosotros encargarnos de lo que realimente nos importa: La aplicación.

En el próximo post empezaremos a construir nuestra aplicación de ejemplo, y para ello contaremos con la ayuda del namespace System.Security.Principal y de System.DirectoryServices... hasta entonces!

** crossposting desde el blog de Lluís Franco en geeks.ms **

Acceder a la caché de Internet Explorer (IV)

lfranco — Fri, 30 May 2008 16:22:52 GMT

En los dos primeros artículos pudimos ver los objetos del API de Windows que íbamos a usar para poder acceder a la caché de los archivos temporales de Internet, cómo persistir estos datos en formato XML, y finalmente cómo permitir que temporalmente nuestra aplicacación se ejecute con las credenciales de otro usuario, para poder realizar una serie de acciones que de otro modo no podría efectuar por falta de privilegios.

Siguiendo con el objetivo de este ejercicio hoy vamos a encapsular la lógica de negocio de nuestra aplicación en forma de servicio de Windows, y éste va a encargarse de realizar una consulta a la caché de Internet de nuestro ordenador cada X tiempo (configurable mediante un fichero XML).

Lo primero de todo va a ser construir la base de nuestro servicio mediante un proyecto de tipo Windows Service. Esta plantilla nos genera un proyecto con un componente de tipo ServiceBase, que servirá para ir construyendo nuestro pequeño juguetito.

A continuación vamos a cambiar el nombre al servicio, en nuestro caso lo llamaremos "IECacheQueryService". Y posteriormente estableceremos a True los valores de las propiedades CanPauseAndContinue y CanShutdown, para poder pausar y detener nuestro servicio en tiempo de ejecución.

Importante: Comprobar que el nombre sel servicio se ha cambiado correctamente en el punto de entrada de la aplicación (si no fuese así tendremos que modificarlo manualmente):

static class Program

        static void Main()

            ServiceBase[] ServicesToRun;

            ServicesToRun = new ServiceBase[]

                new IECacheQueryService()

};

            ServiceBase.Run(ServicesToRun);

Implementando funcionalidad al servicio:

De momento el servicio será capaz de iniciarse, pero no realizará nada. Ahora debemos dotarlo de funcionalidad, y para ello vamos a crear un temporizador que se encargue de realizar una tarea cada X tiempo (por defecto una hora). Éste lo crearemos como un miembro dentro de nuestra clase:

public partial class IECacheQueryService : ServiceBase

    private Timer clock = new Timer();

Y lo usaremos desde el constructor de la misma, así como en los eventos OnStart y OnStop. Observar que en el constructor lo inicializamos con un valor que proviene del fichero de configuración del proyecto (propiedades del proyecto/settings) llamado TimerInterval y se ha establecido a un valor de 3.600.000 (1 hora en milisegundos).

public IECacheQueryService()

    InitializeComponent();

    clock = new Timer(Properties.Settings.Default.TimerInterval);

    clock.Elapsed += new ElapsedEventHandler(clock_Elapsed);

    clock.Enabled = true;

    //...

protected override void OnStart(string[] args)

    ExecuteQuery();

    clock.Start();

    //...

protected override void OnStop()

    clock.Stop();

Del mismo modo también especificamos el manejador de evento asociado que se ejecutará cada vez que se cumpla este intervalo de tiempo (clock_Elapsed). Éste será el corazón de nuestro servicio y será el encargado de invocar la consulta a la caché de IE:

void clock_Elapsed(object sender, ElapsedEventArgs e)

try

            ExecuteQuery();

        catch (Exception ex)

            appEventLog.WriteEntry("Exception: " + ex.Message,

                EventLogEntryType.Error);

Simple verdad? Ahora vamos a construir este método ExecuteQuery a apartir de las piezas que vimos en anteriores entradas de la misma serie. No os preocupeis que en el último post estará un enlace al código completo del ejemplo (incluido el instalable).

Que hace exactamente este método?

Primero de todo crea un objeto de tipo StopWatch para medir con precisión el tiempo que transcurre en la ejecución del mismo.
Llama al método getResults que se encarga de efectuar la consulta y devolver un objeto que es una lista genérica de entradas de la caché.
Construye el nombre de fichero en el que guardaremos los resultados y llama al método saveResults, encargado de realizar la suplantación de identidad y serializar los resultados en el fichero antes mencionado.

private void ExecuteQuery()

try

        Stopwatch watch = new Stopwatch();

        watch.Start();

        List<IECacheEntry> results = getResults(

            Properties.Settings.Default.SearchPattern);

        string filename = string.Format("{0}{1}_{2}.xml",

            Properties.Settings.Default.TargetPathLocation,

            Environment.MachineName,

            DateTime.Now.ToString("ddMMyyyy_hhmm"));

        watch.Stop();

        TimeSpan ts = watch.Elapsed;

        saveResults(results, filename);

        appEventLog.WriteEntry(string.Format(

            "Query executed successfully at {0} in '{1}' by user '{2}'. Elapsed time (ms): {3}",

            DateTime.Now.ToString(), Environment.MachineName,

            WindowsIdentity.GetCurrent().Name,ts.Milliseconds));

    catch (Exception ex)

        appEventLog.WriteEntry("Exception: " + ex.Message,

            EventLogEntryType.Error);

Está el servicio terminado? Bueno, si asumimos que el código está completo y funciona sin errores, sí, lo está :-P

Y ahora cómo lo probamos? Pues... bueno, para probarlo antes tenemos que instalarlo.

Agregando los elementos necesarios para instalar el servicio:

No he encontrado demasiada documentación al respecto, de modo que intentaré mostrar los pasos a seguir mediante capturas de pantalla.

Vamos a agregar un elemento que nos permita distribuir el servicio:

Le agregaremos dos componentes serviceProcessInstaller y serviceInstaller (es posible que no aparezcan en la barra de herramientas, así que tendremos que agregarlos mediante la opción "Choose Items..."

A continuación los configuraremos del siguiente modo:

Control	Propiedad	Valor
serviceProcessInstaller1	Account	LocalSystem (*)
serviceProcessInstaller1	Parent	Installer1
serviceInstaller1	Description	Internet Explorer Query Cache
serviceInstaller1	Display Name	Internet Explorer Query Cache
serviceInstaller1	Parent	Installer1
serviceInstaller1	ServiceName	IEQueryCache
serviceInstaller1	StartType	Automatic

(*) Habitualmente se utilizará siempre la cuenta con menos nivel de privilegios (LocalService), pero en nuestro caso necesitamos acceder a la caché de IE, de modo que es posible que incluso tengamos que configurar la cuenta de un usuario de windows con suficientes permisos.

Cruzamos los dedos, compilamos el proyecto y vamos a agegar un proyecto de instalación a la solución.

Creando el proyecto de instalación:

Agregaremos un proyecto de tipo Setup and deployment, que será el encargado de instalar nuestro servicio en las estaciones Windows que deseamos monitorizar.

Agregamos la salida del proyecto anterior al nuevo proyecto de instalación:

Ahora mostraremos la ventana de "custom actions" para agregar como acción al instalador la salida de nuestro proyecto de servicio de Windows.

Una vez realizado esto ya podemos compilar el proyecto de instalación e instalarlo en las estaciones cliente. Si quereis instalarlo en vuestra estación para probarlo y configurarlo adecuadamente, la opción más sencilla es seleccionar la opción Install del menú contextual del proyecto de instalación, en el explorador de proyectos.

Una vez instalado, aparecerá en el administrador de servicios, para que podamos configurarlo del modo deseado. En este caso particular, si deseamos monitorizar la caché de un usuario en particular, deberemos usar las credenciales de éste usuario, ya que si no el S.O. no será capaz de montar el fichero Index.dat correspondiente a la caché de Internet Explorer.

Bueno, hasta aquí ha llegado este ejemplo. En el próximo post haremos un resumen de lo que se ha visto hasta ahora y publicaré un enlace con el código completo del proyecto para que sirva de ejemplo (o de mal ejemplo :-P).

Saludos desde andorra,

** crossposting desde el blog de Lluís Franco en geeks.ms **