C#, Delegaten von Events

[Tim S. (Firma: tsx89) (freak_ts)]

Hallo,
Ich möchte Objekte zur Laufzeit Konvertieren. z.B. von Label zu 
Button, oder Class1 zu Class2. Dabei sollen alle gleichen Member 
(Felder, Propertys, usw) in einer Schleife übernommen werden. Das klappt 
auch ganz gut. Allerdings komme ich bei den Events nicht mehr weiter, 
und hänge bereits ca eine Woche an diesem Punkt fest.

Es sollen alle "registrierten und möglichen Events" der Class1 später 
von der konvertierten Class2 aufgerufen werden können. Diese Events 
(und alle anderen Member) sollen von "Außen" abgefragt werden 
(Konvertierungs-Klasse), also nicht dort, wo die Class1 Instanz liegt. 
Alle Member und Klassen, auch die Methoden sind Public. Müsste ja 
eigentlich gehen!

Ich bekomme eine Liste der benutzen Delegaten (die Methoden der Events) 
eines Objektes:  ...

Class1 Class1 = new Class1();
EventHandlerList events = (EventHandlerList)Class1.GetType().GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Class1, null);

...Jedoch kann ich diese nicht mehr den Events zuordnen. Dort stehen 
dann wirklich NUR die Delegaten/Methoden, und der 
EventHandlerList.Key-Property ist immer leer!?? Mittlerweile ist es ein 
ebiges hin und her mit diversen Snippets, und leider finde ich keinen 
Weg.

Ich bräuchte als Result etwa so was:

-Object: Class1
-EventList:
  -EventInfo Click, Delegate ClickHandlerMethod
  -EventInfo MouseMove, Delegate MoveHandlerMethod
  -EventInfo AbcEvent, Delegate AbcHandlerMethod,

...Also ich bräuchte einen Delegate oder MethodInfo passend zur 
Eventinfo zur Laufzeit. Dann kann ich diese auf der Class2 anwenden 
bzw. anmelden. Kann mir jemand weiterhelfen?

Gruß, tsx

[Tim S. (Firma: tsx89) (freak_ts)]

So sieht das bisher ungefähr aus:

Propertys:

public static Boolean MappingProperty(Object Source, Object Dest, String PropertyName)
{
  Boolean Done = false;
  if (Source != null && Dest != null && PropertyName != String.Empty)
  {
    PropertyInfo SourceInfo = Source.GetType().GetProperty(PropertyName);
    PropertyInfo DestInfo = Dest.GetType().GetProperty(PropertyName);
    if (SourceInfo != null && DestInfo != null && SourceInfo.PropertyType == DestInfo.PropertyType && SourceInfo.CanRead && DestInfo.CanWrite)
    {
      DestInfo.SetValue(Dest, SourceInfo.GetValue(Source));
      Done = true;
    }
  }
  return Done;
}

Felder:

public static Boolean MappingField(Object Source, Object Dest, String FieldName)
{
  Boolean Done = false;
  if (Source != null && Dest != null && FieldName != String.Empty)
  {
    FieldInfo SourceInfo = Source.GetType().GetField(FieldName);
    FieldInfo DestInfo = Dest.GetType().GetField(FieldName);

    if (SourceInfo != null && DestInfo != null && SourceInfo.FieldType == DestInfo.FieldType)
    {
      DestInfo.SetValue(Dest, SourceInfo.GetValue(Source));
      Done = true;
    }
  }
  return Done;
}

Aber wie mache ich das bei den Events?:

public static Boolean MappingEvent(Object Source, Object Dest, String EventName)
{
  Boolean Done = false;

  // WTF!?

  return Done ;
}

Ich würde auch belohnen! Bierchen oder sowas. Ist Mega-Wichtig!

[Monomops (Gast)]

