Attributs et prise en charge au moment du design

Article
05/17/2015

Les extensions de prise en charge au moment du design sont généralement implémentées dans le code séparé de celui d'un composant. Divers attributs sont utilisés pour associer des fournisseurs de prise en charge au moment du design à un type ou un membre individuel d'un type.

Attributs destinés à associer la prise en charge au moment du design

DesignerAttribute associe un concepteur à un type. TypeConverterAttribute associe un type de convertisseur à un type ou un membre de type. EditorAttribute associe un éditeur de types muni d'une interface utilisateur à un type ou un membre de type.

Attributs destinés à personnaliser l'initialisation d'un composant

Vous pouvez spécifier une valeur par défaut pour qu'une propriété soit définie lorsqu'un composant est chargé au moment du design en appliquant DefaultValueAttribute à une propriété. DefaultValueAttribute substitue une valeur définie par du code d'initialisation de composant au moment du design, mais ne substitue pas une valeur définie par un concepteur.

Attributs destinés à personnaliser le comportement d'une fenêtre Propriétés

Vous pouvez indiquer si une propriété ou un événement doit être répertorié dans une fenêtre Propriétés en lui appliquant un BrowsableAttribute. Vous pouvez également modifier l'ensemble des propriétés et des événements exposés à la fenêtre Propriétés au moment du design à l'aide d'un concepteur qui implémente l'interface IDesignerFilter. Vous pouvez spécifier la catégorie sous laquelle une propriété ou un événement doit être répertorié dans la fenêtre Propriétés en lui appliquant CategoryAttribute. Vous pouvez spécifier une description à afficher pour une propriété ou un événement dans la fenêtre Propriétés en lui appliquant DescriptionAttribute.

Vous pouvez spécifier si une propriété ne peut être définie qu'au moment du design en lui appliquant DesignOnlyAttribute. Vous pouvez spécifier si une propriété est en lecture seule ou en lecture/écriture au moment du design en lui appliquant ReadOnlyAttribute.

Vous pouvez spécifier si une propriété doit être répertoriée avec son nom entre parenthèses dans la fenêtre Propriétés en lui appliquant ParenthesizePropertyNameAttribute avec la valeur true.

Vous pouvez spécifier si une propriété qui possède des propriétés imbriquées ou enfants doit recevoir une notification lorsque la valeur d'une propriété imbriquée change en appliquant NotifyParentPropertyAttribute à la propriété imbriquée qui doit déclencher la notification.

Vous pouvez spécifier si les propriétés d'un composant doivent être actualisées, si aucune propriété ne doit être actualisée ou si la vue du concepteur doit être repeinte en appliquant, à une propriété ou un événement, RefreshPropertiesAttribute avec une valeur RefreshProperties appropriée.

Attributs destinés à personnaliser le comportement de sérialisation au moment du design

Vous pouvez spécifier si les valeurs d'une propriété ou d'une propriété de collection sont sérialisées en appliquant DesignerSerializationVisibilityAttribute avec une valeur d'énumération DesignerSerializationVisibility appropriée à la propriété. Il existe une prise en charge étendue pour cette tâche dans Visual Studio. Procédure pas à pas : sérialisation des collections de types standard avec DesignerSerializationVisibilityAttribute
Procédure pas à pas : sérialisation des collections de types standard avec DesignerSerializationVisibilityAttribute
Procédure pas à pas : sérialisation des collections de types standard avec DesignerSerializationVisibilityAttribute
Procédure pas à pas : sérialisation des collections de types standard avec DesignerSerializationVisibilityAttribute

Vous pouvez indiquer qu'un type est sérialisable en lui appliquant SerializableAttribute. Vous pouvez fournir une sérialisation personnalisée en implémentant l'interface ISerializable ou en fournissant un sérialiseur personnalisé. Pour plus d'informations sur la sérialisation, consultez Sérialisation dans le .NET Framework.

