User Control mit Referenz auf statische Klasse

Hallo,

ich entwerfe aktuell User Controls zur Realisierung einer Grundlage zur Maschinenvisualisierung.
Die Eigenschaften der User Controls sollen komplett über die Eigenschaftsfenster bzw. Propertygrid zur Entwurfszeit definiert werden.

Beispiel:
Viele Controls verfügen über die Eigenschaft UserLevel und CurrentUserLevel, um ein enable erst bei CurentUserLevel ≥ UserLevel zu erreichen.
Damit die Eigenschaft CurrentUserLevel bereits im Design festgelegt werden kann, binde ich das CurrentUserLevel an eine Variable aus der Anwendungskonfiguration.
Wird das User Level geändert, bekommt das Control dieses im Design und zur Laufzeit mit.

In die eine Richtung funktioniert das ganz gut(also für alle Listener). Letztendlich muss ich aber über ein Control ein Login realisieren. Hier ist aber die Bindung an die Anwendungskonfig. nur eine Einbahnstraße.

Dies soll nur ein Beispiel sein, das Problem habe ich bei vielen anderen Controls die auf einen "Datenstamm" schauen und schreiben.

Klar kann man den Controls irgend ein Object mitgeben, da sind wir aber bei einer Zeile Code.
Ziel ist, wie bereits erwähnt, eine Parametrierung zur Design Zeit im Eigenschaftsfenster des Controls und keine Programmierung.

Ich würde mich über eure kreativen Ideen freuen!

Gruß

Hab ich jetzt nicht ganz verstanden, vor allem das hier:

In die eine Richtung funktioniert das ganz gut(also für alle Listener). Letztendlich muss ich aber über ein Control ein Login realisieren. Hier ist aber die Bindung an die Anwendungskonfig. nur eine Einbahnstraße.

und das:

Klar kann man den Controls irgend ein Object mitgeben, da sind wir aber bei einer Zeile Code.

Ein UserControl ist eine Komponente, die sollte möglichst unabhängig von anderen Komponenten und wiederverwendbar sein. Da direkt auf die Anwendungskonfiguration zuzugreifen finde ich etwas suboptimal. Es muss nicht unbedingt schlecht sein, vielleicht brauchst du auch nie was anderes, aber ich würde mit sowas möglichst erst gar nicht anfangen.
Ich hab jetzt zwar nicht ganz verstanden, was du willst, aber ich könnte mir vorstellen, dass man alle externen Daten (z.B. das was du jetzt aus der Appconfig ziehst) in einer entsprechenden Klasse kapseln könnte. Die kannst du auch im Designer konfigurieren, dazu brauchst man keinen Code schreiben. Du kannst für jede Eigenschaft einen eigenen Editor für das Property Grid definieren. Denk z.B. an die Konfiguration vom Binding. So ähnlich würde man zuerst eine Daten- oder Konfigurationsquelle für dein UserControl einstellen und könnte dann weitere Einstellungen vornehmen.

Hi Coder007,

dann versuche ich es mal anders.
Ich habe mehrere User Controls die alle auf eine bestimmte "globale" Eigenschaft zugreifen sollen.
Dieses Objekt ist bei Erstellung des UserControls noch nicht bekannt.
Erst wenn die Controls vom Programmierer genutzt werden, sollen diese Objekte zugewiesen werden.
Die Zuweisung im PropertyGrid des UserControls.

Ein Bildchen im Anhang.

Um beim CurrentUserLevel zu bleiben habe ich ein Control UserControl_PasswordAdministration und ein Control UserControl_Login.

Als erste Idee habe ich den Wert CurrentUserLevel, vom UserControl_PasswordAdministration, an die Anwendungseinstellung gebunden (siehe Bild). Das klappt auch alles soweit.
Wenn ich den Wert in den Anwendungseinstellungen irgendwo setze, bekommt das UserControl_PasswordAdministration den Wert mit und ich kann im Setter darauf reagieren.

private void btnLevel0_Click(object sender, EventArgs e)
        {
            Properties.Settings.Default.CurrentUserLevel = 0;
            
        }

Alles schön gekapselt und per Clicki Clicki im PropertyGrid zu lösen.

Jetzt will ich den Wert

CurrentUserLevel

aus den Anwendungseinstellungen aber im anderen Control UserControl_Login zur Laufzeit schreiben, aber unter Berücksichtigung deiner Aussage

