Frage zur Definition eigener Events

[michaonline]

Hallo Zusammen,

ich habe eine Frage zur Definition eigener Events.
Ich habe dabei 2 mögliche Wege gefunden, eigene Events zu definieren.
Einmal so:

public event EventHandler EigenerEvent;  
        

        protected virtual void OnEigenerEvent(EventArgs e)
        {
            EventHandler eigenerEvent = EigenerEvent;
            if (eigenerEvent != null)
            {
                eigenerEvent(this, e);
            }
        }

        public void DoSomething()
        {
            OnEigenerEvent(EventArgs.Empty);
        }

und einmal mittels Delegat so:

        public delegate void OnMyEreignisEventHandler(Object Sender, EventArgs e);
        public event OnMyEreignisEventHandler OnMyEreignis;

        public void DoSomething()
        {

            if (OnMyEreignis != null)
            {
                OnMyEreignis(this, new EventArgs());
            }

        }

Gibts bei diesen Varianten irgendwelche Vor/Nachteile?
Oder ist es im Prinzip egal?

Gruß

Micha

[gfoidl]

Hallo Micha,

im Prinzip ist es egal. In der ersten Variante ist der Deleget bereits vordefiniert - EventHandler - und das erspart Schreibarbeit. Wenn EventArgs verwendet werden (selbstdefinierte) dann kann auch die generische Variante EventHandler<T> verwendet werden. Ich bevorzuge (aus Faulheit) die vordefinierten Varianten

BTW: In deiner zweiten Variante gehört das On... nicht hin - dies ist für (protected) Methoden vorgesehen welche in der Klasse das Ereignis feuern.


mfG Gü

[michaonline]

Hallo Gü,

danke für die Antwort. jetzt ist mir das Ganze etwas klarer geworden :-)

Micha

[gfoidl]

Hallo Micha,

hab ein kleines Muster erstellt - siehe auch die Kommentare im Code:
[highlight=c#]
using System;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
MyClass mc = new MyClass();
mc.MyEvent += (s, e) => Console.WriteLine("{0}\t{1}", e.TimeStamp, e.Name);

mc.FireEvent("Entwickler-Forum");

Console.ReadKey();
}
}

/// <summary>
/// Die Argumente für das MyEvent-Ereignis.
/// </summary>
public class MyEventArgs : EventArgs
{
public DateTime TimeStamp { get; private set; }
public string Name { get; set; }

public MyEventArgs(string name)
{
this.TimeStamp = DateTime.UtcNow;
this.Name = name;
}
}

public class MyClass
{
/// <summary>
/// Das öffentliche Ereignis dieser Klasse.
/// </summary>
public event EventHandler<MyEventArgs> MyEvent;

/// <summary>
/// Die Methode welches das Ereignis feuert.
/// </summary>
/// <remarks>
/// protected deshalb damit diese Methode von außen nicht zugreifbar ist,
/// jedoch von abgeleiten Klassen aufgerufen werden kann.
/// </remarks>
protected void OnMyEvent(string name)
{
// Die Ereignisargumente erzeugen:
MyEventArgs e = new MyEventArgs(name);

// Eine lokale Kopie des Delegaten für das Ereignis holen. Somit
// kann mit der folgenden if-Klausel geprüft werden ob das Ereignis
// registiert wurde und zudem (etwas) an Threadsicherheit gewonnen
// werden. Es könnte ja sein dass sich ein Objekt vom Ereignis genau
// zwischen der if-Prüfung und dem Aufruf deregistriert. Durch die
// lokale Kopie kann jedoch weiterhin die Methode aufgerufen werden,
// welche zum Zeitpunkt des Erstellen der lokalen Kopie registiert
// war.
EventHandler<MyEventArgs> tmp = MyEvent;
if (tmp != null)
tmp(this, e);
}

/// <summary>
/// Nur eine (sinnlose) öffentliche Dummy-Methode um das Ereignis
/// aufzurufen.
/// </summary>
/// <param name="name"></param>
public void FireEvent(string name)
{
OnMyEvent(name);
}
}
}
[/highlight]

jetzt ist mir das Ganze etwas klarer geworden

Sonst frag einfach


mfG Gü