El blog de Lluis Franco : HowTo

HowTo: Obtener TODOS los usuarios de un grupo del Directorio Activo

lfranco — Mon, 30 Nov 2009 16:58:36 GMT

Siguiendo con el tema de las últimas entradas, vamos a ver cómo obtener TODOS los usuarios que pertenecen a un grupo del directorio activo. Y cuando digo TODOS los usuarios, me refiero a TODOS (por algo lo he puesto en mayúsculas :-D). Es decir, dentro de un grupo podemos tener otros grupos, que a su vez contengan otros grupos y así succesivamente... y nuestro objetivo es obtener todos los usuarios de forma recursiva.

Para obtener los datos de estos usuarios vamos a crear una clase, para ir almacenando las propiedades que deseamos obtener de cada usuario. Y una función que obtenga los usuarios de un grupo, y se llame a sí misma de forma recursiva en caso que este grupo contenga otros grupos.

El código de la clase:

public class ADUser

    public byte[] Sid { get; set; }

    public string Name { get; set; }

    public string DistinguishedName { get; set; }

    public string SAMAccountName { get; set; }

    public int RoleType { get; set; }

    public ADUser(byte[] sid, string name,

        string distinguishedName, string sAMAccountName)

        Sid = sid;

        Name = name;

        DistinguishedName = distinguishedName;

        SAMAccountName = sAMAccountName;

    public string sIDtoString()

        SecurityIdentifier sid = new SecurityIdentifier(Sid, 0);

        return sid.ToString();

Y el método que devuelve todos los usuarios de un grupo de forma recursiva:

namespace Alpha.Code

    public class SecurityContextEx

        public static string getDomainName()

            return IPGlobalProperties.GetIPGlobalProperties().DomainName;

        public static string getLDAPDomainName(string domainName)

            StringBuilder sb = new StringBuilder();

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

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

            foreach (string item in dcItems)

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

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

        public static List<ADUser> GetUsersInGroup(string group)

            List<ADUser> users = new List<ADUser>();

            string ldapDomainName = SecurityContext.getLDAPDomainName(SecurityContext.getDomainName());

            string domainName = ldapDomainName.Replace("LDAP://", string.Empty);

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

            DirectoryEntry de = new DirectoryEntry(ldapDomainName);

            DirectorySearcher ds = new DirectorySearcher(de, "(objectClass=person)");

            ds.Filter = "(&(objectClass=group)(cn=" + group + "))";

            foreach (SearchResult result in ds.FindAll())

                var dir = result.GetDirectoryEntry();

                var list = dir.Invoke("Members");

                IEnumerable entries = (IEnumerable)list;

                foreach (var entry in entries)

                    DirectoryEntry member = new DirectoryEntry(entry);

                    if (member.SchemaClassName == "group")

                        List<ADUser> usersInGroup =

                            GetUsersInGroup(member.Properties["name"][0].ToString());

                        foreach (ADUser aduser in usersInGroup)

                            if (!users.ToDictionary(u => u.Name).ContainsKey(aduser.Name))

                                users.Add(aduser);

                    else

                        ADUser aduser = new ADUser(

                            (byte[])member.Properties["objectSid"][0],

                            member.Properties["name"][0].ToString(),

                            member.Properties["distinguishedName"][0].ToString(),

                            member.Properties["sAMAccountName"][0].ToString());

                        users.Add(aduser);

            return users;

Aparte de la función GetUsersInGroup, también existen un par de métodos de apoyo para averiguar el nombre de nuestro dominio, que creo recordar que he publicado con anterioridad, pero por si acaso os los he publicado también.

Si deseamos obtener los usuarios de un grupo en particular, basta con usarlo de este modo:

List<ADUser> users = SecurityContextEx.GetUsersInGroup("My users");

Nota: En ocasiones, puede resultar una buena práctica para la administración de la seguridad de nuestras aplicaciones, crear un grupo en el directorio activo con el mismo nombre de la aplicación. Y de este modo conceder acceso a todos los miembros de dicho grupo a nuestra aplicación. En este caso todavía resultaría más sencillo mostrar todos los usuarios a los que hemos concedido acceso:

