Como enumerar todas as classes com atributo de classe personalizada?

Pergunta baseada no exemplo do MSDN .

Digamos que tenhamos algumas classes de C # com HelpAttribute no aplicativo de desktop independente. É possível enumerar todas as classes com esse atributo? Faz sentido reconhecer classes dessa maneira? O atributo personalizado seria usado para listar as opções de menu possíveis, a seleção do item trará para a instância de tela dessa classe. O número de classes / itens aumentará lentamente, mas dessa forma podemos evitar enumerá-los em outros lugares, eu acho.

Sim absolutamente. Usando Reflexão:

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

Bem, você teria que enumerar todas as classes em todos os assemblies carregados no domínio do aplicativo atual. Para fazer isso, você chamaria o GetAssembliesmétodo na AppDomaininstância para o domínio de aplicativo atual.

A partir daí, você chamaria GetExportedTypes(se quiser apenas tipos públicos) ou GetTypesem cada um Assemblypara obter os tipos que estão contidos na montagem.

Em seguida, você chamaria o GetCustomAttributesmétodo de extensão em cada Typeinstância, passando o tipo do atributo que deseja encontrar.

Você pode usar o LINQ para simplificar isso para você:

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>() };

A consulta acima fornecerá a você cada tipo com seu atributo aplicado a ela, juntamente com a instância do (s) atributo (s) atribuído (s) a ela.

Observe que, se você tiver um grande número de assemblies carregados no domínio do aplicativo, essa operação poderá ser cara. Você pode usar o LINQ paralelo para reduzir o tempo da operação, assim:

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>() };

Filtrando-o em um específico Assembly é simples:

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>() };

E se a montagem tiver um grande número de tipos, você poderá usar o Parallel LINQ novamente:

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>() };

Outras respostas referenciam GetCustomAttributes . Adicionando este como um exemplo do uso de IsDefined

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

Como já foi dito, a reflexão é o caminho a percorrer. Se você vai chamar isso com frequência, sugiro que os resultados sejam armazenados em cache, pois a reflexão, especialmente enumerando todas as classes, pode ser bastante lenta.

Este é um trecho do meu código que percorre todos os tipos em todos os assemblies carregados:

// 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.
        }
    }
}

Este é um aprimoramento de desempenho sobre a solução aceita. A iteração, embora todas as classes possam ser lentas, porque existem muitas. Às vezes, você pode filtrar uma montagem inteira sem observar nenhum de seus tipos.

Por exemplo, se você estiver procurando por um atributo que você mesmo declarou, não espera que nenhuma das DLLs do sistema contenha nenhum tipo com esse atributo. A propriedade Assembly.GlobalAssemblyCache é uma maneira rápida de verificar as DLLs do sistema. Quando tentei isso em um programa real, descobri que podia pular 30.101 tipos e só tenho que verificar 1.983 tipos.

Outra maneira de filtrar é usar Assembly.ReferencedAssemblies. Presumivelmente, se você deseja classes com um atributo específico, e esse atributo é definido em uma montagem específica, você só se preocupa com essa montagem e outras montagens que a referenciam. Nos meus testes, isso ajudou um pouco mais do que a verificação da propriedade GlobalAssemblyCache.

Combinei os dois e consegui ainda mais rápido. O código abaixo inclui os dois 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)

No caso de limitações Portable .NET , o seguinte código deve 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;
    }

ou para um grande número de montagens usando o loop-state 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 melhorar a resposta de Andrew e converter tudo em uma consulta LINQ.

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