[Maximilian]

Wer schonmal zum Beispiel einen ToolTip oder ErrorProvider benutzt hat, wird das verhalten kennen, dass diese Komponenten in den Eigenschaftenlisten aller Controls zusätzliche Einträge hinzufügen.
Dieses Verhalten läßt sich durch das Implementieren der Schnittstelle IExtenderProvider sowie des Attributes ProvidePropertyAttribute nachbilden.

IExtenderProvider
Dieses Interface implementiert nur eine Funktion:

Visual C#

bool CanExtend(object extendee);

Anhand dieser Funktion kann man bestimmen welche Objekte um die Eigenschaft(en) erweitert werden sollen. Als Beispiel möchte ich alle Elemente welche vom Typ Control ableiten erweitern, einzige Ausnahme ist die Form:

Visual C#

public bool CanExtend(object extendee)
{
    return (extendee is Control) && !(extendee is Form);
}

ProvidePropertyAttribute
In diesem Attribut werden die einzelnen Eigenschaften definiert, um welche die anderen Controls erweitert werden sollen. Angegeben werden muss der Name der Eigenschaft als String sowie der Typ des Zielcontrols als Type oder String:

Visual C#

[ProvidePropertyAttribute("AllowHide", typeof(Control))]
public class myComponent {
    // ...
}

Korrespondierend zu den Attributen benötigt man für jedes Attribut zwei Methoden zum Get und Set der Eigenschaften. Die Namen für diese Funktionen sind vorgegen und müssen wie folgt aufgebaut sein:
public [Datentyp] Get[Name der Eigenschaft welche auch im Attribut verwendet wurde] ([Typ des Controls welche um diese Eigenschaft erweitert wurde] control) { /* ... */ }
public void Set[Name der Eigenschaft welche auch im Attribut verwendet wurde] ([Typ des Controls welche um diese Eigenschaft erweitert wurde] control, [Datentyp] value) { /* ... */ }

Angewandt auf das Beispielattribut von oben könnten die beiden Methoden wie folgt aussehen:

Visual C#

public bool GetAllowHide(Control control)
{
    return getControlItem(control).AllowHide; // <- Hilfsfunktion welche ich später erkläre
}
public void SetAllowHide(Control control, bool value)
{
   getControlItem(control).AllowHide = value; // <- Hilfsfunktion welche ich später erkläre
}

Zusätzlich zum Interface und Attribut(ten) benötigt man noch eine Klasse welche als Wrapper für die Controlinstanzen sowie die zusätzlichen Eigenschaften dient. In meinem Beispiel sieht dieser Wrapper wie folgt aus:

Visual C#

/// <summary>
/// Wrapperklasse zum vereinen von Controlinstanz und zusätzlichen Eigenschaften.
/// </summary>
public class controlItem
{
    public controlItem(Control sControl, myComponent sComponent)
    {
        controlInstance = sControl;
        componentInstance = sComponent;
        AllowHide = true;
        //An dieser Stelle kann man Events von der jeweiligen Controlinstanz abonieren
        //um entsprechend reagieren zu können.
        controlInstance.VisibleChanged += new EventHandler(instanceControl_VisibleChanged);
    }
 
    //Flag welches temporär gesetzt werden muss um einen Stackoverflow zu verhindern
    private bool flag = false;

     //Beispiel 
    void instanceControl_VisibleChanged(object sender, EventArgs e)
    {
        if (!AllowHide && !(sender as Control).Visible && !flag)
        {
            flag = true;
            controlInstance.Visible = true;
            flag = false;
        }
    }

    /// <summary>
    /// Gibt die Controlinstanz wieder oder legt diese fest.
    /// </summary>
    public Control controlInstance { get; set; }
    
    /// <summary>
    /// Gibt die Komponenteninstanz zurück oder legt diese fest.
    /// </summary>
    public myComponent componentInstance { get; set; }
    
    /// <summary>
    /// Gibt an ob das Control versteckt werden darf oder legt dieses fest.
    /// </summary>
    public bool AllowHide { get; set; }
}

Zum Verwalten der Controlinstanzen nutze ich eine Hashtable und eine Hilfsfunktion zum abrufen und setzen der einzelnen controlItems (siehe kompletten Beispielcode unten) und deren neuen Eigenschaften.
Das folgende komplette Beispiel fügt allen Steuerelementen (außer der Form) eine neue Eigenschaft ("AllowHide") hinzu. Ist diese auf False gesetzt ist es nicht möglich diese Controls mit Visible=False oder der Methode Hide() zu verstecken. Über den Sinn bzw. Unsinn müssen wir nicht diskutieren, dieses dient nur als Beispiel zur Veranschaulichung

Spoiler

Visual C#

using System;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;

namespace dotNetBase
{
    [ProvidePropertyAttribute("AllowHide", typeof(Control))] //Attribute welches benötigt wird um die Eigenschaft zu registrieren 
    public class myComponent : Component, IExtenderProvider
    {
        /// <summary>
        /// Wrapperklasse zum vereinen von Controlinstanz und zusätzlichen Eigenschaften.
        /// </summary>
        public class controlItem
        {
            public controlItem(Control sControl, myComponent sComponent)
            {
                controlInstance = sControl;
                componentInstance = sComponent;
                AllowHide = true;
                //An dieser Stelle kann man Events von der jeweiligen Controlinstanz abonieren
                //um entsprechend reagieren zu können.
                controlInstance.VisibleChanged += new EventHandler(instanceControl_VisibleChanged);
            }

            //Flag welches temporär gesetzt werden muss um einen Stackoverflow zu verhindern
            private bool flag = false;

            //Beispiel 
            void instanceControl_VisibleChanged(object sender, EventArgs e)
            {
                if (!AllowHide && !(sender as Control).Visible && !flag)
                {
                    flag = true;
                    controlInstance.Visible = true;
                    flag = false;
                }
            }

            /// <summary>
            /// Gibt die Controlinstanz wieder oder legt diese fest.
            /// </summary>
            public Control controlInstance { get; set; }
            /// <summary>
            /// Gibt die Komponenteninstanz zurück oder legt diese fest.
            /// </summary>
            public myComponent componentInstance { get; set; }
            /// <summary>
            /// Gibt an ob das Control versteckt werden darf oder legt dieses fest.
            /// </summary>
            public bool AllowHide { get; set; }
        }

        private Hashtable items;

        public myComponent()
        {
            items = new Hashtable();
        }

        private controlItem getControlItem(Control control)
        {
            if (control == null)
            {
                throw new ArgumentNullException("control");
            }

            controlItem item = (controlItem)this.items[control];
            if (item == null)
            {
                item = new controlItem(control, this);
                this.items[control] = item;
            }
            return item;
        }

        public bool GetAllowHide(Control control)
        {
            return getControlItem(control).AllowHide;
        }
        public void SetAllowHide(Control control, bool value)
        {
            getControlItem(control).AllowHide = value;
        }

        #region IExtenderProvider Member

        public bool CanExtend(object extendee)
        {
            return (extendee is Control) && !(extendee is Form);
        }

        #endregion
    }
}

Ich hoffe das war verständlich erklärt, ansonsten einfach nachfragen

Cheerio

Dieser Beitrag wurde von Maximilian bearbeitet: 03. Feb 2010 - 17:04