¿Cómo enumerar todas las clases con un atributo de clase personalizado?

Pregunta basada en el ejemplo de MSDN .

Digamos que tenemos algunas clases de C # con HelpAttribute en una aplicación de escritorio independiente. ¿Es posible enumerar todas las clases con dicho atributo? ¿Tiene sentido reconocer las clases de esta manera? El atributo personalizado se usaría para enumerar las posibles opciones de menú, al seleccionar el elemento se mostrará en la pantalla la instancia de dicha clase. El número de clases / artículos crecerá lentamente, pero de esta manera podemos evitar enumerarlos en otros lugares, creo.

Si, absolutamente. Usando la reflexión:

static IEnumerable<Type> GetTypesWithHelpAttribute(Assembly assembly) {
    foreach(Type type in assembly.GetTypes()) {
        if (type.GetCustomAttributes(typeof(HelpAttribute), true).Length > 0) {
            yield return type;
        }
    }
}

Bueno, tendría que enumerar todas las clases en todos los ensamblados que se cargan en el dominio de la aplicación actual. Para hacer eso, llamaría al GetAssembliesmétodo en la AppDomaininstancia para el dominio de la aplicación actual.

Desde allí, llamaría GetExportedTypes(si solo desea tipos públicos) o GetTypesen cada uno Assemblypara obtener los tipos contenidos en el ensamblado.

Luego, llamaría al GetCustomAttributesmétodo de extensión en cada Typeinstancia, pasando el tipo de atributo que desea encontrar.

Puede usar LINQ para simplificar esto para usted:

var typesWithMyAttribute =
    from a in AppDomain.CurrentDomain.GetAssemblies()
    from t in a.GetTypes()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

La consulta anterior le proporcionará cada tipo con su atributo aplicado, junto con la instancia de los atributos asignados a él.

Tenga en cuenta que si tiene una gran cantidad de ensamblados cargados en el dominio de su aplicación, esa operación podría ser costosa. Puede usar Parallel LINQ para reducir el tiempo de la operación, así:

var typesWithMyAttribute =
    // Note the AsParallel here, this will parallelize everything after.
    from a in AppDomain.CurrentDomain.GetAssemblies().AsParallel()
    from t in a.GetTypes()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

Filtrarlo en un específico Assemblyes simple:

Assembly assembly = ...;

var typesWithMyAttribute =
    from t in assembly.GetTypes()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

Y si el ensamblaje tiene una gran cantidad de tipos, puede usar Parallel LINQ nuevamente:

Assembly assembly = ...;

var typesWithMyAttribute =
    // Partition on the type list initially.
    from t in assembly.GetTypes().AsParallel()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

Otras respuestas hacen referencia a GetCustomAttributes . Agregar este como ejemplo de uso de IsDefined

Assembly assembly = ...
var typesWithHelpAttribute = 
        from type in assembly.GetTypes()
        where type.IsDefined(typeof(HelpAttribute), false)
        select type;

Como ya se dijo, la reflexión es el camino a seguir. Si va a llamar a esto con frecuencia, le recomiendo almacenar en caché los resultados, ya que la reflexión, especialmente la enumeración en cada clase, puede ser bastante lenta.

Este es un fragmento de mi código que se ejecuta en todos los tipos en todos los ensamblados cargados:

// this is making the assumption that all assemblies we need are already loaded.
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) 
{
    foreach (Type type in assembly.GetTypes())
    {
        var attribs = type.GetCustomAttributes(typeof(MyCustomAttribute), false);
        if (attribs != null && attribs.Length > 0)
        {
            // add to a cache.
        }
    }
}

Esta es una mejora del rendimiento además de la solución aceptada. Iterar aunque todas las clases pueden ser lentas porque hay muchas. A veces puede filtrar un conjunto completo sin mirar ninguno de sus tipos.

Por ejemplo, si está buscando un atributo que usted mismo declaró, no espera que ninguna de las DLL del sistema contenga ningún tipo con ese atributo. La propiedad Assembly.GlobalAssemblyCache es una forma rápida de verificar las DLL del sistema. Cuando probé esto en un programa real, descubrí que podía omitir 30,101 tipos y solo tengo que verificar 1,983 tipos.

Otra forma de filtrar es usar Assembly.ReferencedAssemblies. Presumiblemente, si desea clases con un atributo específico, y ese atributo se define en un ensamblaje específico, entonces solo le importa ese ensamblaje y otros ensamblajes que hacen referencia a él. En mis pruebas, esto ayudó un poco más que verificar la propiedad GlobalAssemblyCache.

Combiné ambos y lo obtuve aún más rápido. El siguiente código incluye ambos filtros.

        string definedIn = typeof(XmlDecoderAttribute).Assembly.GetName().Name;
        foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            // Note that we have to call GetName().Name.  Just GetName() will not work.  The following
            // if statement never ran when I tried to compare the results of GetName().
            if ((!assembly.GlobalAssemblyCache) && ((assembly.GetName().Name == definedIn) || assembly.GetReferencedAssemblies().Any(a => a.Name == definedIn)))
                foreach (Type type in assembly.GetTypes())
                    if (type.GetCustomAttributes(typeof(XmlDecoderAttribute), true).Length > 0)

En el caso de las limitaciones de Portable .NET , el siguiente código debería funcionar:

    public static IEnumerable<TypeInfo> GetAtributedTypes( Assembly[] assemblies, 
                                                           Type attributeType )
    {
        var typesAttributed =
            from assembly in assemblies
            from type in assembly.DefinedTypes
            where type.IsDefined(attributeType, false)
            select type;
        return typesAttributed;
    }

o para una gran cantidad de ensamblajes que utilizan el estado de bucle yield return:

    public static IEnumerable<TypeInfo> GetAtributedTypes( Assembly[] assemblies, 
                                                           Type attributeType )
    {
        foreach (var assembly in assemblies)
        {
            foreach (var typeInfo in assembly.DefinedTypes)
            {
                if (typeInfo.IsDefined(attributeType, false))
                {
                    yield return typeInfo;
                }
            }
        }
    }

Podemos mejorar la respuesta de Andrew y convertir todo en una consulta LINQ.

    public static IEnumerable<Type> GetTypesWithHelpAttribute(Assembly assembly)
    {
        return assembly.GetTypes().Where(type => type.GetCustomAttributes(typeof(HelpAttribute), true).Length > 0);
    }