Attributi e supporto in fase di progettazione

Le estensioni del supporto per la fase di progettazione sono normalmente implementate in codice separato dal codice per un componente. Vengono utilizzati vari attributi per l'associazione di provider di supporto della fase di progettazione con un tipo o con il membro specifico di un tipo.

Attributi per l'associazione del supporto della fase di progettazione

Un attributo DesignerAttribute consente di associare una finestra di progettazione a un tipo. Un attributo TypeConverterAttribute consente di associare un convertitore di tipi a un tipo o a un membro del tipo. Un attributo EditorAttribute consente di associare un editor di tipi con interfaccia utente a un tipo o a un membro del tipo.

Attributi per la personalizzazione dell'inizializzazione di componenti

È possibile specificare che il valore predefinito per una proprietà venga impostato al caricamento di un componente in fase di progettazione applicando un attributo DefaultValueAttribute a una proprietà. Un attributo DefaultValueAttribute esegue l'override di un valore impostato dal codice di inizializzazione di un componente in fase di progettazione, ma non esegue l'override di un valore impostato da una finestra di progettazione.

Attributi per la personalizzazione del comportamento della finestra Proprietà

È possibile indicare se una proprietà o un evento deve essere elencato in una finestra Proprietà applicandovi un attributo BrowsableAttribute. È inoltre possibile modificare l'insieme di proprietà ed eventi esposti alla finestra Proprietà in fase di progettazione, utilizzando una finestra di progettazione che implementi l'interfaccia IDesignerFilter. È possibile specificare la categoria sotto la quale una proprietà o un evento deve essere elencato nella finestra Proprietà applicando un attributo CategoryAttribute alla proprietà o all'evento. È possibile specificare una descrizione che verrà visualizzata per una proprietà o un evento nella finestra Proprietà applicando un attributo DescriptionAttribute alla proprietà o all'evento.

È possibile specificare se una proprietà può essere impostata solo in fase di progettazione applicando un attributo DesignOnlyAttribute alla proprietà stessa. È possibile specificare se una proprietà è di sola lettura o di lettura e scrittura in fase di progettazione, applicando un attributo ReadOnlyAttribute alla proprietà stessa.

È possibile specificare se una proprietà deve essere elencata con il nome tra parentesi nella finestra Proprietà applicando un attributo ParenthesizePropertyNameAttribute alla proprietà con il valore true.

È possibile specificare se una proprietà che presenta proprietà figlio o annidate deve essere notificata quando il valore di una proprietà annidata viene modificato, applicando un attributo NotifyParentPropertyAttribute alla proprietà annidata che deve generare la notifica.

È possibile specificare se le proprietà di un componente devono essere aggiornate, se nessuna proprietà deve essere aggiornata o se la finestra di progettazione deve essere ridisegnata, applicando un attributo RefreshPropertiesAttribute con un valore RefreshProperties appropriato alla proprietà o all'evento.

Attributi per la personalizzazione del comportamento di serializzazione in fase di progettazione

È possibile specificare se i valori di una proprietà, o della proprietà di una raccolta, vengono serializzati applicando un attributo DesignerSerializationVisibilityAttribute con un valore di enumerazione DesignerSerializationVisibility appropriato alla proprietà. In Visual Studio è disponibile un supporto completo per questa attività. Per ulteriori informazioni, vedere Procedura dettagliata: serializzazione di insiemi di tipi standard tramite DesignerSerializationVisibilityAttribute e Procedura dettagliata: serializzazione di insiemi di tipi standard tramite DesignerSerializationVisibilityAttribute e Procedura dettagliata: serializzazione di insiemi di tipi standard tramite DesignerSerializationVisibilityAttribute e Procedura dettagliata: serializzazione di insiemi di tipi standard tramite DesignerSerializationVisibilityAttribute.

