Dieses Delphi-Event in C#?

[Pseudemys Nelsoni]

Moin,

mal abgesehen davon, dass ich nicht verstehe was delegaten in C# sind, bzw was sie mit Events zu tun haben, geb ich hier einfach mal ein Code-Beispiel von Delphi, dass ich gerne in C# hätte:

Delphi-Quellcode:

TMyMethodPointer = procedure(Int, Int2: Integer);

TMyClass = class(TComponent)
private
  FMyMethodPointer: TMyMethodPointer;
  procedure SomeProc;
published
  property MyEvent: FMyMethodPointer;
end;

...

procedure TMyClass.SomeProc;
begin
  if not (FMyMethodPointer = nil) then
    FMyMethodPointer(2, 5);
end;

Ich möchte also ein Event für mein C# Control haben, dass 2 Integers mit übergibt. Jemand ne Ahnung, wie ich genau DAS Beispiel hier in C# hinbekomme?

[Khabarakh]

Zitat:

Zitat von Pseudemys Nelsoni

mal abgesehen davon, dass ich nicht verstehe was delegaten in C# sind, bzw was sie mit Events zu tun haben, [...]

Na dann würde ich an deiner Stelle unbedingt mal "delegates" im Suchindex des SDKs eingeben.

Code:

.
   public delegate void DoSomethingDelegate(int i1, int i2);
   // oder auch (Object sender, DoSomethingEventArgs e)
    // wäre für Komponenten konformer, aber mehr Schreibaufwand ;)

   public class Foo
   {
      public void Bar()
      {
         OnSomethingHappened(2, 5);
      }

      protected virtual void OnSomethingHappened(int i1, int i2)
      {
         if (SomethingHappened != null)
            SomethingHappened(i1, i2);
      }

      public event DoSomethingDelegate SomethingHappened;
   }

[edit=Phoenix]Code-Tags von C in C# geändert. Bitte auf richtige Sprache achten :) Mfg, Phoenix[/edit]

[Phoenix]

Code:

public delegate void MyEventDelegate(Int32 int1, Int32 int2);

public class TMyClass : Object
{
    public event MyEventDelegate MyEvent; 

    private void SomeProc()
    {
        MyEvent(2, 5);
    }
}

public class Subscriber : Object
{
    public TMyClass myclass;

    public Subscriber()
    {
        myclass = new TMyClass();
        myclass.MyEvent += new MyEventDelegate(onEvent);
    }

    private void onEvent(Int32 a, Int32 b)
    {
        Int32 c = a + b;
    }
}

Und noch ein Edit: Nachtrag: http://www.codeproject.com/csharp/eventdrivenmodel.asp

[Jürgen Thomas]

Hallo,

Zitat:

Zitat von Pseudemys Nelsoni

mal abgesehen davon, dass ich nicht verstehe was delegaten in C# sind, bzw was sie mit Events zu tun haben, geb ich hier einfach mal ein Code-Beispiel von Delphi, dass ich gerne in C# hätte: ...

Das Problem hatte ich auch (ich bin ebenfalls von Delphi 5 auf Delphi 2005 und jetzt auf C# umgestiegen). Du musst Dich in der Tat dringend mit Delegates beschäftigen, weil sie auch anstelle der Methoden-Pointer von Delphi verwendet werden.

Mir hat dabei folgende Lektüre geholfen:

Zitat:

Walter Doberenz, Thomas Gewinnus: Borland Delphi 2005 - Grundlagen, Profiwissen, Kochbuch. Hanser-Verlag 2005, ISBN 3-446-40202-0

Dieses Kochbuch hat m.E. eine erheblich bessere Qualität als die vorherigen Ausgaben und bezieht sich auf NET-Entwicklung mit Delphi. Kapitel 14.1 "Das Microsoft Event Pattern" erläutert den Zusammenhang zwischen Delegates und Events.

Zitat:

Zitat von Khabarakh

Na dann würde ich an deiner Stelle unbedingt mal "delegates" im Suchindex des SDKs eingeben.

Naja, das SDK hilft für die Praxis gerade dann oft wenig, wenn man grundlegende Erläuterungen sucht.

Zu den vorgeschlagenen Codes: Diese sind im Prinzip OK, entsprechen aber nicht den MS-Vorschlägen, nach denen Delegates immer mit EventArgs verbunden werden sollen:

Zitat:

Zitat von Khabarakh

Code:

public delegate void DoSomethingDelegate(int i1, int i2);
   // oder auch (Object sender, DoSomethingEventArgs e)
    // wäre für Komponenten konformer, aber mehr Schreibaufwand ;)

Arbeitsanleitung
Aus Doberenz/Gewinnus (Kochbuch Delphi 2005), einem C#-Lehrbuch und NET-Doku habe ich ein
Verfahren zusammengestellt, das ich als Anlage beigefügt habe.

Viel Erfolg! Jürgen

[Pseudemys Nelsoni]

Danke Leute, :))). Gleich mal schauen.

