Filtragem de metadados
A filtragem de metadados 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 posterior para restaurar o valor de tempo de execução desta propriedade.
Para executar a filtragem de metadados, um designer pode tanto implementar a IDesignerFilter de interface ou adicione um ITypeDescriptorFilterService a implementação para o provedor de serviços de tempo de design que pode realizar a filtragem de metadados em qualquer componente no 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 de modificar o conjunto de atributos, eventos e propriedades retornadas pelo componente.Os métodos de qualquer ativo ITypeDescriptorFilterService são chamados, em seguida, para permitir que o serviço fazer qualquer filtragem de atributos, eventos e propriedades.
Normalmente, um componente no modo de design é consultado quanto a seus atributos, eventos e propriedades 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 é definida.Métodos de outros objetos ou um ambiente de tempo de design podem chamar os métodos de um TypeDescriptor em outros momentos.
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 atributos expostos pelo componente gerenciado pelo designer em tempo de design.
Cada método da IDesignerFilter interface é prefixado com "Pre" ou "Post".Cada método é incluído como "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ê quiser 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 as identificações de tipo dos atributos.Para alterar ou remover um atributo ou atributos, implementar uma substituição da PostFilterAttributes método.
Se você quiser 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 da 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 a 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 pela 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