Atributos e suporte para tempo de design

Extensões de suporte em tempo de design são geralmente implementadas em código que existe separadamente do código para um componente. Vários atributos são usados para associar a fornecedores de suporte de tempo de design um tipo ou um membro individual de um tipo.

Atributos para a associação de suporte em tempo de Design

A DesignerAttribute associa um designer de um tipo. A TypeConverterAttribute associa um conversor de tipo com um tipo ou membro de tipo. Um EditorAttribute associa um editor UI de tipo com um tipo ou membro de tipo.

Atributos para personalizar a inicialização de componente

Você pode especificar um valor padrão para uma propriedade a ser definida quando um componente é carregado no tempo de design, aplicando um DefaultValueAttribute a uma propriedade. A DefaultValueAttribute substituições um valor definido pelo código de inicialização do componente em tempo de design, mas o atributo não substitui um valor definido por um designer.

Atributos para personalizar o comportamento de janela de propriedades

Você pode indicar se uma propriedade ou evento deve constar em um Propriedades janela aplicando um BrowsableAttribute a ele. Você também pode modificar o conjunto de propriedades e eventos expostos para o Propriedades janela em tempo de design usando um designer que implementa o IDesignerFilter interface. Você pode especificar a categoria na qual uma propriedade ou evento deve ser listado na Propriedades janela aplicando um CategoryAttribute para a propriedade ou evento. Você pode especificar uma descrição a ser exibido para uma propriedade ou evento no Propriedades janela aplicando um DescriptionAttribute para a propriedade ou evento.

Você pode especificar se uma propriedade pode ser definida apenas em tempo de design, aplicando um DesignOnlyAttribute à propriedade. Você pode especificar se uma propriedade somente leitura ou leitura/gravação em tempo de design, aplicando um ReadOnlyAttribute à propriedade.

Você pode especificar se uma propriedade deve ser listada com seu nome entre parênteses na Propriedades janela aplicando um ParenthesizePropertyNameAttribute para a propriedade com um valor de true.

Você pode especificar se uma propriedade que tem aninhadas ou filho, as propriedades devem ser notificadas quando o valor de uma propriedade aninhado é alterado, aplicando um NotifyParentPropertyAttribute para a propriedade aninhada que deverá aumentar a notificação.

Você pode especificar se as propriedades de um componente devem ser atualizadas, sem propriedades devem ser atualizadas ou o modo de exibição designer deve ser redesenhado, aplicando um RefreshPropertiesAttribute com um número apropriado RefreshProperties valor a uma propriedade ou evento.

Atributos para personalizar o comportamento de serialização de tempo de Design

Você pode especificar se os valores de uma propriedade são serializados, ou se os valores de uma propriedade de coleção são serializados, aplicando um DesignerSerializationVisibilityAttribute com um número apropriado DesignerSerializationVisibility o valor de enumeração à propriedade. Não há suporte extensivo para essa tarefa em Visual Studio. Demonstra Passo a passo: A serialização coleções de tipos padrão com o DesignerSerializationVisibilityAttribute
Demonstra Passo a passo: A serialização coleções de tipos padrão com o DesignerSerializationVisibilityAttribute
Demonstra Passo a passo: A serialização coleções de tipos padrão com o DesignerSerializationVisibilityAttribute
Demonstra Passo a passo: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute
Demonstra Passo a passo: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute

Você pode especificar um tipo é serializável, aplicando um SerializableAttribute para o tipo. Você pode fornecer a serialização personalizada, Implementando o ISerializable interface ou fornecendo um serializador personalizado. Para obter mais informações sobre serialização, consulte Serialização no .NET Framework.

Para obter mais informações sobre atributos de tempo de design mais usados, consulte Atributos de tempo de design para componentes.

Aplicando atributos

Atributos de tempo de design são aplicados para propriedades, eventos, classes e até mesmo a assemblies. O exemplo de código a seguir mostra os atributos aplicados a uma classe e, em seguida, propriedades e eventos.

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

Por convenção, as classes de atributo são nomeados AttributeNameatributo. O System.ComponentModel espaço para nome contém muitas classes de atributo base.

Atributos de tempo de design e herança

Quando você deriva um componente ou controle de um componente base que tem os atributos de tempo de design, o seu componente herda a funcionalidade de tempo de design da classe base. Se a funcionalidade básica seja adequada aos seus objetivos, você não precisará reaplicar os atributos. No entanto, você pode substituir os atributos do mesmo tipo ou aplicar atributos adicionais ao componente derivado. O fragmento de código a seguir mostra um controle personalizado que substitui o Text propriedade herdada de Control , substituindo o BrowsableAttribute atributo aplicado na classe 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 {...}
...
}

A aplicação de um conversor de tipo Editor UI de tipo ou o criador de atributo

Para associar um provedor de suporte em tempo de design um tipo ou membro de tipo, aplique o tipo apropriado de atributo na linha acima da declaração de classe ou a declaração de membro. O seguinte código exemplo mostra um TypeConverterAttribute aplicados a um tipo.

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

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

Se o tipo de uma propriedade não tiver um conversor de tipo ou um editor UI de tipo associado a ele, ou se você deseja substituir o conversor de tipo padrão ou um editor UI de tipo associado ao tipo de uma propriedade, você pode aplicar um atributo para a própria propriedade. Para associar um conversor de tipo de uma propriedade, aplicar uma TypeConverterAttribute para a declaração de propriedade, conforme mostrado no exemplo de código a seguir.

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

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

Para associar um editor UI de tipo de uma propriedade, aplicar uma EditorAttribute para a propriedade, como mostrado no exemplo de código a seguir.

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

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

Um designer pode ser associado um tipo, mas não uma propriedade. Para associar um designer de um tipo, aplique um DesignerAttribute diretamente acima da declaração de classe, conforme mostrado no exemplo de código a seguir.

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

Atributo de tempo de Design do nível de assembly

ASP.NET fornece um atributo de nível de assembly (TagPrefixAttribute) que permite que um desenvolvedor de controle especificar um prefixo de marca para um aplicativo ASP.Controle de rede. O prefixo de marca é injetado automaticamente pela Visual Studio na Register diretiva para o controle, para que o controle pode ser usado declarativamente na página com o prefixo da marca predeterminada (<tagprefix:nomedocontrole runat = server / > ).

O exemplo de código a seguir mostra como aplicar o TagPrefixAttribute. O primeiro argumento para construtor o atributo do Especifica o namespace e o segundo Especifica o prefixo da marca.

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

Consulte também

Tarefas

Como implementar um conversor de tipos

Como implementar um editor de tipos da interface do usuário

Como aplicar atributos em controles dos Windows Forms

Conceitos

Atributos em controles dos Windows Forms

Atributos de tempo de design para componentes

Outros recursos

Estendendo o suporte para tempo de design

Designers personalizados