C#: Thread-sichere Ereignisse

Question

Ist die Implementierung unter Thread-sicher? Wenn nicht, was fehlt mir? Sollte ich irgendwo die volatile Schlüsselwörter haben? Oder ein Schloss irgendwo in der OnProcessingCompleted Methode? Wenn ja, wo?

public abstract class ProcessBase : IProcess 
{ 
    private readonly object completedEventLock = new object(); 

    private event EventHandler<ProcessCompletedEventArgs> ProcessCompleted; 

    event EventHandler<ProcessCompletedEventArgs> IProcess.ProcessCompleted 
    { 
     add 
     { 
      lock (completedEventLock) 
       ProcessCompleted += value; 
     } 
     remove 
     { 
      lock (completedEventLock) 
       ProcessCompleted -= value; 
     } 
    } 

    protected void OnProcessingCompleted(ProcessCompletedEventArgs e) 
    { 
     EventHandler<ProcessCompletedEventArgs> handler = ProcessCompleted; 
     if (handler != null) 
      handler(this, e); 
    } 
} 

---

Hinweis: Der Grund, warum ich private Veranstaltung und explizite Schnittstelle Zeug haben, ist, weil es eine abstrakte Basisklasse ist. Und die Klassen, die davon erben, sollten nichts direkt mit diesem Ereignis tun. Hinzugefügt Wrapper die Klasse, so dass es klar ist =)

Answer 1

Es besteht keine Notwendigkeit für das private ProcessCompleted Mitglied ist ein event zu sein - es ist nur ein Feld sein könnte: - innerhalb der Klasse geht es direkt immer auf das Feld , so ist das event Zeug sowieso verloren.

Der Ansatz, den Sie mit einem expliziten Sperrobjekt gezeigt haben, ist nicht viel mehr Thread-sicher als nur ein Feld artiges Ereignis (dh public event EventHandler<ProcessCompletedEventArgs> ProcessCompleted; - der einzige Unterschied ist, dass Sie nicht Sperren „this“ sind (das ist eine gute Sache - Sie sollten ideal vermeiden sperren auf this). .. der „handler Variable“ Ansatz ist die richtige, aber es gibt immer noch side-effects you should be aware of

Answer 2

Sie müssen sperren, wenn Sie den Handler holen zu , sonst haben Sie möglicherweise nicht den neuesten Wert:

protected void OnProcessingCompleted(ProcessCompletedEventArgs e) 
{ 
    EventHandler<ProcessCompletedEventArgs> handler; 
    lock (completedEventLock) 
    { 
     handler = ProcessCompleted; 
    } 
    if (handler != null) 
     handler(this, e); 
} 

Beachten Sie, dass nicht verhindert eine Race-Bedingung, wo wir entschieden haben, dass wir eine Reihe von Handlern und dann einen Handler abgemeldet ausführen. Es wird immer noch aufgerufen, weil wir den Multicast-Delegaten, der es enthält, in die Variable handler abgerufen haben.

Es gibt nicht viel, was Sie dagegen tun können, außer dem Handler selbst bewusst zu machen, dass er nicht mehr aufgerufen werden sollte.

Es ist wohl besser, nur nicht versucht die Ereignisse Thread-sicher zu machen - angeben, dass das Abonnement sollte nur Änderung des Threads, das Ereignis auslösen wird.