List<ADUser> users = SecurityContextEx.GetUsersInGroup(Application.ProductName);

Espero que os haya gustado,

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

Y después de la nevada de ayer, esta vez más frías que nunca…

Noviembre 2009

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

HowTo: Agrupando grupos :-)

lfranco — Thu, 26 Nov 2009 11:53:51 GMT

Una entrada rápida, no como la de ayer. Aunque el tema está bastante relacionado ya que ambos tratan de Active Directory e identidades.

Hoy vamos a ver una forma sencilla de obtener todos los grupos a los que pertenece un usuario, y agruparlos por su nombre de dominio. Y todo esto mediante una sola sentencia LINQ to objects. A ver quién es el guapo o guapa que me dice que LINQ to objects no es una maravilla!

El resultado que vamos a obtener es el siguiente (algunos nombres se han omitido por razones obvias :-P):

Groups under:
- Group name: Todos
- Group name: LOCAL
Groups under: BUILTIN
- Group name: Usuarios
- Group name: Administradores
Groups under: PRIMARY_DOMAIN_NAME
- Group name: xxx1
- Group name: xxx2
- Group name: xxx3
- Group name: xxx4
- Group name: xxxN
Groups under: NT AUTHORITY
- Group name: INTERACTIVE
- Group name: Usuarios autentificados

Y el código resultante es un método extensor para la clase WindowsIdentity, con dos funciones auxiliares en forma de métodos extensores de la clase NTAccount:

using System;

using System.Collections.Generic;

using System.DirectoryServices;

using System.DirectoryServices.ActiveDirectory;

using System.Linq;

using System.Net.NetworkInformation;

using System.Runtime.InteropServices;

using System.Security.Principal;

using System.Text;

namespace Alpha.Code

    public static class SecurityExtensions

        public static IOrderedEnumerable<IGrouping <string, NTAccount>>

            GetGroupsUnderDomains(this WindowsIdentity identity)

            var groups =

                        from grIdentity in identity.Groups

                        where grIdentity.IsValidTargetType(typeof(NTAccount))

                        select grIdentity.Translate(typeof(NTAccount)) as NTAccount into ntAccounts

                        let domainName = ntAccounts.GetDomainName()

                        let groupName = ntAccounts.GetAccountName()

                        orderby domainName

                        group ntAccounts by domainName into domainGroups

                        orderby domainGroups.Key

                        select domainGroups;

            return groups;

        public static string GetDomainName(this NTAccount account)

            string[] split = account.Value.Split('\\');

            return split.Length == 1 ? string.Empty : split[0];

        public static string GetAccountName(this NTAccount account)

            string[] split = account.Value.Split('\\');

            return split[split.Length - 1];

Para probarlo y ver el resultado:

var groups = WindowsIdentity.GetCurrent().GetGroupsUnderDomains();

foreach (var dg in groups)

    Console.WriteLine(string.Format("Groups under: {0}", dg.Key));

    foreach (var g in dg)

        Console.WriteLine(string.Format("  - Group name: {0}", g.GetAccountName()));

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

Noviembre 2009

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

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

lfranco — Wed, 25 Nov 2009 18:03:00 GMT

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

El escenario

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

IsInRole

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

Nombre de miembro	Descripción
AccountOperator	Los operadores de cuentas administran las cuentas de los usuarios de un equipo o dominio.
Administrator	Los administradores tienen acceso completo y sin restricciones al equipo o dominio.
BackupOperator	Los operadores de copia de seguridad pueden reemplazar las restricciones de seguridad con el único propósito de hacer copias de seguridad de los archivos o de restaurarlas.
Guest	Los invitados tienen más restricciones que los usuarios.
PowerUser	Los usuarios avanzados poseen la mayoría de los permisos administrativos, con algunas restricciones. De este modo, los usuarios avanzados pueden ejecutar aplicaciones heredadas, además de aplicaciones certificadas.
PrintOperator	Los operadores de impresión pueden tomar el control de una impresora.
Replicator	Los replicadores permiten la duplicación de archivos en un dominio.
SystemOperator	Los operadores del sistema administran un equipo en particular.
User	Los usuarios no pueden realizar cambios accidentales o intencionados en todo el sistema. En consecuencia, pueden ejecutar aplicaciones certificadas, pero no la mayoría de las aplicaciones heredadas.

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

