Ce sont des attributs dans .NET?

StackOverflow https://stackoverflow.com/questions/20346

Question

Ce sont des attributs dans .NET, à quoi servent-elles, et comment puis-je créer mes propres attributs?

Était-ce utile?

La solution

Les métadonnées.Les données sur vos objets, méthodes et propriétés.

Par exemple, je pourrais déclarer un Attribut appelé:DisplayOrder donc je peux facilement contrôler dans quel ordre les propriétés doivent apparaître dans l'INTERFACE utilisateur.Alors je pourrais les ajouter à une classe et à écrire certains composants GUI qui extrait les attributs et l'ordre des é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;
        }
    }
}

Ainsi veiller à ce que SomeInt est toujours affichée avant SomeDate lorsque l'on travaille avec mon custom composants GUI.

Cependant, vous les verrez plus couramment utilisée à l'extérieur du codage direct de l'environnement.Par exemple Windows Concepteur utilise de manière intensive, donc il sait comment traiter avec des objects.À l'aide de la BrowsableAttribute comme suit:

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

Raconte le designer pas à cette liste dans les propriétés disponibles dans la fenêtre Propriétés au moment de la conception, par exemple.

Vous pourrait aussi les utiliser pour la génération de code, de pré-compilation des opérations (telles que Post-Sharp) ou de l'exécution des opérations telles que la Réflexion.En émettent.Par exemple, vous pourriez écrire un peu de code pour l'établissement de profils de manière transparente enveloppé chaque appel de votre code fait et parfois il.Vous pourriez "opt-out" de la synchronisation via un attribut que vous placez sur les 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);
    }
}

Déclarant est facile, il suffit de faire une classe qui hérite de l'Attribut. 

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 que vous pouvez omettre le suffixe "attribut", le compilateur va ajouter que pour vous.

NOTE: Les attributs ne font rien par eux - mêmes, il doit être un autre code qui les utilise.Parfois, ce code a été écrit pour vous, mais parfois vous devez écrire vous-même.Par exemple, le compilateur C# se soucie de certaines et de certains cadres de cadres de l'utilisation de certains (par ex.NUnit recherche [TestFixture] sur une classe et [Test] sur une méthode de test lors du chargement d'une assemblée).
Donc, lors de la création de votre propre attribut être conscient qu'il n'aura pas d'impact sur le comportement de votre code.Vous aurez besoin d'écrire de l'autre partie qui vérifie les attributs (par réflexion) et d'agir sur eux.

Autres conseils

Beaucoup de gens ont répondu, mais personne n'a évoqué jusqu'à présent...

Les attributs sont utilisés fortement avec la réflexion.La réflexion est déjà assez lent.

Il est très intéressant marquage personnalisé de votre attributs comme étant sealed des classes 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 pour attribut l'attribut (!) pour l'indiquer via AttributeUsage.La liste de l'attribut usages pourrait vous surprendre:

  • Assemblée
  • Module
  • Classe
  • Struct
  • Enum
  • Constructeur
  • Méthode
  • Propriété
  • Champ
  • L'événement
  • Interface
  • Paramètre
  • Délégué
  • ReturnValue
  • GenericParameter
  • Tous

C'est aussi cool que l'AttributeUsage attribut fait partie de la AttributeUsage attribut de la signature.Whoa pour les dépendances circulaires!

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