Ein UserControl ist eine Komponente, die sollte möglichst unabhängig von anderen Komponenten und wiederverwendbar sein.

aber ich könnte mir vorstellen, dass man alle externen Daten (z.B. das was du jetzt aus der Appconfig ziehst) in einer entsprechenden Klasse kapseln könnte. Die kannst du auch im Designer konfigurieren, dazu brauchst man keinen Code schreiben. Du kannst für jede Eigenschaft einen eigenen Editor für das Property Grid definieren. Denk z.B. an die Konfiguration vom Binding. So ähnlich würde man zuerst eine Daten- oder Konfigurationsquelle für dein UserControl einstellen und könnte dann weitere Einstellungen vornehmen.

Das liest sich ja nicht schlecht. Prinzipiell ist mir das CallByReference eines Objektes klar. Also ein Objekt an das alle anderen Controls "gebunden" werden. Ich finde aber nach tagelanger Recherche nicht heraus wie ich eine Instanz eines Objektes nur im Designer erzeuge (ähnlich BindingSource, Timer...) das dann als Einstellung im PropertyGrid meiner Controls wiederzufinden ist.
Einen Schritt weiter muss dieses "globale Objekt" aber auch später in allen verwendeten Formularen zur Verfügung stehen. Deswegen als erster Schnellschuss das Konfigurationsmodell.

Ich hoffe, du konntest mich jetzt verstehen 😉

Bildchen der Bindung zu den Konfigurationsdateieinstellungen...

Ich finde aber nach tagelanger Recherche nicht heraus wie ich eine Instanz eines Objektes nur im Designer erzeuge (ähnlich BindingSource, Timer...) das dann als Einstellung im PropertyGrid meiner Controls wiederzufinden ist.

Du hast ja schon das Browsable Attribut verwendet. Es gibt noch zig weitere Attribute, die vom Property Grid ausgewertet werden. Ich hab früher recht viel damit gemacht, ist aber auch schon eine Weile her. Eine Klasse, die ich jetzt gefunden habe, ist UITypeEditor. Such mal danach, du findest bestimmt genug Infos. Im Prinzip muss man eine Klasse erstellen, die davon ableitet, und dann bei der Eigenschaft den Editor angeben:

EditorAttribute Klasse

Damit alle Controls auf dieselbe Instanz gehen, wirst du wohl mit einem Singleton arbeiten müssen. Ist vielleicht auch nicht so schön, wie Code Injection, aber in dem Fall seh ich jetzt eigentlich keine andere Möglichkeit...

Hallo meldano,

scheint mir im Kern ein ähnliches Problem zu sein, wie in User Control: Eigenschaften aus Eigenschaftsfenster zuordnen.

herbivore

Hallo herbivore,

leider nur im Kern des Kerns 😉
M.m.n. setzt meine neue Aufgabenstellung nicht nahtlos an das alte Thema an.
Deswegen der neue Thread.

Gruß

Hallo meldano,

wo genau siehst du die Unterschiede? Welche Teile deiner Frage sind noch nicht durch den anderen Thread beantwortet?

herbivore

wo genau siehst du die Unterschiede? Welche Teile deiner Frage sind noch nicht durch den anderen Thread beantwortet?

Also ist hier auch das Mittel der Wahl über Reflection zu arbeiten?

Edit:

Das hier kommt dem Ganzen ganz nah:

Objekt aus MainForm in usercontrol nutzen?

Zitat von Svenson:

Wann soll dein Objekt an das UserControl "gebunden" werden. Bei den DB-Komponenten kannst du ja z.B. die Connection mit dem Provider, bzw. den Provider mit dem DataSet über den Editor in Studio "verbinden" (Bindung zur Designzeit). Hier muss der Weg über Reflection gegangen werden.

Genau das möchte ich:

Eine andere Variante wäre Reflection. Den Weg geht z.B. das DataBinding oder die diversen UI-Provider. Damit hätte man auch die Möglichkeit, das Objekt im PropertyEditor auszuwählen.

Und hier fehlt mir der Denkanstoß wie ich das umsetzen kann.

Hallo meldano,

was Reflection selbst angeht könnte ich dir vermutlich schon weiterhelfen (falls das dein Problem ist, konkretisiere deine Frage bitte), aber ich kenne mich leider sehr wenig damit aus, was der Designer kann bzw. wozu man ihn überreden kann und wozu nicht. Da müsste wohl einer der anderen Helfer in die Bresche springen.