WindowsPrincipal wp = new WindowsPrincipal(WindowsIdentity.GetCurrent());

return wp.IsInRole(WindowsBuiltInRole.Administrator);

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

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

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

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

WellKnownSidType

Existe una enumeración llamada WellKnownSidType, que devuelve los identificadores de seguridad más utilizados, vamos a darle un vistazo:

Member name	Description
NullSid	Indicates a null SID.
WorldSid	Indicates a SID that matches everyone.
LocalSid	Indicates a local SID.
CreatorOwnerSid	Indicates a SID that matches the owner or creator of an object.
CreatorGroupSid	Indicates a SID that matches the creator group of an object.
CreatorOwnerServerSid	Indicates a creator owner server SID.
CreatorGroupServerSid	Indicates a creator group server SID.
NTAuthoritySid	Indicates a SID for the Windows NT authority.
DialupSid	Indicates a SID for a dial-up account.
NetworkSid	Indicates a SID for a network account. This SID is added to the process of a token when it logs on across a network.
BatchSid	Indicates a SID for a batch process. This SID is added to the process of a token when it logs on as a batch job.
InteractiveSid	Indicates a SID for an interactive account. This SID is added to the process of a token when it logs on interactively.
ServiceSid	Indicates a SID for a service. This SID is added to the process of a token when it logs on as a service.
AnonymousSid	Indicates a SID for the anonymous account.
ProxySid	Indicates a proxy SID.
EnterpriseControllersSid	Indicates a SID for an enterprise controller.
SelfSid	Indicates a SID for self.
AuthenticatedUserSid	Indicates a SID for an authenticated user.
RestrictedCodeSid	Indicates a SID for restricted code.
TerminalServerSid	Indicates a SID that matches a terminal server account.
RemoteLogonIdSid	Indicates a SID that matches remote logons.
LogonIdsSid	Indicates a SID that matches logon IDs.
LocalSystemSid	Indicates a SID that matches the local system.
LocalServiceSid	Indicates a SID that matches a local service.
NetworkServiceSid	Indicates a SID that matches a network service.
BuiltinDomainSid	Indicates a SID that matches the domain account.
BuiltinAdministratorsSid	Indicates a SID that matches the administrator account.
BuiltinUsersSid	Indicates a SID that matches built-in user accounts.
BuiltinGuestsSid	Indicates a SID that matches the guest account.
BuiltinPowerUsersSid	Indicates a SID that matches the power users group.
BuiltinAccountOperatorsSid	Indicates a SID that matches the account operators account.
BuiltinSystemOperatorsSid	Indicates a SID that matches the system operators group.
BuiltinPrintOperatorsSid	Indicates a SID that matches the print operators group.
BuiltinBackupOperatorsSid	Indicates a SID that matches the backup operators group.
BuiltinReplicatorSid	Indicates a SID that matches the replicator account.
BuiltinPreWindows2000CompatibleAccessSid	Indicates a SID that matches pre-Windows 2000 compatible accounts.
BuiltinRemoteDesktopUsersSid	Indicates a SID that matches remote desktop users.
BuiltinNetworkConfigurationOperatorsSid	Indicates a SID that matches the network operators group.
AccountAdministratorSid	Indicates a SID that matches the account administrators group.
AccountGuestSid	Indicates a SID that matches the account guest group.
AccountKrbtgtSid	Indicates a SID that matches the account Kerberos target group.
AccountDomainAdminsSid	Indicates a SID that matches the account domain administrator group.
AccountDomainUsersSid	Indicates a SID that matches the account domain users group.
AccountDomainGuestsSid	Indicates a SID that matches the account domain guests group.
AccountComputersSid	Indicates a SID that matches the account computer group.
AccountControllersSid	Indicates a SID that matches the account controller group.
AccountCertAdminsSid	Indicates a SID that matches the certificate administrators group.
AccountSchemaAdminsSid	Indicates a SID that matches the schema administrators group.
AccountEnterpriseAdminsSid	Indicates a SID that matches the enterprise administrators group.
AccountPolicyAdminsSid	Indicates a SID that matches the policy administrators group.
AccountRasAndIasServersSid	Indicates a SID that matches the RAS and IAS server account.
NtlmAuthenticationSid	Indicates a SID present when the Microsoft NTLM authentication package authenticated the client.
DigestAuthenticationSid	Indicates a SID present when the Microsoft Digest authentication package authenticated the client.
SChannelAuthenticationSid	Indicates a SID present when the Secure Channel (SSL/TLS) authentication package authenticated the client.
ThisOrganizationSid	Indicates a SID present when the user authenticated from within the forest or across a trust that does not have the selective authentication option enabled. If this SID is present, then OtherOrganizationSid cannot be present.
OtherOrganizationSid	Indicates a SID present when the user authenticated across a forest with the selective authentication option enabled. If this SID is present, then ThisOrganizationSid cannot be present.
BuiltinIncomingForestTrustBuildersSid	Indicates a SID that allows a user to create incoming forest trusts. It is added to the token of users who are a member of the Incoming Forest Trust Builders built-in group in the root domain of the forest.
BuiltinPerformanceMonitoringUsersSid	Indicates a SID that matches the group of users that have remote access to schedule logging of performance counters on this computer.
BuiltinPerformanceLoggingUsersSid	Indicates a SID that matches the group of users that have remote access to monitor the computer.
BuiltinAuthorizationAccessSid	Indicates a SID that matches the Windows Authorization Access group.
WinBuiltinTerminalServerLicenseServersSid	Indicates a SID is present in a server that can issue Terminal Server licenses.
MaxDefined	Indicates the maximum defined SID in the WellKnownSidType enumeration.