Tim S. schrieb:
> Ich bräuchte als Result etwa so was:
> -Object: Class1
> -EventList:
>   -EventInfo Click, Delegate ClickHandlerMethod
>   -EventInfo MouseMove, Delegate MoveHandlerMethod
>   -EventInfo AbcEvent, Delegate AbcHandlerMethod,

Meinst du etwas in dieser Richtung?

namespace Bla
{
  class Foo
  {
    public event EventHandler EventW;
    public event EventHandler EventX;
    public event EventHandler EventY;
    public event EventHandler EventZ;

    public Foo()
    {
      EventW += Foo_x;
      EventX += Foo_y;
    }

    public void Foo_x(object sender, EventArgs e) {}
    public void Foo_y(object sender, EventArgs e) {}
  }

  class Program
  {
    static void Main(string[] args)
    {
      var foo = new Foo();

      foo.EventY += MyHandler;
      foo.EventZ += (s, e) => { };

      var events = foo.GetType().GetEvents();
    
      foreach (var ev in events)
      {
        FieldInfo fi = foo.GetType().GetField(ev.Name, BindingFlags.NonPublic | BindingFlags.Instance);
        Delegate del = (Delegate)fi.GetValue(foo);
        var invocationList = del.GetInvocationList();
        foreach (var d in invocationList)
        {
          Console.WriteLine("{0}, {1}, {2}", ev.Name, d.Target, d.Method.Name);
        }
      }
    }

    private static void MyHandler(object sender, EventArgs e) { }
  }
}

[Tim S. (Firma: tsx89) (freak_ts)]

Monomops schrieb:
>

FieldInfo fi = foo.GetType().GetField(ev.Name, BindingFlags.NonPublic | BindingFlags.Instance);
Delegate del = (Delegate)fi.GetValue(foo);

Genau das habe ich auch mehrfach gefunden und getestet. FieldInfo fi ist 
immer null.

Tim S. schrieb:
> Diese Events und alle anderen Member sollen von "Außen" abgefragt werden

...also von einer Converter-Klasse! (ConvertFooBarBaz)
Eventuell geht das doch nicht!?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace Bla
{
    // Klassen, dessen Member-Inhalte zu "konvertieren" bzw zu übernehmen sind.
    // Verschiedene Klassen, mit den selben Member-Namen und Typen (vererbt!)
    // z.B bei allen Controls, Usercontrols: "BackColor".

    // Foo:
    public class Foo
    {
        public const String Const = "Das ist Foo";
        public String String = "Der Foo String";
        public int Number = 1;
        public String DerFooMember = "Foo";
        public event EventHandler EventX;
        public event EventHandler EventY;

        public void X()
        {
            EventX?.Invoke(this, new EventArgs());
        }
        public void Y()
        {
            EventY?.Invoke(this, new EventArgs());
        }
    }

    // Bar:
    // Das selbe wie Foo, nur "anders" parametriert.
    public class Bar
    {
        public const String Const = "Das ist Bar";
        public String String = "Der Bar String";
        public int Number = 2;
        public String DerBarMember = "Bar";
        public event EventHandler EventX;
        public event EventHandler EventY;

        public void X()
        {
            EventX?.Invoke(this, new EventArgs());
        }
        public void Y()
        {
            EventY?.Invoke(this, new EventArgs());
        }
    }


// *************************************************************

    // Mögliche Inhalte zwischen den Klassen austauschen.
    public static class ConvertFooBarBaz
    {
        public static void MappingProperty(Object Source, Object Dest, String PropertyName) { }  // Siehe Post 2
        public static void MappingField(Object Source, Object Dest, String FieldName) { }        // Siehe Post 2
        public static void MappingEvent(Object Source, Object Dest, String EventName)  // Die eigentliche Frage
        {
            // ?????? How to do this!?
        }

        // Diese Funktion soll das für alle Member-Typen gemeinsam machen:
        public static Boolean MappingObject(Object Source, Object Dest)
        {
            foreach (PropertyInfo pi in Source.GetType().GetProperties())
            {
                MappingProperty(Source, Dest, pi.Name);
            }
            foreach (FieldInfo fi in Source.GetType().GetFields())
            {
                MappingField(Source, Dest, fi.Name);
            }
            foreach (EventInfo ev in Source.GetType().GetEvents())
            {
                MappingEvent(Source, Dest, ev.Name);
            }
            return true; //return Done;
        }
    }

// *************************************************************

    class Program
    {

        static void Main(string[] args)
        {
            Foo foo = new Foo();
            foo.EventX += MyHandler;
            foo.EventY += (s, e) => { };
            // Soweit so gut;


            Bar bar = new Bar();

            // Events und alle anderen Member sollen von "Außen" abgefragt werden (*1)
            // (ConvertFooBarBaz-Klasse), und nicht hier im MainCode, in dem die Foo Instanz liegt.

            ConvertFooBarBaz.MappingObject(foo, bar);

            // nun sollte Bar folgende Werte angenommen haben:
            // bar.Const = "Das ist Bar";      // Bleibt Const;
            // bar.String = "Der Foo String";  // (war vorher "Der Bar String");
            // bar.Number = 1;                 // (war vorher 2);
            // bar.DerBarMember = "Bar";       // Bleibt unverändert, da eigener PropertyName von bar;
            // bar.EventX;                     // ist nun bei MyHandler "angemeldet";
            // bar.EventY;                     // ist nun bei emptyFx => { }  "angemeldet";


            Parent.Controls.Remove(foo);
            foo.Dispose();
            // ... mit "bar" weitermachen, das die Werte von "foo" angenommen hat....
            Parent.Controls.Add(bar);
        }

        // alle Handler müssen daher(*1) auch public sein (???) !!!    
        public static void MyHandler(object sender, EventArgs e) { }
    }
}

