Que sont les attributs dans .NET ?

Question

Que sont les attributs dans .NET, à quoi servent-ils et comment puis-je créer mes propres attributs ?

Answer 1

Métadonnées. Données sur vos objets/méthodes/propriétés.

Par exemple, je peux déclarer un attribut appelé : DisplayOrder pour pouvoir contrôler facilement l'ordre dans lequel les propriétés doivent apparaître dans l'interface utilisateur. Je pourrais ensuite l'ajouter à une classe et écrire des composants d'interface graphique qui extraient les attributs et ordonnent les éléments de l'interface utilisateur de manière appropriée.

public class DisplayWrapper
{
    private UnderlyingClass underlyingObject;

    public DisplayWrapper(UnderlyingClass u)
    {
        underlyingObject = u;
    }

    [DisplayOrder(1)]
    public int SomeInt
    {
        get
        {
            return underlyingObject .SomeInt;
        }
    }

    [DisplayOrder(2)]
    public DateTime SomeDate
    {
        get
        {
            return underlyingObject .SomeDate;
        }
    }
}

Je m'assure ainsi que SomeInt est toujours affiché avant SomeDate lorsque je travaille avec mes composants GUI personnalisés.

Cependant, vous les verrez le plus souvent utilisés en dehors de l'environnement de codage direct. Par exemple, le Concepteur Windows les utilise largement pour savoir comment traiter les objets personnalisés. En utilisant l'attribut BrowsableAttribute comme suit :

[Browsable(false)]
public SomeCustomType DontShowThisInTheDesigner
{
    get{/*do something*/}
}

Indique au concepteur de ne pas l'inscrire dans les propriétés disponibles dans la fenêtre Propriétés au moment de la conception, par exemple.

Vous pourrait Vous pouvez également les utiliser pour la génération de code, les opérations de précompilation (telles que Post-Sharp) ou les opérations d'exécution telles que Reflection.Emit. Par exemple, vous pouvez écrire un bout de code pour le profilage qui enveloppe de manière transparente chaque appel effectué par votre code et le chronomètre. Vous pourriez " refuser " le chronométrage par le biais d'un attribut que vous placez sur des méthodes particulières.

public void SomeProfilingMethod(MethodInfo targetMethod, object target, params object[] args)
{
    bool time = true;
    foreach (Attribute a in target.GetCustomAttributes())
    {
        if (a.GetType() is NoTimingAttribute)
        {
            time = false;
            break;
        }
    }
    if (time)
    {
        StopWatch stopWatch = new StopWatch();
        stopWatch.Start();
        targetMethod.Invoke(target, args);
        stopWatch.Stop();
        HandleTimingOutput(targetMethod, stopWatch.Duration);
    }
    else
    {
        targetMethod.Invoke(target, args);
    }
}

Les déclarer est facile, il suffit de créer une classe qui hérite de Attribute.

public class DisplayOrderAttribute : Attribute
{
    private int order;

    public DisplayOrderAttribute(int order)
    {
        this.order = order;
    }

    public int Order
    {
        get { return order; }
    }
}

Et n'oubliez pas que lorsque vous utilisez l'attribut, vous pouvez omettre le suffixe "attribut", le compilateur l'ajoutera pour vous.

NOTE : Les attributs ne font rien par eux-mêmes - il faut qu'un autre code les utilise. Parfois, ce code a été écrit pour vous, mais parfois vous devez l'écrire vous-même. Par exemple, le compilateur C# se soucie de certains attributs et certains frameworks en utilisent d'autres (par exemple, NUnit recherche [TestFixture] sur une classe et [Test] sur une méthode de test lors du chargement d'un assemblage).
Ainsi, lorsque vous créez votre propre attribut personnalisé, sachez qu'il n'aura aucune incidence sur le comportement de votre code. Vous devrez écrire l'autre partie qui vérifie les attributs (via la réflexion) et agir en conséquence.

Answer 2

De nombreuses personnes ont répondu mais personne n'a mentionné ceci jusqu'à présent...

Les attributs sont fortement utilisés dans le cadre de la réflexion. La réflexion est déjà assez lente.

Il est très utile en marquant vos attributs personnalisés comme étant sealed pour améliorer leurs performances d'exécution.

C'est aussi une bonne idée de considérer où il serait approprié d'utiliser un tel attribut, et d'attribuer votre attribut ( !) pour l'indiquer via AttributeUsage . La liste des utilisations d'attributs disponibles pourrait vous surprendre :

• Montage
• Module
• Classe
• Structure
• Enum
• Constructeur
• Méthode
• Propriété
• Champ
• Événement
• Interface
• Paramètre
• Délégué
• Valeur de retour
• Paramètre générique
• Tous

Il est également intéressant que l'attribut AttributeUsage fasse partie de la signature de l'attribut AttributeUsage. Ouah pour les dépendances circulaires !

[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute

Answer 3

Introduction aux attributs

Programmer en C# : Attributs et réflexion (un excellent article, extrait d'un livre)

Answer 4

Les attributs sont une sorte de métadonnées permettant de baliser les classes. Ils sont souvent utilisés dans WinForms, par exemple pour masquer les contrôles de la barre d'outils, mais peuvent être mis en œuvre dans votre propre application pour permettre aux instances de différentes classes de se comporter de manière spécifique.

Commencez par créer un attribut :

[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=true)]
public class SortOrderAttribute : Attribute
{
    public int SortOrder { get; set; }

    public SortOrderAttribute(int sortOrder)
    {
        this.SortOrder = sortOrder;
    }
}

Toutes les classes d'attributs doivent avoir le suffixe "Attribut" pour être valides.
Une fois que cela est fait, créez une classe qui utilise l'attribut.

[SortOrder(23)]
public class MyClass
{
    public MyClass()
    {
    }
}

Maintenant, vous pouvez vérifier une classe spécifique SortOrderAttribute (s'il en a un) en procédant comme suit :

public class MyInvestigatorClass
{
    public void InvestigateTheAttribute()
    {
        // Get the type object for the class that is using
        // the attribute.
        Type type = typeof(MyClass);

        // Get all custom attributes for the type.
        object[] attributes = type.GetCustomAttributes(
            typeof(SortOrderAttribute), true);

        // Now let's make sure that we got at least one attribute.
        if (attributes != null && attributes.Length > 0)
        {
            // Get the first attribute in the list of custom attributes
            // that is of the type "SortOrderAttribute". This should only
            // be one since we said "AllowMultiple=false".
            SortOrderAttribute attribute = 
                attributes[0] as SortOrderAttribute;

            // Now we can get the sort order for the class "MyClass".
            int sortOrder = attribute.SortOrder;
        }
    }
}

Si vous voulez en savoir plus, vous pouvez toujours consulter le site suivant MSDN qui a une description assez bonne.
J'espère que cela vous a aidé !

Answer 5

Les attributs sont comme des métadonnées appliquées aux classes, méthodes ou assemblages.

Ils sont utiles pour un grand nombre de choses (visualisation du débogueur, marquage des choses comme obsolètes, marquage des choses comme sérialisables, la liste est sans fin).

Il est très facile de créer vos propres modèles personnalisés. Commencez ici :

http://msdn.microsoft.com/en-us/library/sw480ze8(VS.71).aspx