herbivore

Genau das möchte ich:

Eine andere Variante wäre Reflection. Den Weg geht z.B. das DataBinding oder die diversen UI-Provider. Damit hätte man auch die Möglichkeit, das Objekt im PropertyEditor auszuwählen.

Du kannst jeden beliebigen (eigenen) Editor verwenden, indem die EditorAttribute Klasse verwendest, wie Coder007 bereits vorgeschlagen hatte.

Andererseits verstehe ich beim besten Willen nicht, was du eigentlich vor hast. Du möchtest zur Designzeit Werte aus der Anwendungskonfiguration auswählen können? Oder auch editieren? Was ist denn ein CurrentUserLevel? Ist das ein Wert, den du änderst, um das gleiche Programm als Admin-Tool mit zusätzlichen Berechtigungen auszuliefern? Beschreib uns lieber mal kurz und knapp, was du eigentlich vorhast. Am Ende findet sich bestimmt eine wesentlich einfachere Lösung als bisher.

Christian

Hallo Christian,

Andererseits verstehe ich beim besten Willen nicht, was du eigentlich vor hast. Du möchtest zur Designzeit Werte aus der Anwendungskonfiguration auswählen können? Oder auch editieren? Was ist denn ein CurrentUserLevel? Ist das ein Wert, den du änderst, um das gleiche Programm als Admin-Tool mit zusätzlichen Berechtigungen auszuliefern? Beschreib uns lieber mal kurz und knapp, was du eigentlich vorhast. Am Ende findet sich bestimmt eine wesentlich einfachere Lösung als bisher.

Das CurrentUserLevel ist nur EIN Beispiel, ein User Level zur Laufzeit der endgültigen Anwendung in der die Controls genutzt werden.
Jedem Benutzer ist ein UserLevel von 0...9 zugeordnet. Das CurrentUserLevel entspricht dem Level des gerade angemeldeten Benutzers zur Laufzeit.

Programm wird gestartet,
Benutzer meldet sich mit Passwort über ein Control an,
Controls sind zur Benutzereingabe entsprechend UserLevel aktiv/deaktiv,
...
Benutzer meldet sich wieder ab,
anderer Benuteer meldet sich an
...

Es gibt eine Menge Controls, die den aktuellen Level kennen müssen, da z.B. ein enable einer Textbox von einem Min User Level abhängig ist.

Die Administration der UserLevel, das Login, EingabeControls usw. müssen das aktuelle Level lesen und im Falle eines Login oder Logout auch schreiben können.

Die Herausforderung ist eben, dem Designer mitzuteilen, dass im Eigenschaftsfenster der Controls eine Referenz auf ein Objekt mitgegeben wird. Dies könnte auch ein Verweis einer statischen Klasse sein die im Design bereits entworfen wurde.

In der klassischen Programmierung eben als globale Variable, nur hier kennen die fertigen Controls erst zur Designzeit die Datenquelle durch Konfiguration aus dem PropertyGrid vom UserControl.

Ich hoffe das war jetzt verstädlich genug.

Gruß

Hi Herbi,

was Reflection selbst angeht könnte ich dir vermutlich schon weiterhelfen (falls das dein Problem ist, konkretisiere deine Frage bitte), aber ich kenne mich leider sehr wenig damit aus, was der Designer kann bzw. wozu man ihn überreden kann und wozu nicht. Da müsste wohl einer der anderen Helfer in die Bresche springen.

Was Reflection angeht komme ich klar, danke.
Wenn ich bei meinem Lösungsansatz mit der statischen Klasse bleibe, ist es ja ein leichtes alle in der Solution vorhandenen static Klassen auf Ihre Felder zu überprüfen und / oder aufzulisten.

Wenn die static Klasse ein static Field "CurrentUserLevel" enthält, ist auch ein schreiben oder lesen per Reflection möglich.

Jetzt brauche ich nur noch einen eigenen Editor im ProperyGrid der mir die static Klassen mit gerade genanntem Feld anbietet...

Die Lösung ???

Hallo meldano,

das das PropertyGrid anzeigt, bestimmt das Objekt, das an das PropertyGrid gebunden ist, über Attribute. Wenn man eine selbstgefüllte DropDownList oder einen eigenen Editor für eine Property haben will, geht das recht einfach. Hier ein Beispiel:

using System;
using System.Drawing;
using System.Drawing.Design;
using System.ComponentModel;
using System.Windows.Forms;
using System.Windows.Forms.Design;

//*****************************************************************************
public class ExampleWindow : Form
{
   //--------------------------------------------------------------------------
   private PropertyGrid optionsPropertyGrid1;

   //==========================================================================
   public ExampleWindow ()
   {
      Text = "Beispiel-Fenster";
      ClientSize = new Size (600, 400);
      optionsPropertyGrid1 = new PropertyGrid ();
      optionsPropertyGrid1.Dock = DockStyle.Fill;
      TextClass tc = new TextClass ();
      optionsPropertyGrid1.SelectedObject = tc;
      Controls.Add (optionsPropertyGrid1);
   }
}

//*****************************************************************************
public class TextClass
{
   //--------------------------------------------------------------------------
   private String _normalText = @"<normaler Text>";
   private String _shortText = @"<kurzer Text>";
   private String _wideText = @"<langer Text>";

   //==========================================================================
   public String NormalText
   {
      get { return _normalText; }
      set { _normalText = value; }
   }

   //==========================================================================
   [TypeConverter (typeof (ShortTextDropDown))]
   public String ShortText
   {
      get { return _shortText; }
      set { _shortText = value; }
   }

   //==========================================================================
   [Editor (typeof (WideTextEditor), typeof (UITypeEditor))]
   public String WideText
   {
      get { return _wideText; }
      set { _wideText = value; }
   }

}

//*****************************************************************************
public class ShortTextDropDown: StringConverter
{
   //==========================================================================
   public override bool GetStandardValuesSupported (ITypeDescriptorContext context)
   {
      return true;
   }

   //==========================================================================
   public override bool GetStandardValuesExclusive (ITypeDescriptorContext context)
   {
      return true;
   }

   //==========================================================================
   public override StandardValuesCollection GetStandardValues (ITypeDescriptorContext context)
   {
      return new StandardValuesCollection (new string [] { "Text1",
                                                           "Text2",
                                                           "Text3"});
   }
}

//*****************************************************************************
public class WideTextEditor : UITypeEditor
{
   //==========================================================================
   public override UITypeEditorEditStyle GetEditStyle (ITypeDescriptorContext context)
   {
      return UITypeEditorEditStyle.Modal;
   }

   //==========================================================================
   public override Object EditValue (ITypeDescriptorContext context,
                                     IServiceProvider provider,
                                     Object value)
   {
      IWindowsFormsEditorService service
         = (IWindowsFormsEditorService)provider.GetService (typeof (IWindowsFormsEditorService));

      WideTextForm form = new WideTextForm ();
      form.WideText = (String)value;
      service.ShowDialog (form);
      return form.WideText;
   }
}

//*****************************************************************************
public class WideTextForm : Form
{
   //--------------------------------------------------------------------------
   private TextBox _tbxWide;

   //==========================================================================
   public WideTextForm ()
   {
      Control ctrlCurr;

      Text = "Text bearbeiten";
      ClientSize = new Size (600, 800);
      ctrlCurr = _tbxWide = new TextBox ();
      ctrlCurr.Dock = DockStyle.Fill;
      ((TextBox)ctrlCurr).Multiline = true;
      Controls.Add (ctrlCurr);
   }

   //==========================================================================
   public String WideText
   {
      get { return _tbxWide.Text; }
      set { _tbxWide.Text = value; }
   }
}

//*****************************************************************************
public static class App
{
   //==========================================================================
   [STAThread]
   static void Main (String [] astrArgs)
   {
      Application.Run (new ExampleWindow ());
   }
}

Durch das Attribut [TypeConverter (typeof (ShortTextDropDown))] erscheint hinter dem Wert ein Button mit deinem Dreieck nach unten ("v"), der die DropDownList für die Property öffnet.

Durch das Attribut [Editor (typeof (WideTextEditor), typeof (UITypeEditor))] erscheint hinter dem Wert ein Button mit drei Punkten ("..."), der den Editor für das Property öffnet.

Bitte schreib, ob das auch für das PropertyGrid im Visual Studio Designer funktioniert.

herbivore

Hallo Herbi,

super, funktioniert im VS Designer!

