A filtragem de metadados
Metadados de filtragem permite que um designer modificar o conjunto de propriedades, atributos e eventos expostos por um componente ou controle em tempo de design.
Por exemplo, Control tem uma propriedade chamada Visible que determina se o controle está visível. Em tempo de design, no entanto, o controle deve permanecer sempre visível, independentemente do valor dessa propriedade para que um desenvolvedor possa posicioná-lo na superfície de design. O designer para Control substitui o Visible propriedade com sua própria versão em tempo de design e posteriormente para restaurar o valor de tempo de execução desta propriedade.
Para executar a filtragem de metadados, um designer pode tanto implementar a IDesignerFilter interface ou adicione um ITypeDescriptorFilterService Serviços de implementação para o tempo de design provedor que pode executar os metadados de filtragem de qualquer componente do ambiente de tempo de design.
Quando um componente é selecionado em tempo de design, o Pesquisador de propriedade consultará o componente de seus atributos, eventos e propriedades por meio dos métodos de um TypeDescriptor. Quando um componente é consultado para seus atributos, eventos e propriedades no modo de design, qualquer designer para o componente que implementa o IDesignerFilter interface é fornecida uma oportunidade para modificar o conjunto de atributos, eventos e propriedades retornadas pelo componente. Os métodos de qualquer ativo ITypeDescriptorFilterService são chamados de Avançar para permitir que o serviço fazer qualquer filtragem de atributos, eventos e propriedades.
Normalmente, um componente no modo de design é consultado para seus atributos, propriedades e eventos quando o Refresh o método de TypeDescriptor é chamado no componente, quando a janela Propriedades é atualizada, quando o modo de design é estabelecido ou restabelecido, e quando a seleção principal é definido. Métodos de outros objetos ou em um ambiente de tempo de design podem chamar os métodos de um TypeDescriptor em outras vezes.
Interface IDesignerFilter para filtragem de metadados do componente
O IDesignerFilter interface define um conjunto de métodos que podem ser substituídas e implementados em um designer para alterar as propriedades, eventos ou a atributos expostos pelo componente gerenciado pelo designer em tempo de design.
Cada método de IDesignerFilter interface é prefixado com "pre" ou "Post". Cada método é sufixado com "Atributos", "Eventos" ou "Propriedades", dependendo do tipo de membro permite adicionar, alterar ou remover. Para adicionar quaisquer atributos, eventos, ou propriedades, usam o método relevante cujo nome começa com "pre". Para alterar ou remover quaisquer atributos, eventos, ou propriedades, usam o método relevante cujo nome começa com "Post". Os métodos cujos nomes começam com "pre" são chamados imediatamente antes dos métodos cujos nomes começam com "Post".
Se você deseja adicionar um atributo ou atributos, implementar uma substituição da PreFilterAttributes método que adiciona o novo System.Attribute para o IDictionary passado para o método. As chaves no dicionário são o tipo de identificações de atributos. Para alterar ou remover um atributo ou atributos, implementar uma substituição da PostFilterAttributes método.
Se você deseja adicionar um evento ou eventos, implementar uma substituição da PreFilterEvents método que adiciona o novo EventDescriptor para o IDictionary passado para o método. As chaves no dicionário são os nomes dos eventos. Para alterar ou remover um evento ou eventos, implementar uma substituição da PostFilterEvents método.
Se você quiser adicionar uma propriedade ou propriedades, implementar uma substituição da PreFilterProperties método que adiciona o novo PropertyDescriptor para o IDictionary passado para o método. As chaves no dicionário são os nomes das propriedades. Para alterar ou remover uma propriedade ou propriedades, implementar uma substituição da PostFilterProperties método.
.gif "Observação") Observação |
|---|
Quando uma classe estende um designer que implementa IDesignerFilter, cada PostMethodName método deve chamar o correspondente PostMethodName método da classe base após alterar seus próprios atributos e cada PreMethodName método deve chamar o correspondente PreMethodName método da classe base antes de alterar seus próprios atributos. |
O bloco de código de exemplo a seguir mostra as assinaturas de método do IDesignerFilter interface.
Public Interface IDesignerFilter
Sub PostFilterAttributes(attributes As IDictionary)
Sub PostFilterEvents(events As IDictionary)
Sub PostFilterProperties(properties As IDictionary)
Sub PreFilterAttributes(attributes As IDictionary)
Sub PreFilterEvents(events As IDictionary)
Sub PreFilterProperties(properties As IDictionary)
End Interface
public interface IDesignerFilter {
void PostFilterAttributes(IDictionary attributes);
void PostFilterEvents(IDictionary events);
void PostFilterProperties(IDictionary properties);
void PreFilterAttributes(IDictionary attributes);
void PreFilterEvents(IDictionary events);
void PreFilterProperties(IDictionary properties);
}
O exemplo de código a seguir demonstra uma implementação de IDesignerFilter que adiciona um Color a propriedade do designer para o componente associado. Você precisará adicionar uma referência ao System.Design.dll.
Imports System
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Drawing
Imports System.Windows.Forms
Imports System.Windows.Forms.Design
Namespace IDesignerFilterSample
_
Public Class DesignerFilterDesigner
Inherits ComponentDesigner
' Designer color property to add to component.
Public Property TestColor() As Color
Get
Return Me.intcolor
End Get
Set(ByVal Value As Color)
Me.intcolor = Value
End Set
End Property
' Color for TestColor property.
Private intcolor As Color = Color.Azure
Public Function DesignerFilterDesigner()
End Function 'DesignerFilterDesigner
' Adds a color property of this designer to the component.
Protected Overrides Sub PreFilterProperties(ByVal properties As System.Collections.IDictionary)
MyBase.PreFilterProperties(properties)
' Adds a test property to the component.
properties.Add("TestColor", TypeDescriptor.CreateProperty(GetType(DesignerFilterDesigner), "TestColor", GetType(System.Drawing.Color), Nothing))
End Sub 'PreFilterProperties
End Class 'DesignerFilterDesigner
' Component with which the DesignerFilterDesigner is associated.
<Designer(GetType(DesignerFilterDesigner))> _
Public Class TestComponent
Inherits Component
Public Function TestComponent()
End Function 'TestComponent
End Class 'TestComponent
End Namespace
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.Design;
namespace IDesignerFilterSample
{
public class DesignerFilterDesigner : ComponentDesigner, IDesignerFilter
{
// Designer color property to add to component.
public Color TestColor
{
get
{ return this.intcolor; }
set
{ this.intcolor = value; }
}
// Color for TestColor property.
private Color intcolor = Color.Azure;
public DesignerFilterDesigner()
{}
// Adds a color property of this designer to the component.
protected override void PreFilterProperties(System.Collections.IDictionary properties)
{
base.PreFilterProperties(properties);
// Adds a test property to the component.
properties.Add("TestColor", TypeDescriptor.CreateProperty(typeof(DesignerFilterDesigner), "TestColor", typeof(System.Drawing.Color), null));
}
}
// Component with which the DesignerFilterDesigner is associated.
[Designer(typeof(DesignerFilterDesigner))]
public class TestComponent : Component
{
public TestComponent()
{}
}
}
Para obter um exemplo de um Windows Forms designer que implementa a filtragem de propriedade usando de controlar o IDesignerFilter interface, consulte a Exemplo de Designer de formulários do Windows.
ITypeDescriptorFilterService para filtragem de metadados Global de modo de Design
Você pode fornecer metadados de filtragem para qualquer componente em um projeto de tempo de design, adicionando um ITypeDescriptorFilterService implementação para o provedor de serviços que fornece serviços em tempo de design, usando o AddService método da IServiceContainer interface implementada pela ISite retornado pelo Site propriedade de um Component situados no modo de design.
O exemplo de código a seguir demonstra como adicionar um ITypeDescriptorFilterService serviço chamado ExampleFilterService.
IDesignerHost dh = (IDesignerHost)this.Component.GetService(typeof(IDesignerHost));
if( dh != null )
{
// First gets any previous ITypeDescriptorFilterService to replace when
// the current service is removed, and to call if the new service
// implements service chaining.
ITypeDescriptorFilterService itdfs =
(ITypeDescriptorFilterService)dh.GetService( typeof(ITypeDescriptorFilterService));
oldService = (ITypeDescriptorFilterService)dh.GetService(
typeof(ITypeDescriptorFilterService));
if(oldService != null)
// Removes any old ITypeDescriptorFilterService.
dh.RemoveService(typeof(ITypeDescriptorFilterService));
// Adds an ExampleFilterService that implements service chaining.
dh.AddService(typeof(ITypeDescriptorFilterService),
new ExampleFilterService(oldService));
}
Para obter um exemplo ITypeDescriptorFilterService implementação, consulte a documentação de referência para o ITypeDescriptorFilterService classe.
Consulte também
Tarefas
Como: Ajustar os atributos, eventos e propriedades de um componente no modo de Design
Conceitos
Como: Implementar um Designer para um controle
Visão geral do descritor de tipo