BINGO!!! Parece que tenemos el SID del grupo de admnistradores del dominio (lo he marcado en rojo en la tabla anterior).

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

WindowsPrincipal wp = new WindowsPrincipal(WindowsIdentity.GetCurrent());

SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.AccountDomainAdminsSid, null);

return wp.IsInRole(sid);

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

DomainSid

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

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

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

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

Domain d = Domain.GetDomain(new

    DirectoryContext(DirectoryContextType.Domain, getDomainName()));

using (DirectoryEntry de = d.GetDirectoryEntry())

    byte[] domSid = (byte[])de.Properties["objectSid"].Value;

    string sdomainSid = sIDtoString(domSid);

    Console.WriteLine(sdomainSid);

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

public static string getDomainName()

    return IPGlobalProperties.GetIPGlobalProperties().DomainName;

public static string sIDtoString(byte[] sidBinary)

    SecurityIdentifier sid = new SecurityIdentifier(sidBinary, 0);

    return sid.ToString();

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

Poniéndolo todo junto

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

using System.DirectoryServices;

using System.DirectoryServices.ActiveDirectory;

using System.Net.NetworkInformation;

using System.Security.Principal;

namespace Alpha.Code

    public static class SecurityExtensions

        public static bool IsDomainAdmin (this WindowsIdentity identity)

            Domain d = Domain.GetDomain(new

                DirectoryContext(DirectoryContextType.Domain, getDomainName()));

            using (DirectoryEntry de = d.GetDirectoryEntry())

                byte[] bdomSid = (byte[])de.Properties["objectSid"].Value;

                string sdomainSid = sIDtoString(bdomSid);

                WindowsPrincipal wp = new WindowsPrincipal(identity);

                SecurityIdentifier dsid = new SecurityIdentifier(sdomainSid);

                SecurityIdentifier dasid = new SecurityIdentifier(

                    WellKnownSidType.AccountDomainAdminsSid, dsid);

                return wp.IsInRole(dasid);

        public static string getDomainName()

            return IPGlobalProperties.GetIPGlobalProperties().DomainName;

        public static string sIDtoString(byte[] sidBinary)

            SecurityIdentifier sid = new SecurityIdentifier(sidBinary, 0);

            return sid.ToString();