Es ist kein "konvertieren" oder "mappen" im eigentlichen Sinne, sondern 
lediglich das Übernehmen der einzelnen Werte auf ein anderes Objekt. Es 
fehlen nur noch die Events. Hoffentlich ist verständlich was ich meine. 
Habe das grob reduziert!

Bestimmt gibt es das auch schon irgendwo als Snippet im Netz? Ich finde 
jedoch gar nichts. Wonach soll ich eigentlich suchen!?
Danke für die Hilfe! tsx

[Frank L. (frank_l)]

Hallo,

schau Dir das mal näher an. Ich kann Dir allerdings nicht sagen, ob das 
Teil auch Events kopiert.

http://circlesandcrossesblogarchive.blogspot.de/2008/01/extension-methods-for-copying-or.html

Gruß
Frank

[Tim S. (Firma: tsx89) (freak_ts)]

Ich habe versucht die Methode von Monomops zu verwenden
FieldInfo fi = foo.GetType().GetField(ev.Name, BindingFlags ...);
FieldInfo fi = foo.GetType().GetField("Event"+ ev.Name, BindingFlags ... 
);

Was der Compiler an Feldern pro Event baut weiß ich noch nicht, und auch 
nicht wie ich darauf zugreifen kann...
FeldInfos sind wie gesagt immer null!!

Ich habe versucht die Eventhandler mit Attributen zu finden.
z.B. Die Methode ClickHandler mit einem ClickHandlerAttribute schmücken.
Bringt aber nichts, gefällt mir nicht und schaff ich auch gar nicht 
erst. Jede Funktion bräuchte eine eigene Attribute und das ist 
Schwachsinn und viel zu statisch für das Projekt.

Ich überlege mir eine Art Liste aufzubauen, die darüber bescheid weiß, 
welches Event zu welchen Delegaten und Handler gehört. Diese wird dann 
zur Laufzeit erweitert oder verändert.

Tim S. schrieb:
> Wonach soll ich eigentlich suchen!?
Event Publisher/Subscriber Pattern anscheinend.