Pour plus d'informations sur les attributs fréquemment utilisés au moment du design, consultez Attributs en mode design pour les composants.

Application des attributs

Les attributs de design sont appliqués à des propriétés, à des événements, à des classes et même à des assemblys. L'exemple de code suivant illustre les attributs qui s'appliquent à une classe puis à des propriétés ainsi qu'à des événements.

' The attribute is the element in angle brackets, and the parameters 
' in the attribute syntax are arguments of the constructor 
' of the attribute class.
' 
' Attributes applied at the class level.
<DefaultEvent("ValueChanged"), _
DefaultProperty("Number")> _
Public Class MyControl
   Inherits Control   
   ...
   ' Attribute applied to a property.
   <DefaultValue(False)> _
   Public Shadows ReadOnly Property TabStop() As Boolean
      ...
   End Property
   
   ' Attribute applied to a property.
   <CategoryAttribute("Data")> _
   Public ReadOnly Property Number() As Integer
      ...
   End Property 
   
   ' Attribute applied to an event.
   <Description("Raised when the Value displayed changes.")>  _
   Public Event ValueChanged As EventHandler
   ...
End Class

// The attribute is the element in brackets, and the parameters in 
// the attribute syntax are arguments of the constructor 
// of the attribute class.
// 
// Attributes applied at the class level.
[DefaultEvent("ValueChanged")]
[DefaultProperty("Number")]
public class MyControl : Control {
   ...
   // Attribute applied to a property.
   [DefaultValue(false)]
   public new bool TabStop {...
   }

   // Attribute applied to a property.
   [CategoryAttribute("Data")]
   public int Number {...}

   // Attribute applied to an event.
   [Description("Raised when the Value displayed changes.")]
   public event EventHandler ValueChanged;
}

Par convention, les classes d'attributs sont appelées NomAttributAttribute. L'espace de noms System.ComponentModel contient de nombreuses classes d'attributs de base.

Attributs de design et héritage

Lorsque vous dérivez un composant ou un contrôle d'un composant de base qui possède des attributs de design, votre composant hérite des fonctionnalités de design de la classe de base. Si les fonctionnalités de base sont adaptées à vos besoins, vous ne devez pas réappliquer les attributs. Cependant, vous pouvez toujours substituer des attributs du même type ou appliquer des attributs supplémentaires au composant dérivé. Le fragment de code suivant montre un contrôle personnalisé qui substitue la propriété Text héritée de Control en substituant l'attribut BrowsableAttribute appliqué dans la classe de base.

Public Class MyControl
   Inherits Control
   ' The base class has [Browsable(true)] applied to the Text property.
   <Browsable(False)>  _
   Public Overrides Property [Text]() As String
      ...
   End Property 
   ...
End Class

public class MyControl : Control {
// The base class has [Browsable(true)] applied to the Text property.
[Browsable(false)]
 public override string Text {...}
...
}

Application d'un attribut de convertisseur de type, d'éditeur de types muni d'une interface utilisateur, ou de concepteur

Pour associer un fournisseur de prise en charge au moment du design à un type ou un membre de type, appliquez le type d'attribut approprié sur la ligne située au-dessus de la déclaration de classe ou de la déclaration de membre. L'exemple de code suivant illustre un TypeConverterAttribute appliqué à un type.

<TypeConverter(GetType(MyColorConverter)), _
Editor(GetType(MyColorEditor), GetType(UITypeEditor))> _
Structure MyColor
   ...
End Structure

[ TypeConverter(typeof(MyColorConverter))]
[ Editor(typeof(MyColorEditor), typeof(UITypeEditor))] 
struct MyColor {...}