Y la forma de usarlo es tan sencilla como esto:

if (WindowsIdentity.GetCurrent().IsDomainAdmin())

    //Acciones a realizar si el usuario es administrador de dominio...

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

Noviembre 2009

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

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (VII)

lfranco — Fri, 20 Mar 2009 08:07:00 GMT

Entradas anteriores de la serie:

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (II)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (III)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (IV)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (V)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (VI)

Han pasado unos días desde que publiqué la última entrada, y es que voy absolutamente desbordado de curro.

Pero como lo prometido es deuda, vamos a proseguir con el tema, ya quedan un par de temas por ver antes de concluir la serie:

Cómo ejecutar distintos threads y mostrar el progreso (Callbacks).

Cómo distribuir nuestro complemento, creando un archivo MSI (Windows Installer packages).

Además, os dije que en el último post publicaría el código fuente del proyecto… y varios de vosotros ya lo habéis reclamado con insistencia :-P

De modo que vamos a hacerlo al revés: Hoy publico el código fuente del proyecto, y mañana (espero) continuaré el resto de la serie. De este modo al menos ya tendreis el código para jugar con él, y poder machacarme a preguntas…

El proyecto incluye el código de ejemplo del Add-In y el proyecto de instalación, y lo podéis descargar desde este enlace de Skydrive:

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

Saludos desde Andorra,

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

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

How to: Utilizar en modelo de proveedores de datos de ADO.NET 2.0

lfranco — Sat, 12 Jul 2008 10:03:31 GMT

(*) Este post es bastante antiguo y lo tenía publicado en otro blog que ya no existe, pero como veo que es un tema recurrente en los foros de MSDN he decidido publicarlo de nuevo.

A petición del inefable Juansa, vamos a ver cómo funciona el modelo de proveedores de ADO.NET 2.0.

Estre modelo es ideal para todas aquellas aplicaciones que deben utilizar distintos proveedores de datos (Access, SQL Server, Oracle), ya que disponen de unas factorías de objetos que proporcionan un nivel de abstracción. Por ejemplo, si deseamos usar el proveedor de SQL Server ya no es necesario usar las clases conexión, comando, etc. que hay dentro del namespace System.Data.SqlClient, ahora podemos crear una factoría basada en SQL Server y pedirle que nos cree una clase de tipo connection, comando, etc.

De este modo, si deseamos cambiar el proveedor de datos basta con cambiar el string del nombre del proveedor y la cadena de conexión. Para muestra un botón:

Private Sub TestFactoryProviders()

    Dim ProviderName As String = "System.Data.SqlClient"

    Dim CnnStr As String = "Data Source=TU_SERVIDOR_SQL;" + _

        "Initial Catalog=TU_BD;" + _

        "Integrated Security=True"

    Dim SQLStr As String = "SELECT * FROM TU_TABLA"

    'Crea la factoria en base al proveedor especificado

    Dim Factory As DbProviderFactory = DbProviderFactories.GetFactory(ProviderName)

    'Crea la conexión del tipo apropiado (según proveedor)

    Dim Con As DbConnection = Factory.CreateConnection()

    Using Con

        'Asigna la cadena de conexión

        Con.ConnectionString = CnnStr

        Con.Open()

        'Crea un command del tipo apropiado (según proveedor)

        Dim Cmd As DbCommand = Con.CreateCommand()

        Using Cmd

            Cmd.CommandType = CommandType.Text

            Cmd.CommandText = SQLStr

            'Crea un DataTable y lo llena a partir del

            'DataReader que devuelve el comando

            Dim dt As DataTable = New DataTable("dt1")

            dt.Load(Cmd.ExecuteReader())

            For Each row As DataRow In dt.Rows

                'Haz lo que quieras con los datos... :-P

            Next

        End Using

        Con.Close()

    End Using

End Sub

Según el ejemplo, cambiando los valores de las dos primeras variables podemos utilizar cualquier origen de datos de forma indistinta.
Happy coding!

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