El blog de Lluis Franco : Visual Studio

VS2010: Aleluya! Mejoras en Project –> Refrences

lfranco — Thu, 29 Oct 2009 08:01:00 GMT

Leo en el blog de Scott, que por fin alguien me ha hecho caso :-)

Ya en las betas de la versión 2003 mandé una petición para que el cuadro de diálogo de referencias se cargara de forma asíncrona, y desde entonces no se puede decir que me hubiésen hecho demasiado caso. La verdad es que tampoco creo que me lo hayan hecho ahora, pero al menos alguien debe haber llegado a la misma conclusión: El cuadro de diálogo de agregar referencias tardaba horrores en cargar.

La verdad es que es normal, ya que en la versión 2008 todavía tenemos el mismo diálogo que en Visual Studio 6.0, ya ha llovido un poco.

Ahora, a partir de la beta 2 de 2010, este cuadro de diálogo se abre por defecto en la pestaña ‘Projects’ en lugar de mostrar las referencias de .NET, y esto es mucho más rápido.

Pero eso no es todo, ahora en las dos primeras pestañas, la carga de ensamblados se realiza ahora de forma asíncrona, de forma que no paraliza el IDE hasta que estan todos los ensamblados cargados en la lista.

Si, se que es una tonteria… pero a veces estos pequeños cambios hacen que uno sea bastante más productivo, o que al menos no se cabree con la herramienta cuando por error le das a esta ventana :-P

Artículo original:

http://weblogs.asp.net/scottgu/archive/2009/10/29/add-reference-dialog-improvements-vs-2010-and-net-4-0-series.aspx

Saludos a todos!

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

El CodeCamp 2009 se acerca…

lfranco — Mon, 21 Sep 2009 12:36:00 GMT

Hola a todos,

Ya queda menos de un mes para uno de los eventos más esperados de este año: el CodeCamp 2009. Este evento ha sido organizado por varios grupos de usuarios de España y del extranjero (Andorra también existe!), y se realizará en Salou (Tarragona), durante el fin de semana del 17 y 18 de Octubre.

El CodeCamp Tarragona 2009 es un evento gratuito organizado por y para la comunidad de .NET, cuyo objetivo es reunir a profesionales, usuarios y entusiastas interesados en la plataforma .NET y Mono para intercambiar experiencias y asistir a un conjunto de ponencias realizadas por especialistas de reconocido prestigio.

El Code Camp estará compuesto por una serie de sesiones divididas en varios tracks. Las sesiones abarcarán presentaciones, charlas informales y sesiones prácticas. Estáis todos invitados a asistir, hablar y participar.

Tendremos una mezcla de ponentes, desde MVPs, directores, autores y, los más importante, desarrolladores como tú, ya que nos interesa tratar temas y problemas reales a los que los profesionales se enfrentan en el trabajo diario.

En esta ocasión, voy a participar como ponente en uno de los tracks, conjuntamente con mis buenos amigos Jorge Serrano y Pep Lluís Bano. De modo que si te quieres divertir y estar al loro de las últimas novedades de VB2010 pásate por allí y hablamos un rato.

Más información en:

http://www.codecamp.es/

PD – El día anterior celebraremos el TTT (Train the trainers), de modo que si vas a ir nos vemos allí :-)

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

Bajando la Beta1 de Visual Studio 2010!

lfranco — Mon, 18 May 2009 15:48:00 GMT

:-)
Como mola!

Será que no hay nadie todavía que la esté bajando? Será la fibra? Que será, será...

La verdad es que así es un gustazo. .. Antes de terminar el post (y mira que era breve) ya ha terminado la descarga.

Ahora... a instalar! Nos vemos!

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

Hotfix para Visual Studio 2008 (error al serializar propiedades)

lfranco — Thu, 14 May 2009 08:40:00 GMT

Leo en el blog del equipo de desarrollo de Developer Express, que Microsoft acaba de publicar un hotfix para solventar un pequeño problema en la serialización de propiedades. Parece ser que bajo algunas condiciones los cambios realizados en el diseñador no se guardan correctamente en la vista del código fuente. Este problema fue detectado por el equipo de desarrollo de Developer Express trabajando con sus propios controles de ASP.NET, pero en un análisis más profundo encontraron que es un error general de Visual Studio.