Jedoch denke ich, dass es oben genannten Snippet schon fertig gibt, es 
ist doch bestimmt wichtig mal Class1 nach Class2 zu "wandeln"!? Warum 
gibt es das nicht!? Das braucht doch gefühlt jeder Mensch hunderte male 
am Tag! Ohne scheiß! Muss man das mit jeden Member statisch einzeln 
machen!? - Wäre doch ultra schwach von .Net

Hat jemand vielleicht noch einen Tipp???
tsx

Edit:
Frank L. schrieb:
> Gruß
> Frank

Danke, ich schau mal rein!

[Markus (Gast)]

Mal davon abgesehen, dass es sich mir nicht erschließt, welchen Sinn es 
macht, Felder von Label nach Button zu kopieren und dabei auch noch die 
Event-Handler (Verweise auf Programm-Code!) kopieren zu wollen... Wobei 
ich das natürlich nicht verstehen muss... ;-)

Schreibe doch mal ein kleines Test-Programm und schaue dir die erzeuge 
Assembly mit ILDASM an. Das ist ein Tool des DotNet-Frameworks, in dem 
Du den erzeugten IL-Code anschauen kannst. Dort wirst Du recht schnell 
finden, welche "Felder" der C#-Compiler bei Events verwendet.

Grüße
Markus

[Tim S. (Firma: tsx89) (freak_ts)]

Markus schrieb:
> welchen Sinn es macht

Ich baue ein GUI und möchte grad Drag&Drop einbauen bzw vorbereiten. Ich 
suche eine universelle Möglichkeit, um ein Element (z.B) vom TreeView in 
ein Panel zu Draggen - oder von dort aus in ein ToolStrip, (etc...) und 
möchte dessen Eigenschaften auf das neue Controll anwenden 
(konvertieren), ohne alles Statisch machen zu müssen. Das funktioniert - 
nur eben die Events noch nicht.

Markus schrieb:
> schaue dir die erzeuge Assembly mit ILDASM an

Kann das mehr als Reflection zur Laufzeit? Meinst du das vom Win SDK? 
(Lade ich grad runter)

[Frank L. (frank_l)]

Hallo Tim,

versuch es mal damit:

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private bool _initialize = false;
        private void button1_Click(object sender, EventArgs e)
        {
            if (_initialize) return;
            try
            {
                _initialize = true;
                var events = button1.GetType().GetEvents();

                var test = new Button();
                Controls.Add(test);
                var events2 = test.GetType().GetEvents();
                foreach (var eventInfo in events2)
                {
                    EventInfo eventOldInfo = findInEvents(events, eventInfo);
                    if (eventOldInfo != null)
                    {
                        try
                        {
                            //                        var method = eventOldInfo.AddMethod;
                            //                        Delegate handler = Delegate.CreateDelegate(eventOldInfo.EventHandlerType, null, method, false);

                            FieldInfo f1 = typeof (Control).GetField("EventClick",
                                BindingFlags.Static | BindingFlags.NonPublic);
                            PropertyInfo pi = button1.GetType()
                                .GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
                            EventHandlerList list = (EventHandlerList) pi.GetValue(button1, null);

                            PropertyInfo pi2 = test.GetType()
                                .GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
                            EventHandlerList list2 = (EventHandlerList) pi2.GetValue(test, null);
                            list2.AddHandlers(list);
                        }
                        catch (Exception ex)
                        {
                            if (ex == null);
                        }
                    }
                }
            }
            finally
            {
                _initialize = false;
            }
        }

        private EventInfo findInEvents(EventInfo[] events, EventInfo searchEventInfo)
        {
            foreach (var eventInfo in events)
            {
                if (eventInfo.Name == searchEventInfo.Name) return eventInfo;
            }
            return null;
        }
    }

Gruß
Frank

[Frank L. (frank_l)]

Hallo Tim,