Si aucun convertisseur de type ou éditeur de types muni d'une interface utilisateur n'est associé au type d'une propriété, ou encore si vous souhaitez substituer le convertisseur de type ou l'éditeur de types muni d'une interface utilisateur par défaut associé au type d'une propriété, vous pouvez appliquer un attribut à la propriété proprement dite. Pour associer un convertisseur de type à une propriété, appliquez TypeConverterAttribute à la déclaration de propriété, comme le montre l'exemple de code suivant :

<TypeConverter(GetType(PointConverter))> _
Public Property MyLocation() As Point
   ...
End Property

[ TypeConverter(typeof(PointConverter))]
        public Point MyLocation {...}

Pour associer un éditeur de types muni d'une interface utilisateur à une propriété, appliquez EditorAttribute à la propriété, comme le montre l'exemple de code suivant :

<Editor(GetType(FlashTrackBarDarkenByEditor), _
GetType(UITypeEditor))>  _
Public Property DarkenBy() As Byte
   ...
End Property

[ Editor(typeof(FlashTrackBarDarkenByEditor), typeof(UITypeEditor))]
        public byte DarkenBy {...}

Un concepteur peut être associé à un type mais pas à une propriété. Pour associer un concepteur à un type, appliquez DesignerAttribute directement au-dessus de la déclaration de classe, comme le montre l'exemple de code suivant :

<Designer(GetType(HelpLabel.HelpLabelDesigner))> _
Public Class HelpLabel
   Inherits System.Windows.Forms.Control
   Implements System.ComponentModel.IExtenderProvider
   ...
End Class

    [Designer(typeof(HelpLabel.HelpLabelDesigner))]
    public class HelpLabel : System.Windows.Forms.Control, System.ComponentModel.IExtenderProvider {...}

Notes

Dans les exemples ci-dessus, les constructeurs pour les classes TypeConverterAttribute, EditorAttribute et DesignerAttribute acceptent les objets Type comme arguments.Cette forme de constructeur pour ces attributs fonctionne si le type est dans le même assembly que les classes de design.Si les classes de design sont dans un autre assembly, une autre forme du constructeur d'attribut (appelée format qualifié par un assembly) est nécessaire, comme le montre l'exemple de code suivant :

<Designer("System.Windows.Forms.Design.DocumentDesigner, System.Design")>  _
Public Class MyForm
   Inherits Form
   ...
End Class

[Designer("System.Windows.Forms.Design.DocumentDesigner, System.Design")]
public class MyForm : Form {...}

Attribut de design au niveau de l'assembly

ASP.NET fournit un attribut au niveau de l'assembly (TagPrefixAttribute) qui permet à un développeur de contrôles de spécifier un préfixe de balise pour un contrôle ASP.NET. Le préfixe de balise est automatiquement injecté par Visual Studio dans la directive Register du contrôle, de sorte que ce dernier peut être utilisé par déclaration sur la page avec le préfixe de balise spécifié précédemment (<PréfixeBalise:NomContrôle runat = server />).

Notes

TagPrefixAttribute fonctionne uniquement dans les concepteurs visuels.Si vous créez des pages ASP.NET à l'aide d'un éditeur de texte tel que le Bloc-notes, vous devez spécifier vous-même le préfixe de balise et l'espace de noms dans la directive Register du contrôle.

L'exemple de code suivant montre comment appliquer TagPrefixAttribute. Le premier argument du constructeur de l'attribut spécifie l'espace de noms et le deuxième, le préfixe de balise.

<assembly: TagPrefix("SimpleControls", "simple")>
Namespace SimpleControls
   <Designer("SimpleControl.Design.SimpleDesigner, SimpleControl")>  _
   Public Class SimpleControl
      Inherits System.Web.UI.WebControls.WebControl
      ...
   End Class 
End Namespace

[ assembly:TagPrefix("SimpleControls", "simple") ]
namespace SimpleControls {
    [
        Designer("SimpleControl.Design.SimpleDesigner, SimpleControl")
    ]
    public class SimpleControl : System.Web.UI.WebControls.WebControl {}
}

Voir aussi

Partager via