Comment énumérer toutes les classes avec un attribut de classe personnalisé?

Question basée sur l' exemple MSDN .

Disons que nous avons des classes C # avec HelpAttribute dans une application de bureau autonome. Est-il possible d'énumérer toutes les classes avec un tel attribut? Est-il judicieux de reconnaître les classes de cette façon? L'attribut personnalisé serait utilisé pour lister les options de menu possibles, la sélection d'un élément amènera à l'écran l'instance de cette classe. Le nombre de classes / éléments augmentera lentement, mais de cette façon, nous pouvons éviter de les énumérer tous ailleurs, je pense.

Oui absolument. Utilisation de la réflexion:

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

Eh bien, vous devrez énumérer toutes les classes de tous les assemblys chargés dans le domaine d'application actuel. Pour ce faire, vous appelleriez la GetAssembliesméthode sur l' AppDomaininstance pour le domaine d'application actuel.

À partir de là, vous appelleriez GetExportedTypes(si vous ne voulez que des types publics) ou GetTypessur chacun Assemblyd' eux pour obtenir les types contenus dans l'assembly.

Ensuite, vous appelleriez la GetCustomAttributesméthode d'extension sur chaque Typeinstance, en passant le type de l'attribut que vous souhaitez trouver.

Vous pouvez utiliser LINQ pour simplifier cela pour vous:

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 requête ci-dessus vous obtiendra chaque type avec votre attribut appliqué, ainsi que l'instance du ou des attributs qui lui sont attribués.

Notez que si vous avez un grand nombre d'assemblys chargés dans votre domaine d'application, cette opération peut être coûteuse. Vous pouvez utiliser Parallel LINQ pour réduire la durée de l'opération, comme ceci:

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

Le filtrer sur un spécifique Assemblyest 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>() };

Et si l'assembly contient un grand nombre de types, vous pouvez à nouveau utiliser Parallel LINQ:

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

D'autres réponses font référence à GetCustomAttributes . Ajout de celui-ci comme exemple d'utilisation d' IsDefined

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

Comme déjà indiqué, la réflexion est la voie à suivre. Si vous appelez cela fréquemment, je suggère fortement de mettre en cache les résultats, car la réflexion, en particulier l'énumération de chaque classe, peut être assez lente.

Ceci est un extrait de mon code qui traverse tous les types dans tous les assemblys chargés:

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

Il s'agit d'une amélioration des performances en plus de la solution acceptée. Itérer toutes les classes peut être lent car il y en a tellement. Parfois, vous pouvez filtrer un assemblage entier sans regarder aucun de ses types.

Par exemple, si vous recherchez un attribut que vous avez déclaré vous-même, vous ne vous attendez pas à ce que l'une des DLL système contienne des types avec cet attribut. La propriété Assembly.GlobalAssemblyCache est un moyen rapide de rechercher les DLL système. Quand j'ai essayé cela sur un vrai programme, j'ai découvert que je pouvais sauter 30 101 types et que je n'avais qu'à vérifier 1 983 types.

Une autre façon de filtrer consiste à utiliser Assembly.ReferencedAssemblies. Vraisemblablement, si vous voulez des classes avec un attribut spécifique et que cet attribut est défini dans un assembly spécifique, vous ne vous souciez que de cet assembly et des autres assemblys qui le référencent. Dans mes tests, cela m'a aidé un peu plus que la vérification de la propriété GlobalAssemblyCache.

J'ai combiné les deux et je l'ai obtenu encore plus rapidement. Le code ci-dessous comprend les deux filtres.

        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 cas de limitations de Portable .NET , le code suivant devrait fonctionner:

    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 pour un grand nombre d'assemblys utilisant des états de boucle 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;
                }
            }
        }
    }

Nous pouvons améliorer la réponse d'Andrew et convertir le tout en une seule requête LINQ.

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