und hier die verkürzte Version ohne foreach Schleife.

    public partial class Form1 : Form
    {
        private Button button1;

        public Form1()
        {
            InitializeComponent();
            button1 = new Button {Dock = DockStyle.Top};
            button1.Click += button1_Click;
            button1.Text = "Click mich";
            Controls.Add(button1);
        }

        private bool _initialize = false;
        private void button1_Click(object sender, EventArgs e)
        {
            if (_initialize) return;
            try
            {
                _initialize = true;

                var test = new Button
                {
                    Text = "Kopie",
                    Dock = DockStyle.Left
                };
                Controls.Add(test);
                try
                {
                    FieldInfo f1 = typeof (Control).GetField("EventClick",
                        BindingFlags.Static | BindingFlags.NonPublic);
                    PropertyInfo pi = button1.GetType()
                        .GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
                    EventHandlerList list = (EventHandlerList) pi.GetValue(button1, null);

                    PropertyInfo pi2 = test.GetType()
                        .GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
                    EventHandlerList list2 = (EventHandlerList) pi2.GetValue(test, null);
                    list2.AddHandlers(list);
                }
                catch (Exception ex)
                {
                    if (ex == null);
                }
            }
            finally
            {
                _initialize = false;
            }
        }

    }

Gruß
Frank

[c-hater (Gast)]

Tim S. schrieb:

> Ich baue ein GUI und möchte grad Drag&Drop einbauen bzw vorbereiten. Ich
> suche eine universelle Möglichkeit, um ein Element (z.B) vom TreeView in
> ein Panel zu Draggen - oder von dort aus in ein ToolStrip, (etc...) und
> möchte dessen Eigenschaften auf das neue Controll anwenden
> (konvertieren), ohne alles Statisch machen zu müssen. Das funktioniert -
> nur eben die Events noch nicht.

Das ist doch ausgekochter Schwachsinn hoch drei. Drag&Drop: OK. Elemente 
zwischen verschiedenen "Containern" transferieren: auch OK.

Der Punkt ist aber: die Tatsache, dass "Elemente" zwischen verschiedenen 
"Containern" hin und her transferiert werden, ändert erstmal rein garnix 
an den transferierten Elementen selber, weder an deren Inhalt noch an 
deren Typ (also deren Klasse). Und das muss es auch nicht, denn alles, 
was sich tatsächlich ändert, ist ja die Position im Container oder 
maximal der Container selber.

Dein Problem kann also allenfalls sein, die Elemente an die Ereignisse 
des neuen Containers zu koppeln.

Kannst du dass mal langsam im Rahmen deiner intellektuellen 
Möglichkeiten durchdenken und dann ggf. bestätigen?

Weil: wenn die Antwort "ja" ist, könnte man der Lösung deines Problems 
doch schon sehr viel näher kommen...

[Frank L. (frank_l)]

Geht auch mit einem anderem Control als Ziel:

        private void button1_Click(object sender, EventArgs e)
        {
            var test = new LinkLabel()
            {
                Text = "Kopie",
                Dock = DockStyle.Left
            };
            Controls.Add(test);
            try
            {
                FieldInfo f1 = typeof (Control).GetField("EventClick",
                    BindingFlags.Static | BindingFlags.NonPublic);
                PropertyInfo pi = button1.GetType()
                    .GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
                EventHandlerList list = (EventHandlerList) pi.GetValue(button1, null);

                PropertyInfo pi2 = test.GetType()
                    .GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
                EventHandlerList list2 = (EventHandlerList) pi2.GetValue(test, null);
                list2.AddHandlers(list);
            }
            catch (Exception ex)
            {
                if (ex == null) ;
            }
        }

Gruß
Frank

[Frank L. (frank_l)]