So kann ich mir schön mit Reflection die entsprechenden statischen Klassen mit dem UserLevel Feld aus der Solution herauspicken und zur Auswahl im Grid zur Verfügung stellen.

Mal so ganz grob:

//Alle static Klassen
            IEnumerable<Type> types = System.Reflection.Assembly.GetExecutingAssembly().GetTypes().Where(t=> t.IsClass && t.IsSealed && t.IsAbstract);;

            List<Type> StaticClassTypesWithUserLevelProperty = new List<Type>();

            //Klassen abklappern
            foreach (Type t in types)
            {
                System.Diagnostics.Trace.WriteLine(t.Name);

               
                System.Reflection.FieldInfo[] fieldAttributes;
                fieldAttributes = t.GetFields();

               
                foreach (System.Reflection.FieldInfo fi in fieldAttributes)
                {
                    System.Diagnostics.Trace.WriteLine(pi.Name);

                    if (fi.Name == "userLevel")
                        StaticClassTypesWithUserLevelProperty.Add(t);

                }


                System.Diagnostics.Trace.WriteLine("-----------------------------------");
           }

Gruß

Wäre das nicht eher was, was man als Plugin realisieren könnte (falls ich richtig verstanden habe, was Du haben willst - bin nicht sicher) ?

Du willst doch zur Designzeit angeben können, woher Deine Applikation bestimmte Infos nehmen soll, wobei es sich bei der Quelle um irgendein Klassenobjekt handeln soll, welches aber von Anwendung zu Anwendung austauschbar ist, ja ?

Kannst Du dann nicht die Werte, wie CurrentUserLevel usw. (die sind ja meinem Verständis nach immer dieselben) in einem Interface definieren und dann eine jeweilige anwendungsspezifische Implementierung des Interface beim Design vorgeben ?

Dann bräuchtest Du im Designer nur zwei String-Variablen

AppDataAssemblyPath
AppDataImplementationType

Mit diesen Angaben kann Deine Anwendung dann zur Laufzeit eine Instanz von dem Typ mittels Activator erzeugen, und dieser Typ gibt dann eben konstante Werte zurück.

Wobei sich mir da ehrlich gesagt die Frage stellt, warum man das nicht gleich über eine Konfigurationsdatei macht, in der man dann für jede Anwendung eben die Werte entsprechend vorgibt.

Am meisten wundert mich an der Kontruktion, daß ein Steuerelement hier über die Anwendungslogik Bescheid wissen muß. Normalerweise hat ein Steuerelement einige Zustände, bspw. sichtbar/nicht sichtbar, editierbar/nicht editierbar, und die Anwendung entscheidet, welches Steuerelement sichtbar oder editierbar sein soll. Wenn jetzt (wie offenbar bei dir) das Steuerelement über die Rechteverwaltung deiner Anwendung Bescheid wissen muß, ist meiner Meinung nach irgendwas an der Programmarchitektur nicht ganz in Ordnung.

Christian

Hallo MrSparkle,

ich sehe da kein Problem. Das UserControl muss ja je nach Berechtigung bestimmte Controls en- oder disablen. Es muss also die Berechtigung des Benutzers in irgendeiner Weise kennen. Jetzt geht es nur noch darum, wie es die Information bekommt. Direkt als (bool-)Wert, der Benutzer ist berechtigt oder eben nicht. Oder als UserLevel, damit es selbst vergleichen kann, ob die Berechtigung hoch genug ist. Und wenn das UserControl einen UserLevel bekommt, dann ist es auch kein wesentlicher Unterschied, ob es den UserLevel als (Konstruktor) Parameter, über eine eigene Property oder eben per Reflection aus einer statischen Klasse bekommt, deren Klassennamen es übergeben bekommt. Das ist ja noch lange keine Anwendungslogik.

herbivore

Hi herbivore,

deine Einwände sind sicherlich berechtigt, überzeugen mich aber nicht ganz. Wenn das UserControl anhand eines UserLevels / einer Benutzergruppe entscheiden muß, wie es dargestellt wird, dann ist das für mich Anwendungslogik, die in eine Rechteverwaltung gehört. Spätestens wenn Reflection ins Spiel kommt um das Problem zu lösen, würde ich nach einer (objektorientierteren) Alternative suchen.

Christian

Hallo MrSparkle,