È possibile specificare che un tipo è serializzabile applicando un attributo SerializableAttribute al tipo stesso. È possibile fornire la serializzazione personalizzata implementando l'interfaccia ISerializable oppure fornendo un serializzatore personalizzato. Per ulteriori informazioni sulla serializzazione, vedere Serialization.

Per ulteriori informazioni sugli attributi di progettazione di uso comune, vedere Attributi per componenti in fase di progettazione.

Applicazione di attributi

Gli attributi in fase di progettazione vengono applicati a proprietà, eventi, classi e persino ad assembly. Nell'esempio di codice che segue vengono mostrati gli attributi applicati a una classe, quindi a proprietà ed eventi.

' 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;
}

Per convenzione le classi di attributi vengono denominate NomeAttributoAttribute. Lo spazio dei nomi System.ComponentModel contiene molte classi Attribute di base.

Attributi in fase di progettazione ed ereditarietà

Quando si deriva un componente o un controllo da un componente di base che presenta attributi in fase di progettazione, il componente eredita le funzionalità in fase di progettazione della classe base. Se le funzionalità di base rispondono alle proprie esigenze, non sarà necessario applicare nuovamente gli attributi. È tuttavia possibile eseguire l'override di attributi dello stesso tipo oppure applicare attributi aggiuntivi al componente derivato. Nel frammento di codice seguente viene illustrato un controllo personalizzato che esegue l'override della proprietà Text ereditata da Control mediante l'override dell'attributo BrowsableAttribute applicato nella classe di 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 {...}
...
}

Applicazione di un attributo convertitore di tipi, editor di tipi con interfaccia utente o finestra di progettazione

Per associare un provider di supporto della fase di progettazione a un tipo o a un membro di tipo, applicare il tipo di attributo appropriato nella riga che precede quella di dichiarazione della classe o del membro. Nell'esempio di codice seguente viene illustrato un attributo TypeConverterAttribute applicato a un tipo.

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

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

Se il tipo di proprietà non dispone di convertitore di tipi o di editor di tipi con interfaccia utente associato, oppure se si desidera eseguire l'override del convertitore di tipi predefinito o dell'editor di tipi con interfaccia utente associato al tipo di una proprietà, è possibile applicare un attributo alla proprietà stessa. Per associare un convertitore di tipi a una proprietà, applicare un attributo TypeConverterAttribute alla dichiarazione di proprietà, come mostrato nell'esempio di codice seguente.

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

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

Per associare un editor di tipi con interfaccia utente a una proprietà, applicare un attributo EditorAttribute alla proprietà, come mostrato nell'esempio di codice seguente.

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

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

Una finestra di progettazione può essere associata a un tipo, ma non a una proprietà. Per associare una finestra di progettazione a un tipo, applicare un attributo DesignerAttribute subito prima della dichiarazione di classe, come mostrato nell'esempio di codice seguente.

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

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

Attributo in fase di progettazione a livello di assembly

In ASP.NET è disponibile un attributo a livello di assembly (System.Web.UI.TagPrefixAttribute) che consente agli sviluppatori del controllo di specificare prefissi del tag per i controlli ASP.NET. Il prefisso di tag viene inserito automaticamente da Visual Studio .NET nella direttiva Register del controllo, in modo che il controllo stesso possa essere utilizzato in modo dichiarativo nella pagina con il prefisso di tag precedentemente specificato (<prefissotag:nomecontrollo runat = server /> ).

Nell'esempio di codice riportato di seguito viene illustrato come applicare l'oggetto TagPrefixAttribute. Il primo argomento fornito al costruttore dell'attributo specifica lo spazio dei nomi mentre il secondo specifica il prefisso del tag.

<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 {}
}

Vedere anche

Attività

Procedura: implementare un convertitore di tipi

Procedura: implementare un editor di tipi con interfaccia utente

Procedura: applicare attributi nei controlli Windows Form

Concetti

Attributi nei controlli Windows Form

Attributi per componenti in fase di progettazione

Altre risorse

Estensione del supporto in fase di progettazione

Finestre di progettazione personalizzate