[Khabarakh]

Zitat:

Zitat von Jürgen Thomas

Zitat:

Zitat von Khabarakh

Na dann würde ich an deiner Stelle unbedingt mal "delegates" im Suchindex des SDKs eingeben.

Naja, das SDK hilft für die Praxis gerade dann oft wenig, wenn man grundlegende Erläuterungen sucht.

Ich glaube du verwechselst das SDK gerade mit der Delphihilfe ;) . Die Kapitel über Delegates und Events sind geradezu sagenhaft ausführlich und lassen wirklich keine Wünsche mehr offen.

Zitat:

Zu den vorgeschlagenen Codes: Diese sind im Prinzip OK, entsprechen aber nicht den MS-Vorschlägen, nach denen Delegates immer mit EventArgs verbunden werden sollen:

Bei Events.

Zitat:

Aus Doberenz/Gewinnus (Kochbuch Delphi 2005), einem C#-Lehrbuch und NET-Doku habe ich ein
Verfahren zusammengestellt, das ich als Anlage beigefügt habe.

Schöne Zusammenfassung (für weitere Informationen gibt es ja immer noch das .Net-SDK), nur ein paar Kleinigkeiten/Anmerkungen:

• Schritt 1:
  • Mit System.EventHandler<TEventArgs> kann man sich das Leben noch ein wenig leichter machen.
  • Code:

    //  Achtung: u.U. sind alle Typen als Klassen zu deklarieren;
            //  aber überall, wo ich es bisher gemacht habe, klappt die implizite Typwandlung

    :?:
  • Typen-Präfixe ("bCancel") sind unüblich, Konstruktorargumente fangen wie Variablen mit einem Kleinbuchstaben an.
