Automatyczne tworzenie pustych programów obsługi zdarzeń w języku C#

Question

Nie można wystrzelić zdarzenia w języku C#, do którego nie są dołączone żadne procedury obsługi. Dlatego przed każdym wywołaniem należy sprawdzić, czy zdarzenie ma wartość zerową.

if (MyEvent != null) { 
    MyEvent(param1, param2); 
} 

Chciałbym zachować mój kod tak czysty, jak to możliwe i pozbyć się tych zerowych kontroli. Nie sądzę, że wpłynie to na wydajność, przynajmniej nie w moim przypadku.

MyEvent(param1, param2); 

W tej chwili rozwiązuję ten problem, dodając pusty ręczny komunikat do każdego zdarzenia. To jest podatny na błędy, ponieważ trzeba pamiętać, aby zrobić itp

void Initialize() { 
    MyEvent += new MyEvent((p1,p2) => { }); 
} 

Czy istnieje sposób, aby generować pustych teleskopowe na wszystkich wydarzeniach z danej klasy automatycznie przy użyciu odbicia i trochę CLR magię?

Answer 1

Widziałem to na innym stanowisku, a nie bezczelnie ukradł go i wykorzystał je w dużej części mojego kodu odkąd:

public delegate void MyClickHandler(object sender, string myValue); 
public event MyClickHandler Click = delegate {}; // add empty delegate! 

//Let you do this: 
public void DoSomething() { 
    Click(this, "foo"); 
} 

//Instead of this: 
public void DoSomething() { 
    if (Click != null) // Unnecessary! 
     Click(this, "foo"); 
} 

* Jeśli ktoś zna pochodzenie tej techniki, proszę pisać w komentarzach . Naprawdę wierzę, że źródło otrzymuje należny kredyt.

(Edit: mam go z tego stanowiska Hidden Features of C#?)

Answer 2

Możesz napisać to jako:

MyEvent += delegate { }; 

Nie jestem pewien, co chcesz zrobić jest poprawny.

Answer 3

Notacja:

if (MyEvent != null) { 
    MyEvent(param1, param2); 
} 

nie jest bezpieczeństwo wątków. Należy zrobić to w ten sposób:

EventHandler handler = this.MyEvent; 
if (null != handler) { handler(param1, param2); } 

Rozumiem, że jest to niepokoić, więc można zrobić metody pomocnika:

static void RaiseEvent(EventHandler handler, object sender, EventArgs e) { 
    if (null != handler) { handler(sender, e); } 
} 

a następnie zadzwonić:

RaiseEvent(MyEvent, param1, param2); 

Jeśli używają C# 3.0, możesz zadeklarować metodę pomocniczą jako metodę rozszerzenia:

static void Raise(this EventHandler handler, object sender, EventArgs e) { 
    if (null != handler) { handler(sender, e); } 
} 

a następnie zadzwonić:

MyEvent.Raise(param1, param2); 

Ponadto można tworzyć następne rozszerzenie/Helper dla innych metod obsługi zdarzeń. Na przykład:

static void Raise<TEventArgs>(this EventHandler<TEventArgs> handler, 
    object sender, TEventArgs e) where TEventArgs : EventArgs 
{ 
    if (null != handler) { handler(sender, e); } 
} 

Answer 4

To zły pomysł, że kod, który zużywa zdarzenie ma teraz oczekiwanie, że obiekt ze zdarzeniem został zakodowany z akcją domyślnie. Jeśli twój kod nigdy nie zostanie użyty nigdzie indziej przez nikogo innego, to myślę, że możesz temu zapobiec.

Answer 5

Nie trzeba kilka metod rozszerzenie dla różnych programów obsługi zdarzeń, wystarczy jeden:

public static class EventHandlerExtensions { 
    public static void Raise<T>(this EventHandler<T> handler, object sender, T args) where T : EventArgs { 
    if (handler != null) handler(sender, args); 
    } 
} 

Answer 6

Można użyć PostSharp się na czasie kompilacji dodać tę magię. To najlepszy sposób.

Answer 7

Deklaracje zdarzeń C# niestety zawierają wiele dobrze znanych problemów bezpieczeństwa i nieefektywności. I designed a number of extension methods on delegates to invoke them safely, and to register/unregister delegates in a thread-safe manner.

Twój stary kod zdarzenia świadomości:

if (someDelegate != null) someDelegate(x, y, z); 

Twój nowy kod:

someDelegate.Raise(x, y, z); 

Twój stary kod rejestracji zdarzeń:

event Action fooEvent; 
... 
lock (someDummyObject) fooEvent += newHandler; 

Twój nowy kod:

Action fooEvent; 
... 
Events.Add(ref fooEvent, newHandler); 

Nie jest wymagane blokowanie, nie są wstawiane obiekty obojętne z kompilatorem używane do blokowania zdarzeń.

Answer 8

W języku C# 6.0 nie ma potrzeby, aby przejść do któregokolwiek z tych długościach zrobić czek zerowej, dzięki warunkowego zerowej operatora ?.

The docs wyjaśniają, że powołanie MyEvent?.Invoke(...) kopie zdarzenie do zmiennej tymczasowej, wykonuje NULL sprawdź, a jeśli nie, null, wywołuje Invoke na kopii tymczasowej. Nie musi to być wątek bezpieczny pod każdym względem, ponieważ ktoś mógłby dodać nowe zdarzenie po skopiowaniu do zmiennej tymczasowej, która nie zostałaby wywołana. Gwarantuje to, że nie zadzwonisz pod numer Invoke na wartość null.

W skrócie:

public delegate void MyClickHandler(object sender, string myValue); 
public event MyClickHandler Click; 

public void DoSomething() { 
    Click?.Invoke(this, "foo"); 
}