Para reproducir este error seguir estos 5 pasos:

Crear un nuevo sitio Web
Colocar un control Wizard estándar en él.
Colocar un control GridView dentro de la región editable del control Wizard.
Ir a las propiedades del control GridView y establecer la propiedad PagerSettings.Visible a False.
Cambiar a la vista de código fuente.

Si los cambios no se han aplicado correctamente, es necesario aplicar el hotfix.

Enlace para descargar el hotfix desde Connect:
http://connect.microsoft.com/VisualStudio/Downloads/DownloadDetails.aspx?DownloadID=17185

Saludos,

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

Google Chrome usa ClickOnce :-)

lfranco — Mon, 06 Apr 2009 11:02:00 GMT

Pues eso. Tal vez muchos de vosotros ya lo sabíais pero esta mañana me he quedado de piedra al comprobar que la instalación de Google Chrome se realiza mediante la tecnología ClickOnce de Microsoft. Curioso verdad? Para muestra un botón:

Si lo piensas es normal, ya que el código del producto para Windows no deja de ser una solución de Visual Studio 2005 (15 proyectos si no recuerdo mal), de modo que es relativamente normal que se hayan aprovechado de una tecnología tan *cojonuda* (y perdón por la expresión) com es ClickOnce para el despliegue de aplicaciones.

Lo que no deja de ser gracioso es que de momento Chrome no tenga versiones estables para Mac ni para Linux (de hecho según los mismos desarrolladores "Esta mas cerca del comienzo que del fin"), y la única versión que funciona más o menos bien esté desarrollada con la herramienta de desarrollo más popular de la competencia :-P

En fin, como dije antes… curioso, verdad?

** 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 **

10 cosas que me gustan de C# respecto a VB

lfranco — Tue, 23 Dec 2008 17:44:53 GMT

Antes de empezar a leer este post, un aviso: En ningún modo pretendo crear polémica o abrir el viejo debate otra vez, si no más bien enumerar algunas cosillas que hacen que *yo* me sienta más cómodo trabajando con C# que con VB, tanto a nivel de lenguaje como del propio editor. Lo remarco porque quiero que quede bien claro que es una opinión personal, ok? No se trata de comerle el coco a nadie…

Algunas de estas cosillas ya las he compartido con algunos de vosotros en algún evento de los grupos de usuarios, o simplemente delante de unas cervezas (aquí la conversación suele tornarse más pasional y tiende a alargarse un poco), jejeje…, y a decir verdad pocas veces nos ponemos de acuerdo ¿eh agüelo?. Parece ser que antes de empezar a hablar cada cual ya se ha posicionado y de aquí no nos movemos… lo cual es hasta cierto punto normal. Uno sabe con qué herramienta se encuentra más cómodo, aunque pueda usar ambas de forma indistinta.

De hecho he tirado más líneas de código con VB que con cualquier otro lenguaje, y eso que empecé en este mundillo con C y posteriormente con C++, para luego pasar a los lenguajes ‘más productivos’ como Delphi o finalmente VB en sus primeras versiones. No fue hasta 2002 y las primeras versiones de .NET que volví a usar la vieja sintaxis del punto y coma. De modo que VB en-todas-sus-variedades me es muy querido, y debo reconocerle sus ventajas… Sin embargo, codificar, al igual que leer o hablar, es algo que siempre haces mejor o te sientes más cómodo en uno de los lenguajes que dominas, y aquí reconozco que C# (como antes de conocerlo lo fue Java) es mi predilecto. Siempre que YO decido el lenguaje a utilizar en un nuevo proyecto, lo escojo, y en caso contrario intento convencer a la otra persona (ya sea compañero, cliente, etc.).

Os enumero a continuación una lista de cosas que me gustan de C#, o más bien que no me gustan cuando al cabo de un tiempo de trabajar con C#, me pongo a codificar con VB. No siguen ningún orden ni patrón y las voy a ir enumerando conforme se me vayan ocurriendo:

1) Escribo menos código && código más limpio:

En este punto, un desarrollador de VB acostumbra a decirme que esto no es cierto. Que si bien la sintaxis de VB es en alguno puntos ‘rocambolesca’ es para aclarar, y además el propio editor de código se encarga de escribirlo. Sin embargo tengo comprobado que con el editor de C# en la gran mayoría de las situaciones tecleo menos para decir lo mismo, y queda más claro (al menos para mí). Ojo! Es importante destacar que en ningún momento me mueve el afán de teclear menos, sino que el código resultante sea más legible. Comparemos los siguientes ejemplos:

Declarar una variable:

C#:

int x = 5;

VB:

Dim x As Int = 5

Bloques de código (ends por todas partes :-P).

C#:

if(Nombre == "Pepe" && Sueldo <= 500)

...

VB:

If Nombre = "Pepe" AndAlso Sueldo <= 500 Then

...

End If

Operador AddressOf

C#:

Thread t = new Thread(CountSheep);

VB:

Dim t As New Thread(AddressOf CountSheep)

Expresiones lambda:

C#:

Func<int, Func<int, int>> mult = (int x) => (int y) => x * y;

VB:

Dim mult As Func(Of Integer, Func(Of Integer, Integer)) = _

Function(x As Integer) Function(y As Integer) x * y

Implementar una interfaz (no es preciso Implements):

C#:

interface ITest

    string getValue();

class Test : ITest {

    string getValue()

        Random r = new Random();

        return r.Next().ToString();

VB:

Interface ITest

    Function getValue() As String

End Interface

Class Test

    Implements ITest

    Public Function getValue() As String Implements ITest.getValue

        Dim r As New Random

        Return r.Next().ToString()

    End Function

End Class

Podriamos seguir con Overridable, Overrides y unos cuantos más... Pero mejor vamos al siguiente punto que si no, no acabo el post hoy… :-)

2) No más underscores!

Cuantas veces he tenido que escuchar “no tengo porque terminar cada línea de código con un punto y coma!”. Pues precisamente, el delimitador de línea es lo que permite que en los lenguajes derivados del viejo y bueno ‘C’ no tengamos que hacer algo tan antinatural como partir las líneas de código con underscores (_). Además suele pasar que es una de las cosas que olvido con mayor rapidez, y cada vez que escribo en VB una query con LINQ acabo por soltar un “AAAAARGH!!! OTRA VEZ!!!”.

C#

List<int> nums = new List<int>(new int[] { 1, 2, 3, 4 });

var mynums = from n in nums

             where n < 5

             orderby n

             select n;

VB:

Dim nums As New List(Of Integer)(New Integer() {1, 2, 3, 4})

Dim mynums = From n In nums _

    Where n < 5 _

    Order By n _

    Select n

3) Matrices y Listas: [] en lugar de ():

Cuando estoy picando o leyendo código me gusta saber con exactitud si estoy llamando a una función, a una propiedad u obteniendo el valor de una matriz o colección. Precisamente por eso prefiero usar corchetes en lugar de paréntesis para acceder a los miembros de una matriz o lista. En el ejemplo siguiente en la llamada a nums(i) en VB, podría ser tanto un método como una matriz, como una propiedad que devuelve una matriz o lista:

C#

List<int> nums = new List<int>(new int[] { 1, 2, 3, 4 });

Console.WriteLine(nums[2].ToString());

VB:

Dim nums As New List(Of Integer)(New Integer() {1, 2, 3, 4})

Console.WriteLine(nums(2).ToString())

4) Parámetros de salida (out):

Tipos de parámetro de salida. Estos son muy parecidos a los parámetros por referencia (ref), pero no necesitan ser inicializados. Resultan particularmente útiles en algoritmos recursivos. Visual Basic no dispone de nada equivalente, aunque si permite el paso de valores por referencia.

C#:

static void Method(out int i)

    i = 44;

static void Main()

    int value;

    Method(out value);

5) Los códigos de escape y las cadenas verbatim:

Otra cosa que me molesta es que VB no reconoce los carácteres de escape contenidos en un string. Esto es particularmente útil cuando deseamos mostrar un retorno de línea ‘\n’ o una tabulación ‘\t’ dentro de una cadena. En Visual Basic hay que recorrer a la concatenación de Environment.NewLine o artimañas parecidas como concatenar directamente el carácter. Por ejemplo el código siguiente se muestra así:

MessageBox.Show("hola\nque\ntal");

C#:

VB:

En este punto más de uno se preguntará ¿y que pasa si no quiero tratar estos caracteres de escape como especiales?, ¿o si quiero mostrar una ruta de acceso que contiene varios caracteres ‘\’? Bien, para ello tenemos varias alternativas: Podemos anteponer un carácter ‘\’ a todo símbolo que deseemos mostrar literalmente o podemos usar cadenas verbatim (también llamado ‘literal de cadena textual’):

MessageBox.Show("C:\\Windows\\system32\\Calc.exe");

MessageBox.Show(@"hola\nque\ntal");

Las cadenas verbatim van incluso un poco más allá y permiten incluso poder partir una cadena en varias líneas, lo que clarifica en mucho el código:

MessageBox.Show(@"SELECT O.OrderID, O.CustomerID, O.EmployeeID,

                O.OrderDate, O.RequiredDate, O.ShippedDate,

                O.ShipVia, O.Freight, O.ShipName, O.ShipAddress,

                O.ShipCity, O.ShipRegion, O.ShipPostalCode,

                O.ShipCountry, C.CompanyName, C.Address,

                C.City, C.Region, C.PostalCode, C.Country

                FROM dbo.Customers AS C

                INNER JOIN dbo.Orders AS O

                ON C.CustomerID = O.CustomerID");

6) Propiedades autogeneradas:

Algo tan sencillo como crear una propiedad para una clase, lo es todavía más en C#, ya que permite el uso de propiedades autogeneradas. Esto hace que el compilador maneje internamente una variable privada a nivel de clase para almacenar el valor, quedando esta parte oculta al desarrollador. Esta característica estará disponible en la próxima versión de Visual Basic, pero de momento todavía tenemos que conformarnos con representarlo así:

C#:

class Foo

    public int id { get; set; }

    public string name { get; set; }

VB:

Class Foo

    Private _id As Integer

    Public Property id() As Integer

Get

            Return _id

        End Get

        Set(ByVal value As Integer)

            _id = value

        End Set

    End Property

    Private _name As String

    Public Property name() As String

Get

            Return _name

        End Get

        Set(ByVal value As String)

            _name = value

        End Set

    End Property

End Class

7) Refactoring:

Hoy en día, al igual que el uso de pruebas unitarias, empieza a ser impensable no refactorizar el código para una mejor comprensión, que repercute en un mejor índice de mantenibilidad (o Maintainability index, vaya usted a saber cómo se traduce) del código. Bien, pues el menú ‘Refactor’ del editor de C# no aparece en VB. Y la única información acerca de refactorizar el código VB nos enlaza con un Add-In de terceros, la cual a decir verdad es una gran utilidad. Lo sé, porque he usado la versión PRO de este producto durante bastante tiempo. Pero el hecho es que Visual Studio no incorpora ninguna utilidad ‘de fábrica’ para refactorizar el código, lo que no deja de ser sorprendente…

8) Posibilidad de desactivar ‘Strict on’:

Al ser VB la evolución de un lenguaje no tan ‘estricto’ como C#, nos ofrece la posibilidad de desactivar la opción Strict On, y de este modo dejar que el compilador se encargue de realizar muchas conversiones implícitas. Pero lo más peligroso de todo es que la opción viene desactivada ‘de fábrica’ y en cambio no conozco ningún buen programador de VB (que los hay, y muchos) que no sea lo primero que active. Muchos errores en tiempo de ejecución podrían ser evitados si el propio compilador nos obligase a codificar correctamente, en lugar de actual de este modo más ‘relajado’:

VB (con Option Strict Off):

Dim s As String

s = DateTime.Today

VB (con Option Strict On):

Dim s As String

s = DateTime.Today.ToString()

Observar que con Option Strict activado, el compilador no permite asignar una fecha a una variable de tipo cadena (con razón!), de modo que para poder compilar debemos realizar una conversión explícita.

Recomiendo dar un vistazo a este artículo de coding horror:
http://www.codinghorror.com/blog/archives/000355.html

9) Microsoft.VisualBasic:

Son legión los programadores que provienen de versiones anteriores de .NET (6 o anteriores), de modo que para facilitarles el camino los proyectos de VB incorporan el espacio de nombres Microsoft.VisualBasic, el cual a su vez incorpora muchas de las funciones de estas versiones anteriores. El hecho de incorporarlas no es un error en sí, lo malo es que estas funciones tienen su equivalente en el modelo de objetos del framework, y si seguimos usando estas funciones ‘antiguas’ no aprenderemos las nuevas, y el día en que debamos trabajar con otro lenguaje del Framework (que no tiene porque ser C#, hay unos cuantos más :-P) nos encontraremos con que estamos usando funciones propias de VB y no conoceremos su equivalente.

Por ejemplo, en lugar de llamar a la función Len para averiguar el número de caracteres de una cadena, es mejor usar el método Lenght de la clase String, lo mismo para Trim(), y todavía es más flagrante con Mid(), que equivale al método SubString del objeto String:

Dim n As Integer = Len(DateTime.Now.ToLongDateString)    'NO

Dim n As Integer = DateTime.Now.ToLongDateString.Lenght  'SI

No son pocos los esfuerzos de muchos compañeros, fantásticos programadores como Jorge Serrano o Harvey Triana para eliminar esta librería de nuestras aplicaciones, de modo que la recomendación siempre acaba siendo “no la uses, no la mires, haz como si no estuviera…”. Por cierto, os recomiendo una lectura de ambos artículos.

10) Hay más, y no se por cual decidirme…

Hay muchas otras cosas que se quedan en el tintero, porque algunas de ellas son demasiado largas (como el manejo de eventos), y otras no son precisamente de uso diario, como la ejecución de código no seguro (unsafe). Pero estaremos de acuerdo en que la mayoría de las novedades aparecen primero para C# (inicializadores de colecciones, propiedades autogeneradas, soporte para expresiones lambda ‘de verdad’, etc.) e incluso los compiladores de C# del proyecto MoNo van siempre por delante de los de VB. Aunque este último punto reconozco que no es demasiado importante… o sí?

En fin, vaya chapa me ha salido! Pero por lo menos ahora tengo una lista de cosas para cuando me pregunten “¿porque te gusta más C# que VB?”.

Un saludo desde Andorra,

** 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 **

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

lfranco — Tue, 08 Jul 2008 12:27:24 GMT

Buscar

Hoy vamos a buscar. Buscar elementos en el AD dentro de nuestra organización, y como lo más habitual es buscar usuarios o grupos he creado algunas funciones para facilitar esta tarea dentro de la clase LDAPServices (os dejo para vosotros ampliarlas para buscar equipos, por ejemplo).

También veremos cómo extraer los nombres de las propiedades de un objetos del AD, ya que en ocasiones queremos filtrar o devolver el valor de una propiedad de un objeto y no sabemos cómo se llama esta propiedad. Por ejemplo, para devolver el teléfono de un usuario en el AD hay que preguntar por el valor de la propiedad 'telephoneNumber'.

Tal vez más adelante (si tengo tiempo) lo ampliemos un poco. Me gustaría realizar un post acerca de cómo realizar un mapeador de propiedades para asignar los valores de las propiedades de objetos LDAP a objetos de nuestra aplicación. Esto podría ser muy útil por ejemplo, para importar los valores de nuestros usuarios de AD a una tabla de empleados.

Antes de empezar quiero comentaros que para poder realizar todo esto va a ser necesario agregar una referencia a System.DirectoryServices a nuestro proyecto. Pero vamos ya con estos nuevos métodos de LDAPServices:

getLDAPFilterString - Devuelve una cadena de consulta en formato LDAP query, que permite filtrar los objetos que deseamos devolver. Esta función filtra aquellos carácteres no deseados para evitar posible inyección de código LDAP por parte de un usuario (aunque es muy mejorable, estoy seguro que mi JoseMariCariño sería capaz de sacar información de aquí, casi me apuesto algo).

public enum LDAPFilterType

    UsersAndGroups,

    OnlyUsers,

    OnlyGroups

public static string

    getLDAPFilterString(LDAPFilterType Type, string Filter)

    Filter = Filter.Replace("&","");

    Filter = Filter.Replace("|","");

    Filter = Filter.Replace("*", "");

    string FilterByName = "(samAccountName=*{0}*)";

    string f = string.Empty;

    switch (Type)

        case LDAPFilterType.OnlyUsers:

            f = "(&(objectCategory=person)(objectClass=user){0})";

            break;

        case LDAPFilterType.OnlyGroups:

            f = "(&(objectCategory=Group){0})";

            break;

        case LDAPFilterType.UsersAndGroups:

            f = "(|(&(objectCategory=person)(objectClass=user){0})(&(objectCategory=Group){0}))";

            break;

    if (Filter == string.Empty)

        return string.Format(f, string.Empty);

    else

        return string.Format(f, string.Format(FilterByName, Filter));