Les attributs sont une sorte de méta-données pour le marquage des classes.Ceci est souvent utilisé dans les WinForms par exemple, pour masquer les contrôles de la barre d'outils, mais peut être mis en œuvre dans votre propre application pour permettre à des instances de classes différentes 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 valide.
Après cela, 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 (si 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 lire plus à ce propos, vous pouvez toujours vérifier MSDN qui a une assez bonne description.
J'espère que cela vous a aidé à en sortir!

Un attribut est une classe qui contient un peu de fonctionnalités que vous pouvez appliquer à des objets dans votre code.Pour en créer une, créer une classe qui hérite de System.Attribut.

Comme pour ce qu'ils sont bons pour...il y a presque illimitées utilise pour eux.

http://www.codeproject.com/KB/cs/dotnetattributes.aspx

Les attributs comme des métadonnées appliquée à des classes, des méthodes ou des assemblées.

Ils sont bons pour un certain nombre de choses (débogueur de visualisation, le marquage des choses comme obsolète, le marquage des choses comme sérialisable, la liste est sans fin).

La création de votre propre personnalisé est simple comme bonjour.Commencez ici:

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

Dans le projet que je suis en train de travailler, il y a un ensemble d'objets de l'INTERFACE utilisateur de saveurs différentes et un éditeur pour l'assemblage de ces objets pour créer des pages pour une utilisation dans l'application principale, un peu comme le concepteur de formulaire dans DevStudio.Ces objets existent dans leur propre assemblée et chaque objet est une classe dérivée de UserControl et a un attribut personnalisé.Cet attribut est défini comme ceci:

[AttributeUsage (AttributeTargets::Class)]
public ref class ControlDescriptionAttribute : Attribute
{
public:
  ControlDescriptionAttribute (String ^name, String ^description) :
    _name (name),
    _description (description)
  {
  }

  property String ^Name
  {
    String ^get () { return _name; }
  }

  property String ^Description
  {
    String ^get () { return _description; }
  }

private:
  String
    ^ _name,
    ^ _description;
};

et je l'applique à une classe comme ceci:

[ControlDescription ("Pie Chart", "Displays a pie chart")]
public ref class PieControl sealed : UserControl
{
  // stuff
};

qui est ce que le précédent affiches ont dit.

Utiliser l'attribut, l'éditeur a un Generic::List <Type> contenant les types de contrôle.Il y a une zone de liste à laquelle l'utilisateur peut faire glisser et de déposer sur la page pour créer une instance du contrôle.Pour remplir la zone de liste, j'ai l' ControlDescriptionAttribute pour le contrôle et la remplir d'une entrée dans la liste:

// done for each control type
array <Object ^>
  // get all the custom attributes
  ^attributes = controltype->GetCustomAttributes (true);

Type
  // this is the one we're interested in
  ^attributetype = ECMMainPageDisplay::ControlDescriptionAttribute::typeid;

// iterate over the custom attributes
for each (Object ^attribute in attributes)
{
  if (attributetype->IsInstanceOfType (attribute))
  {
    ECMMainPageDisplay::ControlDescriptionAttribute
      ^description = safe_cast <ECMMainPageDisplay::ControlDescriptionAttribute ^> (attribute);

    // get the name and description and create an entry in the list
    ListViewItem
      ^item = gcnew ListViewItem (description->Name);

    item->Tag = controltype->Name;
    item->SubItems->Add (description->Description);

    mcontrols->Items->Add (item);
    break;
  }
}

Note:le ci-dessus est le C++/CLI, mais il n'est pas difficile à convertir en C# (ouais, je sais, C++/CLI est une abomination, mais c'est ce que j'ai à travailler avec :-( )

Vous pouvez mettre des attributs sur la plupart des choses et il y a toute une gamme d'attributs prédéfinis.L'éditeur mentionné ci-dessus cherche aussi les attributs personnalisés sur des propriétés qui décrivent la propriété et comment le modifier.

Une fois que vous obtenez l'idée, vous vous demanderez comment vous avez pu vivre sans eux.

Comme l'a dit, les Attributs sont relativement faciles à créer.L'autre partie du travail est de créer du code qui l'utilise.Dans la plupart des cas, vous utiliserez la réflexion au moment de l'exécution pour modifier son comportement en fonction de la présence d'un attribut ou d'une de ses propriétés.Il y a aussi des scénarios où vous examinez les attributs sur le code compilé pour faire une sorte d'analyse statique.Par exemple, les paramètres peuvent être indiqués comme non nulle, et l'outil d'analyse peut l'utiliser comme un indice.

En utilisant les attributs et de connaître les scénarios appropriés pour leur utilisation est le gros du travail.

Les attributs sont, essentiellement, les bits de données que vous souhaitez joindre à votre types (les classes, les méthodes, les événements, les énumérations, etc.)

L'idée est que, au moment de l'exécution d'un autre type/cadre/outil de requête votre type de l'information contenue dans l'attribut et d'agir sur elle.

Ainsi, par exemple, Visual Studio, vous pouvez interroger les attributs sur un 3ème contrôle du parti pour lequel les propriétés du contrôle doit apparaître dans le volet des Propriétés au moment de la conception.

Attributs peuvent également être utilisés dans la Programmation Orientée Aspects à injecter/manipuler des objets au moment de l'exécution sur la base des attributs qui les décorer et ajouter la validation, enregistrement, etc.pour les objets sans affecter la logique métier de l'objet.

Vous pouvez utiliser des attributs personnalisés comme un moyen simple de définir les valeurs de balise dans les sous-catégories sans avoir à écrire le même code pour chaque sous-classe.Je suis tombé sur une belle concis exemple de John Waters comment définir et utiliser des attributs personnalisés dans votre propre code.

Il y a un tutoriel sur http://msdn.microsoft.com/en-us/library/aa288454(SV.71).aspx

Pour commencer la création d'un attribut, d'ouvrir un source C# fichier, tapez attribute et appuyer sur [TAB].Il permettra de développer un modèle pour un nouvel attribut.

Les attributs sont également couramment utilisés pour la Programmation Orientée Aspects.Pour un exemple de cette admirez les PostSharp projet.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top