Attributs de propriété C #

Question

J'ai vu le code suivant:

[DefaultValue(100)]
[Description("Some descriptive field here")]
public int MyProperty{...} 

La fonctionnalité de l'extrait ci-dessus semble assez claire, je ne sais pas comment l'utiliser pour faire des choses utiles. Je ne suis même pas sûr de savoir quel nom lui donner!

Est-ce que quelqu'un sait où je peux trouver plus d'informations / un tutoriel sur ces attributs de propriété? Je serais également intéressé par toute tâche nouvelle / utile que cette fonctionnalité peut accomplir.

Answer 1

Les utilisateurs ont déjà abordé l'aspect interface utilisateur (les attributs ont d'autres utilisations, bien que ... par exemple, ils sont largement utilisés dans la plupart des frameworks de sérialisation. Le compilateur accorde un traitement spécial à certains attributs. Par exemple, [PrincipalPermission (...)] ajoute une sécurité déclarative à une méthode, ce qui vous permet de vérifier (automatiquement) que l'utilisateur dispose d'un accès approprié.

Pour ajouter votre propre traitement spécial, vous pouvez utiliser PostSharp ; Il existe de nombreux excellents exemples d'utilisation de PostSharp pour des tâches AOP, telles que la journalisation - ou simplement la simplification de code, comme avec implémentation automatique de INotifyPropertyChanged .

Answer 2

  

La fonctionnalité de ce qui précède   extrait semble assez clair,

Peut-être pas, car beaucoup de gens pensent que [DefaultValue ()] définit la valeur de la propriété. En fait, tout ce qu'il fait pour indiquer à un concepteur visuel (Visual Studio, par exemple), en quoi le code va définir la valeur par défaut. De cette manière, gras il connaît la valeur dans la fenêtre de propriétés s'il est défini sur autre chose.

Answer 3

Ceux de votre exemple sont utilisés par le concepteur visuel (c'est-à-dire MS Expression Blend et le concepteur Visual Studio) pour donner des conseils dans l'interface utilisateur du concepteur.

Notez qu’il s’agit de métadonnées et qu’elles n’affecteront pas la logique de la propriété. La définition de DefaultValue par exemple ne définira pas la propriété sur cette valeur par défaut, vous devez le faire manuellement.

Si, pour une raison quelconque, vous souhaitez accéder à ces attributs, vous devez utiliser réflexion .

Voir MSDN pour plus d'informations sur les attributs du concepteur.

Answer 4

Ils s'appellent Attributs. Il y a beaucoup d’informations dans msdn, par exemple. http://msdn.microsoft.com/en-us/library/z0w1kczw.aspx

En général, ils ne le font pas. quoi que ce soit par eux-mêmes, ils sont utilisés par un autre code qui utilisera votre classe. XmlSerializer est un bon exemple: XmlSerializer (fourni par Microsoft dans le cadre du cadre) peut être utilisé par presque toutes les classes (il existe cependant un certain nombre d'exigences relatives à la classe). Il utilise la réflexion pour voir quelles données sont contenues dans la classe. Vous pouvez utiliser des attributs (définis avec XmlSerializer) pour modifier la façon dont XmlSerializer sérialisera votre classe (par exemple, indiquez-lui de sauvegarder les données en tant qu'attribut au lieu d'un élément).

Answer 5

Nous l'utilisons pour définir le concepteur graphique à charger pour le configurer une instance d'un type spécifique.

C'est-à-dire que nous avons une sorte de concepteur de workflow qui charge toutes les commandes possibles types d'un assemblage. Ces types de commandes ont des propriétés qui doivent être configurées, donc chaque type de commande a besoin d'un concepteur différent (usercontrol).

Par exemple, considérons le type de commande suivant (appelé composite dans notre solution)

[CompositeMetaData("Delay","Sets the delay between commands",1)]
[CompositeDesigner(typeof(DelayCompositeDesigner))]
public class DelayComposite : CompositeBase 
{
       // code here
}

Ces informations sont utilisées à deux endroits

1) Lorsque le concepteur crée une liste de commandes, il utilise le composant CompositeMetaData.    pour afficher plus d'informations sur la commande.

2) Lorsque l'utilisateur ajoute une commande au concepteur et que celui-ci crée    une instance de cette classe, il examine la propriété CompositeDesigner,    crée une nouvelle instance du type spécifié (usercontrol) et l'ajoute    au concepteur visuel.

Considérez le code suivant, nous utilisons pour charger les commandes dans notre "barre d'outils":

foreach (Type t in assembly.GetExportedTypes())  
{
    Console.WriteLine(t.Name);

    if (t.Name.EndsWith("Composite"))
    {
        var attributes = t.GetCustomAttributes(false);
        ToolboxListItem item = new ToolboxListItem();

        CompositeMetaDataAttribute meta = (CompositeMetaDataAttribute)attributes
                              .Where(a => a.GetType() == typeof(Vialis.LightLink.Attributes.CompositeMetaDataAttribute)).First();
        item.Name = meta.DisplayName;
        item.Description = meta.Description;
        item.Length = meta.Length;
        item.CompositType = t;

        this.lstCommands.Items.Add(item);
    }                           
}

Comme vous pouvez le constater, pour chaque type de l'assemblage dont le nom se termine par "Composite", nous obtenons les attributs personnalisés et utilisons ces informations pour renseigner notre instance ToolboxListItem.

En ce qui concerne le concepteur, l'attribut est récupéré comme suit:

var designerAttribute = (CompositeDesignerAttribute)item.CompositType.GetCustomAttributes(false)
                         .Where(a => a.GetType() == typeof(CompositeDesignerAttribute)).FirstOrDefault();

Ceci n'est qu'un exemple de la manière dont vous pourriez utiliser des attributs personnalisés,

J'espère que cela vous donne un endroit où commencer.

Answer 6

Ces attributs personnalisent l'expérience de conception.

http://msdn.microsoft.com/en-us/library /a19191fh.aspx