neue Mode, Controls zu "verdrahten"

Hallo!

Kann natürlich sein, dasses niemanden interessiert, aber mir scheint, in Zukunft werde ich dazu übergehen, die gängigen Events (wohl v.a. _Click()) folgendermaßen zu abonnieren:

public partial class frmA0FormStart : Form {

   public frmA0FormStart() {
      InitializeComponent();
      // mehrere Events auf einen "Handler" leiten
      this.button1.Click += (sender, e) => SayThanx((Button)sender);
      this.button2.Click += (sender, e) => SayThanx((Button)sender);
      this.btLoadData.Click += (sender, e) => LoadData();         //Parameterlose Funcs bevorzugen
      this.Disposed += (sender, e) => MessageBox.Show("Bye!");        //Kleinkram direkt erledigen
      LoadData();
   }

   // dieser "Handler" hat den Vorzug, dasser nur die Argumente erwartet, die er braucht, und 
   // zwar typisiert
   private void SayThanx(Button sender) {
      sender.Text = "Thanks for klicking me!";
   }

   private void LoadData() {
      // insert code here
   }

}

Prinzipien*Parameter weglassen, wenn nicht gebraucht. Dadurch erhalte ich Funktionen, die auch direkt aufrufbar sind, ohne gegen die Konvention zu verstoßen, nach der EventHandler nur vom Event-Auslöser aufgerufen werden sollten (s. LoadData() ) *Den Sender-Parameter ggfs. typisiert durchreichen *Kleinkram direkt erledigen

Schlagwörter: event,events,eventhandler

Nette Sache, werde das im Hinterkopf behalten, auch wenn das für mich wohl maximal nur für Control-clicks in Betracht käme.

Auch "C# in Depth" von Jon Skeet gelesen 😉?

Hallo ErfinderDesRades.

Interessant, wusste garnicht das sowas geht.

Mir gefällt der Weg, über einen herkömmlichen EventHandler zu gehen, aber trotzdem besser. Zum einen ist es einheitlicher, zum anderen kann man einen EventHandler direkt als solchen identifizieren bzw. kategorisch von anderen Methoden abgrenzen.

Wenn man die Funktionalität in separaten Methoden auslagert (welche dann in dem EventHandler aufgerufen werden), ist der Code ebenfalls wiederverwendbar.

Auch "C# in Depth" von Jon Skeet gelesen 😉?

Nein!
Jetzt sach blos, da habich das Rad mal wieder neu erfunden!

Wenn man die Funktionalität in separaten Methoden auslagert (welche dann in dem EventHandler aufgerufen werden), ist der Code ebenfalls wiederverwendbar.

Ja, und im EventHandler steht dann nur noch der doofe Aufruf der Methode. Da kannich mir den EventHandler ja auch ganz schenken (wassich ja auch tue 😉 ).

Na ja, da wird zumindest auch auf die Vor- und Nachteile dieser Variante eingegangen.

Nachteil ist nämlich, dass es nur bei Events funktioniert, die mindestens einen Parameter haben, denn ansonsten kann man keinen Lambdaausdruck angeben, weil die linke Seite fehlen würde.

Wobei das eher ein theoretisches Problem ist, weil die Events in der Regel ja mit EventArgs oder eine davon abgeleiteten Klasse arbeiten.

?

Geht doch:

      public event MethodInvoker AnarchoEvent;

      public frmA0FormStart() {
         InitializeComponent();
         this.AnarchoEvent += () => MessageBox.Show(
            "Der Kommunismus hat gesiegt! Amerika verstaatlicht seine Banken!");
         // ...

Aber sowas machen, wie du sagst, nur böse Onkels.

Hm, Du hast recht - okay, dann muss ich noch mal nachgucken, was genau das Problem war ...

wenn ich das jetzt richtig verstnaden hab, kann man damit mehrere events mit der dem gleichen eventhandler verarbeiten, oder?

Wenn ja, danke hab sowas auch al probiert, wusste nur nich wie.
Wäre vorallem praktisch, wenn man 20 Buttons in ner form hat, und nich für jede einzelne ne eigene funktion schrieben muss^^

Hallo hobofan,

kann man damit mehrere events mit der dem gleichen eventhandler verarbeiten, oder?

nein, das kann man immer schon. Das ist aber bitte nicht das Thema dieses Threads.

herbivore

...muss ich noch mal nachgucken, was genau das Problem war ...

Ah, ja - ein Nachteil ist, daß man so anonyme Eventhandler nicht mehr deregistrieren kann.
Bzw. nur mit einem Workaround, sodaß die traditionelle Methode doch wieder einfacher ist.

Mal 'ne Frage: in .NET 2.0 geht das nicht, oder?

Doch, sollte gehen. Es setzt aber den C# 3-Compiler voraus.

Ich habe gedacht, dass diese Lambdaausdrücke

this.button1.Click += (sender, e) => SayThanx((Button)sender);

erst mit .Net 3.5 eingeführt wurden 🤔

Edit: siehe .NET 3.5 - Neuerungen bei C#3.0 - Teil 4 von 9 (erster Treffer bei Google)

.NET 3.5 = .NET 2.0 + paar Erweiterungen

Der C# 3-Compiler erzeugt für Lambdaausdrücke intern auch keinen anderen Code als wenn Du direkt eine anonyme Methode hinschreibst.

Deshalb sollte eine entsprechende Anwendung auch auf .NET 2.0 laufen, sie MUSS aber mit C# 3 kompiliert worden sein, da der C# 2-Compiler den Lambdaausdruck nicht kennt.