[C#] Eigenschaften zu Controls hinzufügen

Hellsgore

Servus,

ich stehe gerade hier vor einem kleinen Problem. Ich würde gerne zu bestimmten Controls, welche auf meinem Formular gesetzt sind, einige Eigenschaften hinzufügen. Ein gutes Beispiel dafür ist das ToolTip. Sobald es hinzugefügt wird, werden automatisch zu bestimmten Controls, die Eigenschaft "ToolTip on toolTipx" drangepappt. Vielleicht hat sich schon jemand in diese Richtung damit beschäftigt und könnte mir einen kleinen Denkanstoß geben. Denn irgendwie stehe ich hier gerade im leeren...

mfg
Hellsgore

Hellsgore schrieb:

Servus,

ich stehe gerade hier vor einem kleinen Problem. Ich würde gerne zu bestimmten Controls, welche auf meinem Formular gesetzt sind, einige Eigenschaften hinzufügen. Ein gutes Beispiel dafür ist das ToolTip. Sobald es hinzugefügt wird, werden automatisch zu bestimmten Controls, die Eigenschaft "ToolTip on toolTipx" drangepappt. Vielleicht hat sich schon jemand in diese Richtung damit beschäftigt und könnte mir einen kleinen Denkanstoß geben. Denn irgendwie stehe ich hier gerade im leeren...

mfg
Hellsgore

guckmal ob dir das Weiterhilft, der ToolTip ist ne eigene Klasse, aber hier nen
Code - Schnipsel aus der MSDN

// This example assumes that the Form_Load event handling method
// is connected to the Load event of the form.
private void Form1_Load(object sender, System.EventArgs e)
{
   // Create the ToolTip and associate with the Form container.
   ToolTip toolTip1 = new ToolTip();

   // Set up the delays for the ToolTip.
   toolTip1.AutoPopDelay = 5000;
   toolTip1.InitialDelay = 1000;
   toolTip1.ReshowDelay = 500;
   // Force the ToolTip text to be displayed whether or not the form is active.
   toolTip1.ShowAlways = true;

   // Set up the ToolTip text for the Button and Checkbox.
   toolTip1.SetToolTip(this.button1, "My button1");
   toolTip1.SetToolTip(this.checkBox1, "My checkBox1");
}

Ansonsten von gewünschten Control nen eigenes Control ableiten
und dort mit besagter Klasse ToolTip eigenen Code einbauen denke ich!

mfg

Hellsgore

Servus,

danke für deinen Beitrag. Aber ich möchte ja keine Klasse und oder Control ableiten, abgesehen davon ist die ToolTip Klasse sealed, sondern ich möchte während der Designzeit (also im DesignModus von Visual Studio) einige Eigenschaften zu verschiedenen Komponenten hinzufügen. Wie ich das zu Laufzeit mache, ist kein Problem, bei mir hängt es am Designermodus. Ich glaube ich hatte mich eben unverständlich ausgedrückt

Aus diesem Grund habe ich als Beispiel die ToolTip Komponente genommen, welche beim erstellen der Komponente auf dem Formular, bestimmten Controls etc. eine Eigenschaft "ToolTip on toolTipXYZ" zuweist. Ich benötige einfach irgendeinen Anhaltspunkt.......

mfg
Hellsgore

Also ich schaffe mit 2003er Variante und wenn ich mein Eignschaftsfenster aufhabe
sieht man nicht wie beim BorlandBuilder ne Eigneschaft Hint oder sowas!
Naja wie gesagt im .NET - IDE fehlt bei mir sowas.

Also ich hoffe ich bin nicht auf dem Holzweg, aber ich glaube wenn Du meinen
gepostet Code siehst ist diese ToolTip - Klasse son wie soll man sagen nen
Servicobjekt was ner Komponente von aussen nochnen Schild druffbabbt was
wenn mal später der Maus kommt nen Hint aufmacht!

Bei allen Komponenten hier wird bekanntlich zwischen
Entwurfszeit und DesignZeit unterschieden!

Und damit du was zur Designzeit hast ne Eigenschaft kommste wenn du diegleich IDE hasst wie ich nicht drumrum ne eigenes Control zu bauen!

Wenn Du zumbeispiel nen Member eines solhen Eigenbaus zu ner Eigenschaft die auch zur Entwurfszeit musst Du mal unter DesignerVerb-Klasse in deiner MSDN gucke, und diese komponente/dein Control selbstbasteln

guckemal das habe ich zu nem Eigenbaucontrol in MSDN gef:

//------------------------------------------------------------------------------
/// <copyright from='1997' to='2001' company='Microsoft Corporation'>
///    Copyright (c) Microsoft Corporation. All Rights Reserved.
///
///    This source code is intended only as a supplement to Microsoft
///    Development Tools and/or on-line documentation.  See these other
///    materials for detailed information regarding Microsoft code samples.
///
/// </copyright>
//------------------------------------------------------------------------------
namespace Microsoft.Samples.WinForms.Cs.HelpLabel {
    using System;
    using System.Collections;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Drawing;
    using System.Windows.Forms;
    using System.Windows.Forms.Design;

    //
    // <doc>
    // <desc>
    // Help Label offers an extender property called
    // "HelpText".  It monitors the active control
    // and displays the help text for the active control.
    // </desc>
    // </doc>
    //
    [
    ProvideProperty("HelpText",typeof(Control)),
    Designer(typeof(HelpLabel.HelpLabelDesigner))
    ]
    public class HelpLabel : Control, System.ComponentModel.IExtenderProvider {
        /// <summary>
        ///    Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components;
        private Hashtable helpTexts;
        private System.Windows.Forms.Control activeControl;

        //
        // <doc>
        // <desc>
        //      Creates a new help label object.
        // </desc>
        // </doc>
        //
        public HelpLabel() {
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            helpTexts = new Hashtable();
        }

        /// <summary>
        ///    Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing) {
            if (disposing) {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        /// <summary>
        ///    Required method for Designer support - do not modify
        ///    the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent() {
            this.components = new System.ComponentModel.Container ();
            this.BackColor = System.Drawing.SystemColors.Info;
            this.ForeColor = System.Drawing.SystemColors.InfoText;
            this.TabStop = false;
        }

        //
        // <doc>
        // <desc>
        //      Overrides the text property of Control.  This label ignores
        //      the text property, so we add additional attributes here so the
        //      property does not show up in the properties window and is not
        //      persisted.
        // </desc>
        // </doc>
        //
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public override string Text {
            get {
                return base.Text;
            }
            set {
                base.Text = value;
            }
        }

        //
        // <doc>
        // <desc>
        //      This implements the IExtenderProvider.CanExtend method.  The
        //      help label provides an extender property, and the design time
        //      framework will call this method once for each component to determine
        //      if we are interested in providing our extended properties for the
        //      component.  We return true here if the object is a control and is
        //      not a HelpLabel (since it would be silly to add this property to
        //      ourselves).
        // </desc>
        // </doc>
        //
        bool IExtenderProvider.CanExtend(object target) {
            if (target is Control &&
                !(target is HelpLabel)) {

                return true;
            }
            return false;
        }

        //
        // <doc>
        // <desc>
        //      This is the extended property for the HelpText property.  Extended
        //      properties are actual methods because they take an additional parameter
        //      that is the object or control to provide the property for.
        // </desc>
        // </doc>
        //
        [
        DefaultValue(""),
        ]
        public string GetHelpText(Control control) {
            string text = (string)helpTexts[control];
            if (text == null) {
                text = string.Empty;
            }
            return text;
        }

        //
        // <doc>
        // <desc>
        //      This is an event handler that responds to the OnControlEnter
        //      event.  We attach this to each control we are providing help
        //      text for.
        // </desc>
        // </doc>
        //
        private void OnControlEnter(object sender, EventArgs e) {
            activeControl = (Control)sender;
            Invalidate();
        }

        //
        // <doc>
        // <desc>
        //      This is an event handler that responds to the OnControlLeave
        //      event.  We attach this to each control we are providing help
        //      text for.
        // </desc>
        // </doc>
        //
        private void OnControlLeave(object sender, EventArgs e) {
            if (sender == activeControl) {
                activeControl = null;
                Invalidate();
            }
        }

        //
        // <doc>
        // <desc>
        //      This is the extended property for the HelpText property.
        // </desc>
        // </doc>
        //
        public void SetHelpText(Control control, string value) {
            if (value == null) {
                value = string.Empty;
            }

            if (value.Length == 0) {
                helpTexts.Remove(control);

                control.Enter -= new EventHandler(OnControlEnter);
                control.Leave -= new EventHandler(OnControlLeave);
            }
            else {
                helpTexts[control] = value;

                control.Enter += new EventHandler(OnControlEnter);
                control.Leave += new EventHandler(OnControlLeave);
            }

            if (control == activeControl) {
                Invalidate();
            }
        }

        //
        // <doc>
        // <desc>
        //      Overrides Control.OnPaint.  Here we draw our
        //      label.
        // </desc>
        // </doc>
        //
        protected override void OnPaint(PaintEventArgs pe) {

            // Let the base draw.  This will cover our back
            // color and set any image that the user may have
            // provided.
            //
            base.OnPaint(pe);

            // Draw a rectangle around our control.
            //
            Rectangle rect = ClientRectangle;

            Pen borderPen = new Pen(ForeColor);
            pe.Graphics.DrawRectangle(borderPen, rect);
            borderPen.Dispose();

            // Finally, draw the text over the top of the
            // rectangle.
            //
            if (activeControl != null) {
                string text = (string)helpTexts[activeControl];
                if (text != null && text.Length > 0) {
                    rect.Inflate(-2, -2);
                    Brush brush = new SolidBrush(ForeColor);
                    pe.Graphics.DrawString(text, Font, brush, rect);
                    brush.Dispose();
                }
            }
        }

        // <doc>
        // <desc>
        //     Returns true if the backColor should be persisted in code gen.  We
        //      override this because we change the default back color.
        // </desc>
        // <retvalue>
        //     true if the backColor should be persisted.
        // </retvalue>
        // </doc>
        //
        public bool ShouldSerializeBackColor() {
            return(!BackColor.Equals(SystemColors.Info));
        }

        // <doc>
        // <desc>
        //     Returns true if the foreColor should be persisted in code gen.  We
        //      override this because we change the default foreground color.
        // </desc>
        // <retvalue>
        //     true if the foreColor should be persisted.
        // </retvalue>
        // </doc>
        //
        public bool ShouldSerializeForeColor() {
            return(!ForeColor.Equals(SystemColors.InfoText));
        }

        //
        // <doc>
        // <desc>
        //      This is a designer for the HelpLabel.  This designer provides
        //      design time feedback for the label.  The help label responds
        //      to changes in the active control, but these events do not
        //      occur at design time.  In order to provide some usable feedback
        //      that the control is working the right way, this designer listens
        //      to selection change events and uses those events to trigger active
        //      control changes.
        // </desc>
        // </doc>
        //
        public class HelpLabelDesigner : System.Windows.Forms.Design.ControlDesigner {

            private bool trackSelection = true;

            /// <summary>
            /// This property is added to the control's set of properties in the method
            /// PreFilterProperties below.  Note that on designers, properties that are
            /// explictly declared by TypeDescriptor.CreateProperty can be declared as
            /// private on the designer.  This helps to keep the designer's publi
            /// object model clean.
            /// </summary>
            private bool TrackSelection
            {
                get
                {
                    return trackSelection;
                }
                set
                {
                    trackSelection = value;
                    if (trackSelection)
                    {
                        ISelectionService ss = (ISelectionService)GetService(typeof(ISelectionService));
                        if (ss != null)
                        {
                            UpdateHelpLabelSelection(ss);
                        }
                    }
                    else
                    {
                        HelpLabel helpLabel = (HelpLabel)Control;
                        if (helpLabel.activeControl != null)
                        {
                            helpLabel.activeControl = null;
                            helpLabel.Invalidate();
                        }
                    }
                }
            }

            public override DesignerVerbCollection Verbs
            {
                get
                {
                    DesignerVerb[] verbs = new DesignerVerb[] {
                                                                  new DesignerVerb("Beispielverb", new EventHandler(OnSampleVerb))
                                                              };
                    return new DesignerVerbCollection(verbs);
                }
            }

            //
            // <doc>
            // <desc>
            //      Overrides Dispose.  Here we remove our handler for the selection changed
            //      event.  With designers, it is critical that they clean up any events they
            //      have attached.  Otherwise, during the course of an editing session many
            //      designers may get created and never destroyed.
            // </desc>
            // </doc>
            //
            protected override void Dispose(bool disposing) {
                if (disposing) {
                    ISelectionService ss = (ISelectionService)GetService(typeof(ISelectionService));
                    if (ss != null) {
                        ss.SelectionChanged -= new EventHandler(OnSelectionChanged);
                    }
                }

                base.Dispose(disposing);
            }

            //
            // <doc>
            // <desc>
            //       Overrides initialize.  Here we add an event handler to the selection service.
            //      Notice that we are very careful not to assume that the selection service is
            //      available.  It is entirely optional that a service is available and you should
            //      always degrade gracefully if a service could not be found.
            // </desc>
            // </doc>
            //
            public override void Initialize(IComponent component) {
                base.Initialize(component);

                ISelectionService ss = (ISelectionService)GetService(typeof(ISelectionService));
                if (ss != null) {
                    ss.SelectionChanged += new EventHandler(OnSelectionChanged);
                }
            }

            private void OnSampleVerb(object sender, EventArgs e)
            {
                MessageBox.Show("Sie haben soeben ein Beispielverb aufgerufen. Normalerweise htte dies eine sinnvolle Funktion.");
            }

            //
            // <doc>
            // <desc>
            //      Our handler for the selection change event.  Here we update the active control within
            //      the help label.
            // </desc>
            // </doc>
            //
            private void OnSelectionChanged(object sender, EventArgs e) {
                if (trackSelection)
                {
                    ISelectionService ss = (ISelectionService)sender;
                    UpdateHelpLabelSelection(ss);
                }
            }

            protected override void PreFilterProperties(IDictionary properties)
            {
                // Always call base first in PreFilter* methods, and last in PostFilter*
                // methods.
                base.PreFilterProperties(properties);

                // We add a design-time property called "TrackSelection" that is used to track
                // the active selection.  If the user sets this to true (the default), then
                // we will listen to selection change events and update the control's active
                // control to point to the current primary selection.
                properties["TrackSelection"] = TypeDescriptor.CreateProperty(
                    this.GetType(),        // the type this property is defined on
                    "TrackSelection",    // the name of the property
                    typeof(bool),        // the type of the property
                    new Attribute[] {CategoryAttribute.Design});    // attributes
            }

            /// <summary>
            /// This is a helper method that, given a selection service, will update the active control
            /// of our help label with the currently active selection.
            /// </summary>
            /// <param name="ss"></param>
            private void UpdateHelpLabelSelection(ISelectionService ss)
            {
                Control c = ss.PrimarySelection as Control;
                HelpLabel helpLabel = (HelpLabel)Control;
                if (c != null)
                {
                    helpLabel.activeControl = c;
                    helpLabel.Invalidate();
                }
                else
                {
                    if (helpLabel.activeControl != null)
                    {
                        helpLabel.activeControl = null;
                        helpLabel.Invalidate();
                    }
                }
            }
        }
    }
}

hmm jedenfalls in meiner Weiterbildung die sich um .NET gedreht hat
gings um Eigenbaucontrols und wie kriege ich Member/Eigenschaften zur
Entwurfszeit sichtbar! In dieser Hinsicht sind Codepassagen in den Eckigen Klammern wichtig weil du mit diesen wichtige Ausgaben in den Eigenschaftbrowser
bestimmst die zu deinem Control zur Entwurszeit kommen sollen

siehe:

[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Never),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]

