Atributos e em time de design

Artigo
08/25/2010

Extensões do suporte em time 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 fornecedores de suporte de time de design com um tipo ou um membro individual de um tipo.

Atributos para associar o suporte ao time de design

A DesignerAttribute associa um designer de um tipo. A TypeConverterAttribute associa um conversor de tipos com um tipo ou membro de tipo. An EditorAttribute associa um editor de tipos de interface do usuário com um tipo ou membro de tipo.

Atributos para personalizar componentes de inicialização

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

Atributos para personalizar o comportamento de janelas Propriedades

Você pode indicar se uma propriedade ou evento deve estar listado em um Propriedades janela aplicando um BrowsableAttribute a ele. Você também pode modificar o conjunto de propriedades e eventos expostos à Propriedades janela no time de design usando um designer que implementa o IDesignerFilter interface. Você pode especificar a categoria em que uma propriedade ou evento deve estar listado no 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 somente no time de design aplicando um DesignOnlyAttribute a propriedade. Você pode especificar se uma propriedade é somente leitura ou de leitura/gravar em time de design, aplicando um ReadOnlyAttribute a propriedade.

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

Você pode especificar se uma propriedade que tem aninhados ou filho, propriedades serão notificadas quando o valor de uma propriedade aninhada é 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, não há propriedades devem ser atualizadas ou a exibição de design deve ser redesenhada, aplicando um RefreshPropertiesAttribute com um apropriado RefreshProperties valor a uma propriedade ou evento.

Atributos para personalizar o comportamento de serialização de time 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 apropriado DesignerSerializationVisibility valor de enumeração à propriedade. Há suporte extensivo para esta tarefa no Visual Studio.

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

Para obter mais informações sobre atributos de time de design usados com freqüência, consulte Atributos de tempo de design para componentes.

Aplicando atributos

Atributos de time de design são aplicados para propriedades, eventos, classes e até mesmo para módulos (assemblies).O exemplo de código a seguir mostra os atributos aplicados para uma classe e, em seguida, para 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, classes de atributo são nomeados AttributeNameO atributo.The System.ComponentModel espaço para nome contém muitas classes de atributo base.

Atributos de time de design e herança

Quando você derivar um componente ou controle de um componente base que tem atributos de time de design, o componente herda a funcionalidade de time de criação da classe base.Se a funcionalidade básica é adequada para suas finalidades, não é necessário reaplicar os atributos.No entanto, pode substituir 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 {...}
...
}

Aplicar um conversor de tipo, UI tipo Editor ou Designer atributo

Para associar um tipo ou membro de tipo, um provedor de suporte em time de design aplicar o tipo apropriado de atributo na linha acima da declaração de classe ou declaração de membro.O exemplo de código a seguir 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 tem um tipo de conversor ou editor de tipos de interface do usuário associado a ele ou se você deseja substituir o conversor de tipo padrão ou o editor de tipos de interface do usuário associado ao tipo de uma propriedade, você pode aplicar um atributo a própria propriedade.Para associar um conversor de tipo de propriedade, aplicar um TypeConverterAttribute para a declaração de propriedade, sistema autônomo neste 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 de tipos de interface do usuário com uma propriedade, aplicar um EditorAttribute à propriedade, sistema autônomo neste 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 tipo de um designer, aplique um DesignerAttribute diretamente acima da declaração de classe, sistema autônomo neste 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 {...}

Observação:
Nos exemplos acima, os construtores para o TypeConverterAttribute,EditorAttribute, and DesignerAttribute classes accept System.Type objects as their arguments.Essa forma de construtor para esses atributos funciona se o tipo for no mesmo assembly sistema autônomo sistema autônomo classes de time de design.Se sistema autônomo classes de time de design estiverem em um assembly diferente, em seguida, um formulário diferente do construtor de atributo (denominado formato qualificado de assembly) é necessária, sistema autônomo neste exemplo de código a seguir.

Nos exemplos acima, os construtores para o TypeConverterAttribute,EditorAttribute, and DesignerAttribute classes accept System.Type objects as their arguments.Essa forma de construtor para esses atributos funciona se o tipo for no mesmo assembly sistema autônomo sistema autônomo classes de time de design.Se sistema autônomo classes de time de design estiverem em um assembly diferente, em seguida, um formulário diferente do construtor de atributo (denominado formato qualificado de assembly) é necessária, sistema autônomo neste 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 time de design de nível de assembly

O ASP.NET fornece um atributo de nível de assembly (System.Web.UI.TagPrefixAttribute) que permite que um desenvolvedor de controles especificar um prefixo de marca para um controle ASP.NET. O prefixo da marca é injetado automaticamente pelo Visual Studio .NET no Registerdiretiva para o controle, para que o controle pode ser usado declarativamente na página com o prefixo da marca predeterminada (<TagPrefix:nome do controle runat = servidor / >).

Observação:
O TagPrefixAttribute funciona apenas nas designers visuais. Se você criar páginas ASP.NET usando um editor de texto, sistema autônomo o bloco de notas, você precisa especificar o prefixo da marca e o espaço para nome por conta própria no Register 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 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

Compartilhar via