c-hater schrieb:
> Das ist doch ausgekochter Schwachsinn hoch drei. Drag&Drop: OK. Elemente
> zwischen verschiedenen "Containern" transferieren: auch OK.
>
> Der Punkt ist aber: die Tatsache, dass "Elemente" zwischen verschiedenen
> "Containern" hin und her transferiert werden, ändert erstmal rein garnix
> an den transferierten Elementen selber, weder an deren Inhalt noch an
> deren Typ (also deren Klasse). Und das muss es auch nicht, denn alles,
> was sich tatsächlich ändert, ist ja die Position im Container oder
> maximal der Container selber.
>
> Dein Problem kann also allenfalls sein, die Elemente an die Ereignisse
> des neuen Containers zu koppeln.
>
> Kannst du dass mal langsam im Rahmen deiner intellektuellen
> Möglichkeiten durchdenken und dann ggf. bestätigen?
>
> Weil: wenn die Antwort "ja" ist, könnte man der Lösung deines Problems
> doch schon sehr viel näher kommen...

Und Deine Antwort ist an Schwachsinn nicht zu übertreffen. Denk mal 
weiter als Dein Tellerrand, dann fallen Dir wahrscheinlich mehr als ein 
paar Dinge ein, bei denen ein Button auf einmal ein MenueItem sein 
könnte oder sonstiges...

Gruß
Frank

[Tim S. (Firma: tsx89) (freak_ts)]

Frank L. schrieb:
> Hallo Tim,
> und hier die verkürzte Version ohne foreach Schleife.

Joaa genau das brauche ich. Hatte ich zuvor auch schon mehrfach 
gefunden, jedoch funktionierte das nicht wirklich... Das jetzt läuft 
schon besser, und bringt mich erstmal weiter... Dankeschön

Tim S. schrieb:
> Ich habe versucht die Methode von Monomops zu verwenden

FieldInfo fi = foo.GetType().GetField("Event"+ ev.Name, BindingFlags ..);

> FieldInfo fi ist immer null.


Frank L. schrieb:

          ...
             try
             {
                 FieldInfo f1 = typeof (Control).GetField("EventClick",
                     BindingFlags.Static | BindingFlags.NonPublic);
             ...
             }

Auch diese FieldInfo f1 ist hier null, aber anscheinend braucht die eh 
niemand! :-) LOOL

Tim S. schrieb:
> Mittlerweile ist es ein ebiges hin und her mit diversen Snippets

Wie oft ich zuvor beim Debuggen dieser vielen Online-Fetzen abgebrochen 
habe, nur weil diese fi null ist ... AHHRRG! - den ganzen Part danach 
habe ich nicht mehr debuggt oder getestet. Dabei hatte es anscheinend 
schon ansatzweise funktioniert. Jedoch fehlte mir folgende Zeile:

Frank L. schrieb:

list2.AddHandlers(list);

Das löst eigentlich alle Probleme mit einem Schlag! Ich hatte zuvor die 
EventHandlerList in irgendwelche Dictionarys gewandelt, um an die 
Delegaten / MethodInfos zu kommen, und die Events dann alle "manuell" 
dort anzumelden. Deine Zeile macht das alles von alleine! ;-)

c-hater schrieb:
> Weil: wenn die Antwort "ja" ist, könnte man der Lösung deines Problems
> doch schon sehr viel näher kommen...

Frank L. schrieb:
> ...dann fallen Dir wahrscheinlich mehr als ein
> paar Dinge ein, bei denen ein Button auf einmal ein MenueItem sein
> könnte oder sonstiges...

Joaa genau das habe ich gemeint!
Ich stelle mein Code dann hier rein wenn er fitt geworden ist.
Danke an alle und dir Frank!
tsx

[Tim S. (Firma: tsx89) (freak_ts)]

convert.Control(a1, b1);     // Alle Member
convert.Events(a1, b1);         // Events
convert.Fields(a1, b1);         // Felder
convert.Propertys(a1, b1);      // Propertys

Beim "konvertieren" der Felder werden die Events jetzt auch irgendwie 
übernommen. Also eigentlich war´s umsonnst! Trotzdem Danke für jede 
Hilfe.