getItemsInLDAP - Basándose en el método anterior, realiza la consulta al AD y devuelve una lista con los objetos coincidentes. Su funcionamiento se basa en un objeto DirectoryEntry, que apunta al AD que se le ha pasado como aergumento. Y en un objeto DirectorySearcher, que es el que realmente se encarga de buscar las entradas coincidentes con el filtro en el DirectoryEntry.

public static List<string>

    getItemsInLDAP(string LDAPURL, LDAPFilterType type, string criteria)

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

    DirectoryEntry entries = new DirectoryEntry(LDAPURL);

    string filter = getLDAPFilterString(type, criteria);

    DirectorySearcher searcher = new DirectorySearcher(

        entries, filter);

try

        foreach (SearchResult result in searcher.FindAll())

            items.Add((string)result.Properties["samAccountName"][0]);

    catch (Exception ex)

        throw ex;

    return items;

Para probar esta funcionalidad basta con tener un TextBox en el que introducir el criterio de búsqueda y un ComboBox en el que especificar que objetos deseamos buscar. Así cómo un CommandButon para lanzar la consulta y un ListBox en el que mostrar los resultados:

El código es muy sencillo. Basta con asignar el valor devuelto por la función getItemsInLDAP al DataSource de la lista.

private void cmbSearch_Click(object sender, EventArgs e)

try

        string dcName = LDAPServices.getLDAPDomainName(txtDomain.Text);

        List<string> items = LDAPServices.getItemsInLDAP(dcName,

            (LDAPServices.LDAPFilterType) cmbType.SelectedIndex, txtCriteria.Text);

        lstItems.DataSource = items;

    catch (Exception ex)

        MessageBox.Show(ex.Message,

             Application.ProductName,

             MessageBoxButtons.OK,

             MessageBoxIcon.Exclamation);

getUserLDAPProperties - Devuelve una lista de cadenas con los nombres de las propiedades de un objeto User dentro del AD. Cabe observar que el esquema del AD es variable, con lo que las propiedades devueltas pueden cambiar. Por ejemplo, productos que se integran fuertemente con AD como Exchange agregan propiedades a los objetos usuario y grupo.

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;

De este modo podemos saber las propiedades de un objeto dentro de nuestro AD. Esto es más importante de lo que parece, ya que cuando buscamos elementos dentro del AD, no se devuelven todas las propiedades de forma predeterminada. Para agregar el valor de una propiedad a los resultados de la búsqueda ésta debe añadirse explícitamente mediante la colección PropertiesToLoad:

searcher.PropertiesToLoad.Add("telephoneNumber");

Y luego comprobar si existe valor devuelto, ya que es posible que no exista o no devuelva valor:

if (r.Properties("telephoneNumber").Count > 0)

//

Y hasta aquí el cuarto capítulo de esta serie. Espero que os sea útil, recordar que en esta ocasión el código completo lo publiqué en el post anterior.

Nos vemos pronto!
Un saludo desde Andorra,

** 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 **

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 **

Language Futures Page on Code Gallery

lfranco — Wed, 12 Mar 2008 08:07:21 GMT

Quieres saber algunas de las cosas que se están cociendo para las nuevas versiones de los lenguajes de Visual Studio?

Entonces dale un vistazo a este sitio creado por la gente del Visual Studio Team, en el que encontrarás no sólo ejemplos de código sino que se plantean diversos threads en los que los equiposde desarrollo quiere tu feedback para para algunas características que están considerando para la siguiente versión de Visual Studio.

A modo de ejemplo he encontrado interesantes algunas características como el "Call Hierarchy" que permitiría mostrar desde el IDE las llamadas que se realizan a o desde un método, esto permitiría entender mejor el flujo del código, navegar a través de él y comprender el impacto de algunos cambios en nuestro código.

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

Heroes - The evolution show

lfranco — Thu, 28 Feb 2008 09:28:55 GMT

