Applicazione di filtri ai metadati

Aggiornamento: novembre 2007

L'applicazione di filtri di metadati consente a una finestra di progettazione di modificare un insieme di proprietà, attributi ed eventi esposti da un componente o controllo in fase di progettazione.

Control, ad esempio, è dotato di una proprietà chiamata Visible che determina se il controllo è visibile o meno. In fase di progettazione, tuttavia, è opportuno che il controllo rimanga sempre visibile, indipendentemente dal valore di questa proprietà, in modo che gli sviluppatori possano posizionarlo sull'area di progettazione. La finestra di progettazione di Control sostituisce la proprietà Visible con la propria versione per la fase di progettazione e solo in seguito ripristina per la proprietà il valore della fase di esecuzione.

Per consentire l'applicazione di filtri ai metadati, una finestra di progettazione può implementare l'interfaccia IDesignerFilter oppure aggiungere un'implementazione di ITypeDescriptorFilterService al provider di servizi per la fase di progettazione che può quindi eseguire l'applicazione di filtri ai metadati su qualsiasi componente nell'ambiente di progettazione.

Quando un componente viene selezionato in fase di progettazione, il visualizzatore proprietà effettuerà una query sul componente per ottenerne gli attributi, gli eventi e le proprietà mediante i metodi di un oggetto TypeDescriptor. Quando viene effettuata una query su un componente per ottenerne attributi, eventi e proprietà in modalità di progettazione, qualsiasi finestra di progettazione per il componente che implementi l'interfaccia IDesignerFilter sarà in grado di modificare l'insieme di attributi, proprietà ed eventi restituiti dal componente. I metodi di qualsiasi oggetto ITypeDescriptorFilterService attivo vengono quindi chiamati per consentire al servizio di eseguire l'eventuale applicazione di filtri ad attributi, eventi e proprietà.

Un componente in modalità di progettazione normalmente riceve query su attributi, eventi e proprietà quando il metodo Refresh dell'oggetto TypeDescriptor viene chiamato per il componente, quando la finestra Proprietà viene aggiornata, quando la modalità di progettazione viene stabilita o ristabilita e quando viene impostata la selezione principale. I metodi di altri oggetti o un ambiente di progettazione potrebbero chiamare metodi da un oggetto TypeDescriptor in altri momenti.

Interfaccia IDesignerFilter per l'applicazione di filtri ai metadati dei componenti

L'interfaccia IDesignerFilter consente di definire un insieme di metodi di cui è possibile eseguire l'override e che è possibile implementare in una finestra di progettazione per modificare le proprietà, gli eventi o gli attributi esposti dal componente gestito dalla finestra di progettazione e in fase di progettazione.

Ciascun metodo dell'interfaccia IDesignerFilter è provvisto di prefisso "Pre" o "Post". Ciascun metodo è provvisto di suffisso "Attributes", "Events" o "Properties", a seconda del tipo di membro che consente di aggiungere, modificare o rimuovere. Per aggiungere attributi, eventi o proprietà, utilizzare il metodo desiderato tra quelli il cui nome inizia per "Pre". Per modificare o rimuovere attributi, eventi o proprietà, utilizzare il metodo desiderato tra quelli il cui nome inizia per "Post". I metodi i cui nomi iniziano per "Pre" vengono chiamati immediatamente prima di quelli i cui nomi iniziano per "Post".

Se si desidera aggiungere uno o più attributi, implementare un override del metodo PreFilterAttributes che aggiunge il nuovo attributo System.Attribute all'oggetto IDictionary passato al metodo. Le chiavi nel dizionario sono gli ID del tipo degli attributi. Per modificare o rimuovere uno o più attributi, implementare un override del metodo PostFilterAttributes.

Se si desidera aggiungere uno o più eventi, implementare un override del metodo PreFilterEvents che aggiunge il nuovo attributo EventDescriptor all'oggetto IDictionary passato al metodo. Le chiavi nel dizionario sono i nomi degli eventi. Per modificare o rimuovere uno o più eventi, implementare un override del metodo PostFilterEvents.

Se si desidera aggiungere una o più proprietà, implementare un override del metodo PreFilterProperties che aggiunge il nuovo attributo PropertyDescriptor all'oggetto IDictionary passato al metodo. Le chiavi nel dizionario sono i nomi delle proprietà. Per modificare o rimuovere una o più proprietà, implementare un override del metodo PostFilterProperties.

Nota:
Quando una classe estende una finestra di progettazione che implementa IDesignerFilter, è necessario che ciascun metodo PostNomeMetodo chiami il corrispondente metodo PostNomeMetodo della classe base dopo la modifica dei propri attributi e che ciascun metodo PreNomeMetodo chiami il corrispondente metodo PreNomeMetodo della classe base prima della modifica dei propri attributi.

Nell'esempio di codice seguente vengono mostrate le firme del metodo dell'interfaccia IDesignerFilter.

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);
}

Nell'esempio di codice seguente viene mostrata un'implementazione dell'oggetto IDesignerFilter che aggiunge una proprietà Color della finestra di progettazione al componente associato.

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()
      {}
   }
}

Per un esempio di finestra di progettazione di controlli Windows Form che implementa il filtro delle proprietà utilizzando l'interfaccia IDesignerFilter, vedere l'Esempio di finestra di progettazione Windows Form.

Servizio ITypeDescriptorFilterService per l'applicazione di filtri ai metadati in modalità progettazione globale

È possibile fornire l'applicazione di filtri ai metadati per qualsiasi componente in un progetto in fase di progettazione, aggiungendo un'implementazione di ITypeDescriptorFilterService al provider che fornisce servizi per la fase di progettazione, utilizzando il metodo AddService dell'interfaccia IServiceContainer implementata dall'oggetto ISite restituito dalla proprietà Site di un oggetto Component collocato in modalità di progettazione.

Nell'esempio di codice seguente viene illustrato come aggiungere un servizio ITypeDescriptorFilterService denominato 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));
}

Per un esempio di implementazione di ITypeDescriptorFilterService, vedere la documentazione di riferimento per la classe ITypeDescriptorFilterService.

Vedere anche

Attività

Procedura: modificare attributi, eventi e proprietà di un componente in modalità progettazione

Concetti

Classi base della finestra di progettazione

Verbi di progettazione

Procedura: implementare una finestra di progettazione per un controllo

Cenni preliminari sul descrittore del tipo

Altre risorse

Finestre di progettazione personalizzate