Atributos e suporte em tempo de Design

Artigo
08/01/2011

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

Atributos para associar o suporte de tempo de Design

A DesignerAttribute associa um designer com 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 um valor definido pelo código de inicialização do componente em tempo de design, mas o atributo não substitui um valor definido pelo 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 para o proprietário. 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 a propriedade ou evento. Você pode especificar uma descrição a ser exibido para uma propriedade ou evento no Propriedades janela aplicando um DescriptionAttribute a propriedade ou evento.

Você pode especificar se uma propriedade pode ser definida apenas em tempo de design, aplicando um DesignOnlyAttribute para a propriedade. Você pode especificar se uma propriedade somente leitura ou leitura/gravação em tempo de design, aplicando um ReadOnlyAttribute para a 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 deve disparar a notificação.

Você pode especificar se as propriedades de um componente devem ser atualizadas, sem propriedades devem ser atualizadas ou 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 para a propriedade. Não há suporte extensivo para essa tarefa em Visual Studio. Para obter mais informações, consulte Demonstra Passo a passo: A serialização coleções de tipos padrão com o DesignerSerializationVisibilityAttribute e Demonstra Passo a passo: A serialização coleções de tipos padrão com o DesignerSerializationVisibilityAttribute e Demonstra Passo a passo: A serialização coleções de tipos padrão com o DesignerSerializationVisibilityAttribute e Demonstra Passo a passo: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute e 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 Serialization.

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 namespace contém muitas classes de atributo base.

Atributos de tempo de design e herança

Quando você derivar um componente ou controle de um componente base que tem os atributos de tempo de design, o componente herda a funcionalidade de tempo de design da classe base. Se a funcionalidade de base é adequada para seus propósitos, não é necessário 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 a 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 {...}
...
}

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, aplica 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 aplicado 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 seguinte exemplo de código.

<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, conforme mostrado no seguinte exemplo de código.

<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 da classe, conforme mostrado no seguinte exemplo de código.

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

Observação
Nos exemplos acima, os construtores para o TypeConverterAttribute,EditorAttribute, e DesignerAttribute classes aceitam System.Type objetos como seus argumentos. Essa forma de construtor para esses atributos funciona se o tipo for no mesmo assembly como as classes de tempo de design. Se as classes de tempo de design em um assembly diferente, em seguida, um formulário diferente do construtor de atributo (chamado o formato qualificado de assembly) é necessária, conforme mostrado no exemplo de código a seguir.

Nos exemplos acima, os construtores para o TypeConverterAttribute,EditorAttribute, e DesignerAttribute classes aceitam System.Type objetos como seus argumentos. Essa forma de construtor para esses atributos funciona se o tipo for no mesmo assembly como as classes de tempo de design. Se as classes de tempo de design em um assembly diferente, em seguida, um formulário diferente do construtor de atributo (chamado o formato qualificado de assembly) é necessária, conforme mostrado no exemplo de código a seguir.

<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 (System.Web.UI.TagPrefixAttribute) que permite que um desenvolvedor de controle especificar um prefixo de marca para um aplicativo ASP.Controle NET. 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 / > ).

Observação
O TagPrefixAttribute funciona somente no visual designers. Se você criar aplicativos ASP.NET pages usando um editor de texto como o bloco de notas, você precisa especificar o prefixo da marca e o namespace sozinho na Register a diretiva para o controle.

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 de 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

Compartilhar via