• Schritt 2 kann man sich sparen, indem man SharpDevelop und Alt + Einfg benutzt ;) .
• Schritt 3 und 4 können seit 2.0 durch anonyme Methoden ersetzt werden (zusätzlich ist nun das "new XYEventHandler(..." optional), außerdem wird einem hier viel Schreibaufwand durch die IDE abgenommen (#d: automatische Deklaration anonymer Methoden, VS: automatische Deklaration benannter Methoden).

[Pseudemys Nelsoni]

Moin,

ich hab jetzt etliche Tutorials gelesen etc und auch versucht diese Beispiele hier nachzuvollziehen, aber ich verstehe das mit den delegates nicht.

u.a das hier:

Zitat:

myclass.MyEvent += new MyEventDelegate(onEvent);

An sowas kann ich mich bei Delphi nicht erinnern.

Könnte mir jemand mein Beispiel:

Delphi-Quellcode:

TMyMethodPointer = procedure(Int, Int2: Integer); 

TMyClass = class(TComponent) 
private 
  FMyMethodPointer: TMyMethodPointer; 
  procedure SomeProc; 
published 
  property MyEvent: FMyMethodPointer; 
end; 

... 

procedure TMyClass.SomeProc; 
begin 
  if not (FMyMethodPointer = nil) then 
    FMyMethodPointer(2, 5); 
end;

In C# umschreiben, mit gleichen Namen der Klasse/Prozedur usw?

[Chewie]

Der Unterschied zwischen Delphi und C#, also das, was dich verwirrt, dürfte wohl sein, dass Eriegnisse in Delphi technisch gesehen nur Methodenzeiger sind, also Zeiger auf eine Methode.

In C# sind Events eigene Sprachfeatures und deswegen als Multicast eingeführt, d.h. du weißt nicht eine Methode dem Event zu wie in Delphi, sondern mehrere.

Deswegen verwendest du den Operator += und nicht den einfachen Zuweisungsoperator, wie du es in Delphi machen würdest.

[Phoenix]

Ein klein wenig Offtopic: So einen Multicast kann man sich in Delphi recht easy nachbauen:

Delphi-Quellcode:

private
      m_events: array of TNotifyEvent;
public
      procedure RegisterEvent(event: TNotifyEvent);
      procedure UnregisterEvent(Subscriber: TObject);

...

////////////////////////////////////////////////////////////////////////////////
// register event to distributor
////////////////////////////////////////////////////////////////////////////////

procedure TFrmEventTest.RegisterEvent(Event: TNotifyEvent);
begin
   SetLength( m_events, Length(m_events) + 1 );
   m_events[ Length(m_events) - 1 ] := Event;
end;

////////////////////////////////////////////////////////////////////////////////
// unregister event from distributor
////////////////////////////////////////////////////////////////////////////////

procedure TFrmEventTest.UnregisterEvent(Subscriber: TObject);
var
   i: integer;
begin
   for i := 0 to Length(m_events) - 1 do
   begin
      if TMethod(m_events[i]).Data = Subscriber then
      begin
         m_events[i] := m_events[Length(m_events) - 1];
         SetLength(m_events, Length(m_events) - 1);
      end;
   end;
end;


////////////////////////////////////////////////////////////////////////////////
// distribute the event
////////////////////////////////////////////////////////////////////////////////

procedure TFrmEventTest.btnEventClick(Sender: TObject);
var
   i: integer;
begin
   for i := 0 to Length(m_events) - 1 do
      m_events[i](Sender);
end;

Man beachte dass ein Objekt mehrere Events registrieren kann und dann auch mehrfach benachrichtigt wird. Ein unregister hebt nur die erste Registrierung wieder auf, die anderen bleiben unberührt.

Im Anhang ein kleines D5-Beispiel was ich vor ein paar Jahren mal gebastelt hab (170 KB).

[Pseudemys Nelsoni]

Zitat:

Zitat von Chewie

Der Unterschied zwischen Delphi und C#, also das, was dich verwirrt, dürfte wohl sein, dass Eriegnisse in Delphi technisch gesehen nur Methodenzeiger sind, also Zeiger auf eine Methode.

In C# sind Events eigene Sprachfeatures und deswegen als Multicast eingeführt, d.h. du weißt nicht eine Methode dem Event zu wie in Delphi, sondern mehrere.

Deswegen verwendest du den Operator += und nicht den einfachen Zuweisungsoperator, wie du es in Delphi machen würdest.

Danke für die Erklärung, nur versteh ich das nicht ganz. Man weisst Mehr events an ein Delegate? oder wie? *g hm

[Chewie]

Also, du hast in C# zunächst mal keine Methodenzeiger wie in Delphi. Anstelle derer benutzt du ein Delegate.

Ein Event ist ein entsprechendes Sprachfeature, nicht nur eine Property, die einen Methodenzeiger enthält. Du brauchst also ein public event.

Dann brauchst du, genauso wie in Delphi, eine Methode, die der Signatur des Methodenzeigers bzw. hier des Delegates entspricht. Dem Event wird diese Methode zugewiesen allerdings nicht mit =, sondern mit +=.

Der Text hier ist im Prinzip nur die Erläuterung des Quellcodes von Phoenix weiter oben in dem Thread ;)

[Pseudemys Nelsoni]

Danke, ich hoffe ich habs nun verstanden ;)

Und wie ist es wenn ich einen Parameter an ein Event weitergeben möchte, den ich hinterher in meiner Komponente wieder brauche? In Delphi hat man diesen ja einfach mit "var" definiert. Wie ist das in C#?

[Chewie]

Dort heißts ref und funktioniert genauso, man muss nur drauf achten, dass man das ref nicht nur im Methodenkopf hinschreibt, sondern auch beim Aufruf.