frohes Schaffen

also wenn ich nicht auf dem Holzweg bin, musst Du nen Control einbauen/Selbstbauen
und in dem Control irgendwas schaffen was mit meine Code - Schnipsel was mit dem Control anstellt, siehe nochma diesen:

// This example assumes that the Form_Load event handling method
// is connected to the Load event of the form.
private void Form1_Load(object sender, System.EventArgs e)
{
   // Create the ToolTip and associate with the Form container.
   ToolTip toolTip1 = new ToolTip();

   // Set up the delays for the ToolTip.
   toolTip1.AutoPopDelay = 5000;
   toolTip1.InitialDelay = 1000;
   toolTip1.ReshowDelay = 500;
   // Force the ToolTip text to be displayed whether or not the form is active.
   toolTip1.ShowAlways = true;

   // Set up the ToolTip text for the Button and Checkbox.
   toolTip1.SetToolTip(this.button1, "My button1");
   toolTip1.SetToolTip(this.checkBox1, "My checkBox1");
}

in deinem Abgeletet Control müsste obiger Code dann etwa so aussehen:

// irgenwo in deine Eigenbaucontrol hast Du ne Variable
   String Hint; // könnte ja nen Geter/Seter sein vor den könntest Du och die
                // komische Geschicht in Eckigen Klammern schreiben, dann
                // wird dieses Datenelement auch angezeigt im Entwurf

   ToolTip toolTip1 = new ToolTip();

   // Set up the delays for the ToolTip.
   toolTip1.AutoPopDelay = 5000;
   toolTip1.InitialDelay = 1000;
   toolTip1.ReshowDelay = 500;
   // Force the ToolTip text to be displayed whether or not the form is active.
   toolTip1.ShowAlways = true;

   // Set up the ToolTip text for the Button and Checkbox.
   toolTip1.SetToolTip(this, Hint);