El show ha terminado. Mientras escribo esto, el resto de la gente debe estar viendo a Steve Balmer tirar sillas o a punto de empezar la fiesta final, y yo en cambio aquí estoy, en el tren de camino a casa... :-(

Atrás quedan dos días muy interesantes, llenos de sesiones técnicas, hands on labs y presentaciones, en los que he podido encontrarme de nuevo con viejos amigos y hacer otros nuevos. He disfrutado enormemente con algunas de las sesiones (David Salgado, José Murillo y Octavio Hernandez, Jose Alarcon, David Carmona, y los chicos de Team system), y si tuviese que poner algún pero, sólo he encontrado algunas pequeñas deficiencias organizativas. Como las salas de SQL Server que el primer día estaban abarrotadas, o la extraña ausencia de papeleras fuera de la tercera planta. Por otro lado, en un evento de esta magnitud supongo que es normal que no todo salga al 100%, y esto no han sido sino inconvenientes menores.

Así pues la impresión ha sido muy buena, y no tan solo en el aspecto técnico, sino también en el humano. La atmósfera que flota en estos eventos es magnífica, y además se respira pasión por la tecnología, algo que a todos nos apasiona. Es muy agradable poder tomar un café con compañeros MVP e intercambiar opiniones acerca de las últimas tecnologías, o compartir opiniones con empleados de Microsoft o con partners de lujo.

Me gustó especialmente la intervención el primer día del psicólogo Emilio Duró, con su particular visión de la vida, en una de esas charlas que te cargan las pilas una buena temporada.

Y bueno, ahora que el evento ha terminado, desde mi perspectiva de desarrollador me quedo con varias cosas:

- La aparición de LINQ y su modelo de proveedores, creo que va a suponer una revolución en la concepción del nuevo software que vamos a diseñar en adelante. La productividad que ofrece y su versatilidad gracias a su modelo extensible van a facilitar enormemente el trabajo con datos de SQL Server, archivos XML y colecciones de objetos en memoria. Tendrá sus detractores evidentemente, pero a mi juicio sus ventajas están muy por encima de sus defectos.

- La implantación de WPF y Silverlight es un hecho. Las posibilidades de WPF son conocidas por todos, pero debo agradecer a David Carmona, Marino posadas y a Miguel Jimemez la estupenda labor divulgativa que hoy han realizado Hoy justamente Marino posadas nos ha dado el notición de que la semana que viene vamos a poder disfrutar de la primera beta de la versión 2.0 de Silverlight, algo muy demandado por la comunidad de desarrolladores Web.

- Team System es una pieza básica en todo equipo de desarrollo de software, si bien hasta ahora siempre se ha tendido a pensar en su implantación en equipos grandes o con un alto requerimiento de calidad, ahora no hay excusa para no usar este estupendo producto que cubre todo el espectro de roles del equipo (jefes de proyecto, managers, arquitectos, desarrolladores, testers, DBAs, diseñadores, etc.)

Si tengo tiempo mañana intentaré publicar algo más en profundidad, que ahora van a servir la cena. Os dejo!

PD - Ahora que lo pienso si que he encontrado en falta un servicio de clonación para poder asistir a más sesiones en paralelo :-P

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

Mi agenda para los TechDays

lfranco — Mon, 25 Feb 2008 10:03:00 GMT

Hoy saldré para Madrid, al Evolution Show (lanzamiento de Visual Studio, SQL Server y Windows Server 2008). Os paso mi agenda por si alguno viene por aquí y compartimos alguna de las sesiones. Estaré encantado de tomar un café y charlar con vosotros... ¡nos vemos!

Agenda: 26/02
-----------------------------
09:30 - 11:00 (Auditorio A): Sesión Inaugural. Bienvenida
Plataforma 2008: el camino hacia “Dynamic IT”
Virtualización: desde el PC hasta el Centro de Datos
"El coeficiente de optimismo como clave del éxito", por Emilio Duró.
11:00 - 11:30 (Sala Mónaco): Hands-On Lab. Visual Studio: Windows Presentation Foundation. Colabora: Danysoft
11:30 - 12:15 (Sala París): .NET 3.5 Y Visual Studio 2008: Desarrolladores Web
12:30 - 14:00 (Auditorio B): Evolución de la plataforma de Acceso a Datos
14:00 - 14:30 (Sala Mónaco): Hands-On Lab. Visual Studio: Práctica de Desarrollo Dirigido por Pruebas (TDD, Test-Driven Development). Colabora: Danysoft
15:00 - 15:45 (Sala Madrid): Entity Framework a fondo
16:00 - 16:45 (Auditorio B): Evolución de la plataforma de servicios
17:00 - 17:45 (Auditorio B): Windows Server 2008 para Desarrolladores
18:00 - 19:00 (Sala Mónaco): Hands-On Lab. Visual Studio: Generación de una Plantilla de Proyecto Propia en Team System. Colabora: Danysoft

Agenda: 27/02
-----------------------------
09:30 - 10:30 (Auditorio B): ALM: Acelera el Ciclo de Vida de tus Aplicaciones. MVPs Team System.
10:45 - 12:00 (Auditorio B): Desarrollo de frontales web con Visual Studio 2008 y .NET 3.5
12:15 - 13:00 (Sala Mónaco): Hands-On Lab. Visual Studio 2008: LINQ Práctico. Colabora: Danysoft
13:00 - 14:00 (Sala Roma): SQL Server 2008: Nuevos tipos de Datos y Aplicaciones de próxima generación
14:00 - 15:00 (Auditorio B): Evolución de la experiencia de usuario con Windows Presentation Foundation y Silverlight
15:15 - 16:15 (Sala París): WPF a fondo

Lamentablemente, compromisos laborales no me permiten quedarme al cierre y a la fiesta, así que voy a tener que conformarme con ver las fotos :-(

Un saludo!

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

Primer evento en AndorradotNet

lfranco — Tue, 05 Feb 2008 12:07:36 GMT

Al fin! El pasado viernes 1 de Febrero se realizó el primer evento de AndorraDotNet.

En esta ocasión el tema a tratar fue SharePoint como plataforma de servicios al desarrollador, ya que fue el que salió más votado en los foros del grupo, en los que con anterioridad se habían propuesto los diversos posibles temas a tratar.

De modo que cuando toda la gente ‘normal’ se preparaba para largarse de fin de semana largo (en Andorra ayer lunes de Carnaval no se trabajó), unos puñado de tipos raros nos encontrábamos en la sala formación de FIMARGE (muchas gracias por la sala!), para departir sobre tecnología .NET, en el primero de (espero) muchos eventos del grupo.

La sesión “Sumérgete en SharePoint” empezó a las 18h15, se desarrolló sin incidencias y con bastantes risas, y se prolongó por casi tres horas, así que cuando terminamos ya no sabíamos si estábamos hablando del modelo de objetos de SharePoint, o del peso del chuletón que nos íbamos a meter entre pecho y espalda :-)

Al salir, algunos de los irreductibles nos fuimos a tomar unas cañas a Casa Teresa y seguimos hablando del tema (hay que ver lo frikis que llegamos a ser), y sólo empezó a cambiar la conversación cuando nos desplazamos al restaurante y nos plantaron delante algo con lo que calmar nuestros estómagos.

En breve se iniciarán las votaciones con los posibles temas a tratar para el próximo evento, así que estar atentos porque ¡volveremos pronto!

PD - Por cierto, gracias por las fotos a Josep “Gadgets”, ya que (como siempre) me olvidé la cámara :-P

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

Mejoras en el IDE de VB2008

lfranco — Wed, 09 Jan 2008 09:48:13 GMT

:-)

Siempre me he sentido más cómodo escribiendo código C# que VB dentro del IDE de Visual Studio 2005, tal vez será porque el soporte para IntelliSense está más desarrollado, porque me conozco mejor los atajos de teclado, o quizás porque debido a la sintaxis del lenguaje escribo menos para realizar lo mismo (aquí he tenido alguna discusión en la terraza de un bar con el Guille :-P).

La cuestión es que ahora el equipo de VB2008 acaba de publicar un post en el que se explican las *muchas* mejoras que se han realizado en cuanto al soporte para IntelliSense. No las voy a enumerar aquí pero se resumen en el título del post: IntelliSense Everywhere!

Tal vez ahora le pague aquella cerveza que nos apostamos al Guille... ;-)

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