streng genommen ist ein Vergleich von IST- und SOLL-Level schon Anwendungslogik. Praktisch gesehen finde ich es hier in Ordnung. Problematisch würde es erst, wenn man später komplexere Bedingungen braucht würde. Aber es steht eben KISS gegen eine womöglich nie gebrauchte (=YAGNI) Flexibilität.

Ich stelle mir es so vor, dass alles vom Entwickler vorgegeben wird. Er bindet zur Entwicklungszeit an die Controls die jeweils passenden IST- und SOLL-Level-Quellen.

Hierfür Reflection zu benutzen, sehe ich als vollkommen unproblematisch. Das ist ja eine Infrastrukturaufgabe.

Dass in der Konsequenz dann auch zur späteren Laufzeit Reflection nötig ist, um die vorgegebene Bindung zu etablieren, liegt in der Natur der Sache und ist auch bei normalen DataBinding nicht anders. Insofern ist das also schon fast ein klassischer Fall für den Einsatz von Reflection.

herbivore

Ich stelle mir es so vor, dass alles vom Entwickler vorgegeben wird. Er bindet zur Entwicklungszeit an die Controls die jeweils passenden IST- und SOLL-Level-Quellen.

Genau darum geht es! Deswegen passt die Lösung auch.

Ich habe die Funktion wie hier dargestellt implementiert.

Falls jeman in Zukunft nach etwas Ähnlichem sucht, hier mal ein schönes Beispiel für eigene, von UITypeEditor, abgeleitete Klassen:

How to: Passwort im PropertyGrid

Jetzt steht aber eine weitere Herausforderung im Raum.
Ich schreibe im LoginControl mit Reflection das Feld CurrentUserLevel in der entsprechenden static Klasse.

Jetzt müssen alle Controls, die das currentUserLevel zum Auswerten der Berechtigung benötigen, mitbekommen, wenn sich die statische Variable geändert hat.
Durch Zuweisung des Propertys mit Reflection, spielt der Setter ja bei Änderung der reflektierten Variable (hier mein int) keine Rolle.

Habt Ihr einen Ansatz wie ich das implementieren kann?

Als erste Idee hatte ich einen Timer in den Controls der den Status zyklisch aktualisiert.
Diese Vorgehensweise wirkt aber nicht elegant.

Gruß

Hallo meldano,

Durch Zuweisung des Propertys mit Reflection, spielt der Setter ja bei Änderung der reflektierten Variable (hier mein int) keine Rolle.

wenn du tatsächlich die Property zuweisen würdest, dann würde natürlich auch bei Reflection der Setter ausgeführt werden. PropertyInfo statt FieldInfo.

herbivore

Hast du ein Codebeispiel. Ich arbeite zum erstem mal, ausser zum spielen, mit Reflection.
Zur Zeit arbeite ich mit string properties als fieldname der static klasse.

Gruß

Hallo meldano,

zu Codebeispielen siehe [Hinweis] Wie poste ich richtig? Punkt 4. Und die Klassennamen habe ich schon genannt. Ein weiterer wäre INotifyPropertyChanged.

Jedenfalls geht mit Reflection alles, was normal auch geht.

Und wie man ein eigenes Event schreibt, das bei der Änderung einer Property gefeuert wird, kann man schon zu den Grundlagen zählen. Siehe [FAQ] Eigenen Event definieren.

Damit solltest du aus eigener Kraft weiterkommen.

herbivore

O.K.
Ich habe nicht nach kompletten Code gefragt. Nach stundenlangem Lesen von Anwendungsbeispielen im Reflection Context ist mir nicht klar, wie die "Listener Controls" mitbekommen sollen das sich ein Property ämdert wenn sie nur über den Type und Fieldname als string bescheid wissen.
Auch Events nutzen tut mir nicht weh 😉

Anhand der genannten Schlagwörter werde ich es wol herausfinden...

Hallo meldano,

wenn sie nur über den Type und Fieldname als string bescheid wissen.

statt eines Feldes ist es besser, eine Property zu verwenden. Das habe ich ja schon oben angedeutet.

Wenn die statische Klasse außer der Property auch noch ein zugehöriges Event hat, also z.B. zu UserLevel auch noch UserLevelChanged, dann kannst du das Event doch problemlos per Reflection abonnieren.

Ich denke, wir kommen jetzt in den Bereich von [Hinweis] Wie poste ich richtig? Punkt 1.1.1 und 1.2.

herbivore