und damit man was im Entwurf sieht:

[
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
[Description("Event dieses EigenbauControl")] // durch diese Konstrukt
public event System.Eventhandler DeinHandlerEvent; // wird dieses Ding wien 
                                                   // Click - Event beinem   
                                                   // Button zur Entwurfszeit   
                                                   // bei den Eigenschaften 
                                                   // angezeigt und das sogar  
                                                   // mit ner Beschreibung

also das dürfte genug Stoff sein um Dirs vielleicht schmackhaft zu machen

nochmals frohes Schaffen

Hellsgore schrieb:

Servus,

danke für deinen Beitrag. Aber ich möchte ja keine Klasse und oder Control ableiten, abgesehen davon ist die ToolTip Klasse sealed, sondern ich möchte während der Designzeit (also im DesignModus von Visual Studio) einige Eigenschaften zu verschiedenen Komponenten hinzufügen. Wie ich das zu Laufzeit mache, ist kein Problem, bei mir hängt es am Designermodus. Ich glaube ich hatte mich eben unverständlich ausgedrückt

Aus diesem Grund habe ich als Beispiel die ToolTip Komponente genommen, welche beim erstellen der Komponente auf dem Formular, bestimmten Controls etc. eine Eigenschaft "ToolTip on toolTipXYZ" zuweist. Ich benötige einfach irgendeinen Anhaltspunkt.......

mfg
Hellsgore

ja wie gesagt ich sehe keine Eigenschaft Hint/Tooltip etc. zur Designzeit
jedenfalls nicht bei den Standardcontrols! -> selbst is der Mann its tool time
Oder ne Komponente von jemanden geben lassen der ne Komponente spezialisiert hat mit genau dem Feature was Du willst. Ansonsten habe ich da keine Idde!

mfg nochma

hmm wartmal aber die tooltip - Komponente die Du meinst könnte nen Container sein
bei der du jed Komponente registrierst gleichzeitig mit dem "Tooltip"
hmm es is schon spät jetzt sehe ich das Ding auch auf meiner Idde wart ich guck mal in meinem Projekt wie man das macht mit dem Ding

ne Quatsch is kein Container was rede ich es is ganau das Ding was ich auch
in den vorangegangen Postings habe.
Wie soll das zur Entwurfszeit schon funzen wenn dus da als komponente erst mit der
Maus auf deine Form zihst!

Bau nen String - Array wo deine Tooltips drin sind!

Innerhalb ner Schleife gehste durch das String - tooltip - Array

und dann benutzt Du im Schleifenkoerper besagten Code etwas abgewandelt
(um an alle Controls deiner Form was dranzupabben):

this.ToolTip1.AutoPopDelay = 5000;
    this.ToolTip1.InitialDelay = 1000;
    this.ToolTip1.ReshowDelay = 500;

    this.ToolTip1.ShowAlways = True;

    this.ToolTip1.S(...);

hmm da könnte man sich auch wie nennt man das Wrapper - Klassebauen
die nen TooltipStringArray bekommt
desweiteren gibt man der noch ne ControlCollection!
Und dann stempelt einen diese Klasse alle Schildchen (Tooltipps)
off alle Controls in der Collection!

jede Komponente hat doch die

(DynamicProperties) drunter is nen Feld hiesst (Advenced)

klick drauf es is egal alle haben dies Teil jetzt geht nen KontextMenu
auf dort drin scrollst du runter bis Tooltip mach dort nen Hacken in das Kästchen besagtes Schlüsselwort kannste so lassen oder wählst selbst eines!

Jetzt der Klou es gibt in deinem Projekt im Projektmappenexplorer ne Datei
heisst irgendwie was mit config klick dort doppelt an

Hier wird in dieser XML - Datei jeder Schlüssel der druch die
DuynamicPropeties ---> ToolTip gewählt wurde abgelegt!

Jetzt brauchst du dort nur das leere XML - Element editieren und du hast deine
ToolTip

dies ist eine Konfigurationsdatei die bei mir etw so aussieht (ist XML)

<?xml version="1.0" encoding="utf-8"?>
<configuration>
	<appSettings>
		<!--   Benutzeranwendung und konfigurierte Eigenschafteneinstellungen hier einfügen.-->
		<!--   Beispiel: <add key="settingName" value="settingValue"/> -->
		<add key="btnStartBrowser.ToolTip" value="Startet den Browser" />
		<add key="TextBox1.ToolTip" value="zeigt die Daten deines OPW - Accounts" />

	</appSettings>
</configuration>

Dort werden die Schüssel der DynamicProperties in unserem Fall ToolTip abgelegt, der Entwickler muss nur hierhinSteuern und das value - Attribut selbst einsetzten weil das der ToolTipp ist der angezeigt werden soll!

Such/Guck in der MSDN mal direkt unter Dynamische Eigenschaften
also ich weiss jetzt wies geht! Gut ich muss sagen das hat Microsoft
nen bisschen versteckt, jedoch ist es übers Eigenschaftsfenster erreichbar
(DynamicProperties) bei Tooltip Hacken machen (eventuell dort noch Schlüsselwert selbstdefinieren/am besten so lassen)

dann zu besagter config - Datei im Projektexplorer steuern!
Und diese XML - Datei zu editieren.

Die Schlüsselwerte sind dort unter den jeweiligen XML - Attribut key
zu finden und das XML - Attribut value is leer das musst du editieren!

Dann klappts auch mit den Tooltips, habs eben mal kompiliert läuft super!

mfg sclearscreen

Die ToolTip - komponente muss aber drin sein im Projekt die steuert dann global das Ansprechverhalten der "Hints"!
Sowie du kannst während der Laufzeit die "hints" verändern.

also denn dein Problem ist von meiner Warte her gelöst, ich hoffe ich war verständlich, auch wenn ich nenn bissl gebraucht habe! Sorry.

Hellsgore

Servus,

erstmal, wow... soviel Mühe wäre das nicht Wert gewesen . Ich bedanke mich aufjedenfall bei dir, für deine geopferte Zeit. Aber leider waren deine Ausführung nicht direkt das worauf ich hinauswollte. Die Lösung für das ganze Spektakel ist:

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

namespace TestComponent
{
	[ProvideProperty("MyProperty", typeof(Control))]
	public class MyClass : Component, IExtenderProvider 
	{
		protected bool ciMine = false;
		// Provides the Get portion of MyProperty. 
		public bool GetMyProperty(Control myControl) 
		{
			// Insert code here.
			return ciMine;
		}

		// Provides the Set portion of MyProperty.
		public void SetMyProperty(Control myControl, string value) 
		{
			// Insert code here.
		}

		/* When you inherit from IExtenderProvider, you must implement the 
		 * CanExtend method. */
		public bool CanExtend(Object target) 
		{
			return(target is Control);
		}

		// Insert additional code here.
	}

}

Das Stichwort ist hierbei "ProvideProperty" / "ProvidePropertyAttribute". Wenn man dieses Attribute bentutzt, benötigt man nur noch Get und Set Methoden für die Eigenschaft und die CanExtend Methode um herauszufinden ob das vorliegende Object vom Typ Control ist, damit man diese Eigenschaft daran pappen kann.

[ProvideProperty("MyProperty", typeof(Control))]

"MyProperty": Der Individuelle Name der Eigenschaft, wobei die Get und Set Methoden dem gleichen Namen entsprechen sollen.

typeof(Control): Der Vergleich für welchen Typ von Controls die Eigenschaft hinzugefügt werden soll. Trägt man hier TextBox ein, werden logischerweise nur Controls vom Typ TextBox zur Designzeit mit der Eigenschaft versehen.

Wenn man das alles in eine Klassenbibliothek packt und aus der Klasse selbst noch eine schöne Komponente "public class MyClass : Component, IExtenderProvider " macht, dann kann man das ganze richtig fein nutzen.

Nocheinmal ein dickes Dankeschön an sclearscreen, denn ohne ihn wäre ich nicht auf diese Fährte gekommen.

mfg
Hellsgore

Danke jetzt bin ich aber stolz! Soviel Ehre jetzt bin ich ganz verlegen...

Ich opfere hier gern Zeit sitze gerade wieder bei meiner Weiterbildung,
momentan ist Selbststudium angesagt. Na denn, ach was Zeit schliesslich lernt man nie aus bei der Sache.

mfg aus Erfurt

ich hoffe Du bist mir nicht böse habe mir den Code mit Cut/Paste mal geholt
und nach VB. Net umgeschreiben sieht sehr interessant aus

[b]Imports[/b] System
[b]Imports[/b] System.Windows.Forms
[b]Imports[/b] System.ComponentModel

<ProvideProperty("MyProperty", "Control")> _
 [b]Public Class[/b] DynamicPropertyExtenderForComponents
  [b]Inherits[/b] Component
  [b]Implements[/b] IExtenderProvider

  [b]Protected[/b] ciMine [b]As Boolean[/b] = [b]False[/b]
  ' Provides the Get portion of MyProperty.
  [b]Public Function[/b] GetMyProperty([b]ByVal[/b] myControl [b]As[/b] Control) [b]As Boolean[/b]

    ' Insert code here. 
    [b]Return[/b] ciMine
  [b]End Function[/b]

  ' Provides the Set portion of MyProperty. 
  [b]Public Sub[/b] SetMyProperty([b]ByRef[/b] myControl [b]As[/b] Control, [b]ByVal[/b] value [b]As[/b] String)

    ' Insert code here. 
  [b]End Sub[/b]

  ' When you inherit from IExtenderProvider, you must implement the 
  ' CanExtend method. 
  [b]Public Function[/b] CanExtend([b]ByVal[/b] target [b]As Object[/b]) [b]As Boolean Implements[/b] IExtenderProvider.CanExtend
  ' aha da du diese Klasse in nem Projekt instanzieren kannst
  ' bekommt man dort dan zur Entwurfszeit die Instanz dieser Klasse
  ' im Editor der IDE auswählen um CanExtend - Methode zu überschreiben
  ' um dort den Tooltip zu setzen, hmm schön dann kann ich in dieser  
  ' Überschrieben Methode im Projekt das ganz Tooltip - Gedönse abhandeln  
  ' schhönes Ding dies ist
  [b]End Function[/b]

  ' Insert additional code here
[b]End Class[/b]

Ich hoffe Du hast nischt dagegen sowas kann man immermal irgendwo gebrauchen!

mfg sclearscreen

goil Du bekomst beim Überladen sogar alle Kommentare mit rein
durch diese Anweisung die der Klasse vorangestellt ist:

<ProvideProperty("MyProperty", "Control")> _
[b]Public Class[/b] ToolTipSticker .... [b]end Class[/b]

sclearscreen schrieb:

goil Du bekomst beim Überladen sogar alle Kommentare mit rein
durch diese Anweisung die der Klasse vorangestellt ist:
<ProvideProperty("MyProperty", "Control")> _
[b]Public Class[/b] ToolTipSticker .... [b]end Class[/b]

Man sollte ich denke ich diese Klasse so nennen:

***DynamicPropertyExtenderForComponents

ich editiers mal gleich in meinem vorherigen Beitrag bin gleich wieder hier ....
mfg sclearscreen

hmm also ich denke man könnte diesen Beitrag als nützlich betrachten
Vielleicht schiebt den dann bitte von Euch einer in den FAQ zu
.NET - Angelegenheiten. Hmm gibts eigentlich schon nenspezielles FAQ
für .NET? *grübel*

Hellsgore

Servus,

nene, kein Problem dafür ist er ja auch da.
Du kannst dem Ding auch noch das Attribute "Description" verpassen. Dann bekommste du im Designer noch eine schöne Erklärung dazu *g*. Das Beispiel steht so ähnlich in der MSDN und dort gibts das auch direkt in VB

mfg
Hellsgore

Hellsgore schrieb:

Servus,

nene, kein Problem dafür ist er ja auch da.
Du kannst dem Ding auch noch das Attribute "Description" verpassen. Dann bekommste du im Designer noch eine schöne Erklärung dazu *g*. Das Beispiel steht so ähnlich in der MSDN und dort gibts das auch direkt in VB

mfg
Hellsgore

hmm und ich mach mir die arbeit es umzuschreiben
egal das bringt Praxis für später. Jedenfalls hätte ich das Ding nicht gefunden
och ich mag dieses Forum gemeinsamer Gehirnschmalz bringt echt was