Filtragem de metadados

Metadados de filtragem permite que um designer modificar o conjunto de propriedades, atributos e eventos expostos por um componente ou controle no time de design.

Por exemplo, Control possui uma propriedade chamada Visible que determina se o controle está visível. Em time de design, no entanto, o controle deve sempre permanecer visível, independentemente do valor dessa propriedade para que um desenvolvedor pode posicioná-lo na área de design.O designer de Control substitui o Visible propriedade com sua própria versão na time de design e posteriormente para restaurar o valor de time de execução desta propriedade.

Para executar filtragem de metadados, um designer pode implementar tanto o IDesignerFilter interface ou adicione um ITypeDescriptorFilterService implementação para o provedor de serviços de time de design que pode executar filtragem de metadados de qualquer componente no ambiente de time de design.

Quando um componente é selecionado em time de design, o navegador de propriedade consulta o componente para seus atributos, eventos e propriedades através dos métodos de um TypeDescriptor. Quando um componente é consultado quanto a 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 chamadas a seguir para permitir que o serviço fazer qualquer filtragem de atributos, eventos e propriedades.

Um componente no modo de design normalmente é consultado quanto a seus atributos, eventos e propriedades quando o Refresh 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 time de design podem chamar os métodos de um TypeDescriptor em outras ocasiões.

Interface IDesignerFilter para filtragem de metadados do componente

The 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 time de design.

Cada método do IDesignerFilterinterface é 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 todos os atributos, eventos, ou propriedades, use o método relevante cujo nome começa com "Pre".Para alterar ou remover todos os atributos, eventos, ou propriedades, use 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 substituir do 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 substituir do PostFilterAttributes método.

Se você deseja adicionar um evento ou eventos, implementar uma substituir do 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 substituir do PostFilterEvents método.

Se você deseja adicionar uma propriedade ou propriedades, implementar uma substituir do 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 substituir do PostFilterProperties método.

Observação:
Quando uma classe estende um designer que implementa IDesignerFilter, cada POSTMétodo de MethodName deve chamar o correspondente POSTMethodName método da classe base após alterar seus próprios atributos e cada PreMétodo de MethodName deve chamar o correspondente PreMethodName método da classe base antes de alterar seus próprios atributos.

O seguinte bloco de código de exemplo 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 propriedade do designer para o componente associado.

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 designer de controle Windows Forms que implementa a filtragem de propriedade usando o IDesignerFilter interface, consulte o Exemplo do Designer de Formulários do Windows.

ITypeDescriptorFilterService para filtragem de metadados de modo de design global

Você pode fornecer metadados de filtragem para qualquer componente em um projeto design-time adicionando um ITypeDescriptorFilterService implementação para o provedor de serviços que fornece serviços em tempo de design, usando o AddService método para o IServiceContainer interface implementada pela ISite retornado pela Site propriedade de um Component localizado 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));
}

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

Classes base do Designer

Verbos do Designer

Como: Implementar um designer para um controle

Visão geral do descritor de tipo

Outros recursos

Designers personalizados