Kann ich starke Ausnahmesicherheit und Ereignisse haben?

Question

Angenommen, ich eine Methode, die den Zustand eines Objekts ändert, und löst ein Ereignis-Listener dieser Zustandsänderung mitzuteilen:

public class Example 
{ 
    public int Counter { get; private set; } 

    public void IncreaseCounter() 
    { 
     this.Counter = this.Counter + 1; 
     OnCounterChanged(EventArgs.Empty); 
    } 

    protected virtual void OnCounterChanged(EventArgs args) 
    { 
     if (CounterChanged != null) 
     CounterChanged(this,args); 
    } 

    public event EventHandler CounterChanged; 
} 

Die Ereignishandler eine Ausnahme auslösen kann, auch wenn IncreaseCounter erfolgreich die Zustandsänderung abgeschlossen. So haben wir nicht stark haben exception safety hier:

Die starke Garantie: dass der Betrieb entweder abgeschlossen hat erfolgreich oder eine Ausnahme geworfen, den Programmzustand verläßt genau wie es war, bevor der Betrieb gestartet.

Ist es möglich, eine starke Ausnahmesicherheit zu haben, wenn Sie Ereignisse auslösen müssen?

Answer 1

Um eine Ausbreitung auf den Ereignisgenerator eine Ausnahme in einem Handler zu verhindern, Die Antwort besteht darin, jedes Element im MultiCast-Delegierten (dh den Ereignishandler) innerhalb eines try-catch manuell aufzurufen

Alle Handler werden aufgerufen, und die Ausnahme w fortschreiten.

public EventHandler<EventArgs> SomeEvent; 

protected void OnSomeEvent(EventArgs args) 
{ 
    var handler = SomeEvent; 
    if (handler != null) 
    { 
     foreach (EventHandler<EventArgs> item in handler.GetInvocationList()) 
     { 
      try 
      { 
       item(this, args); 
      } 
      catch (Exception e) 
      { 
       // handle/report/ignore exception 
      } 
     }     
    } 
} 

Was bleibt, ist für Sie die Logik für die umzusetzen, was tun, wenn ein oder mehr Ereignis Empfänger wirft und die andere nicht. Die catch() könnte auch eine bestimmte Ausnahme abfangen und alle Änderungen rückgängig machen, wenn dies sinnvoll ist und der Ereignisempfänger der Ereignisquelle signalisieren kann, dass eine Ausnahmesituation eingetreten ist.

Wie andere darauf hinweisen, wird die Verwendung von Ausnahmen als Kontrollfluss nicht empfohlen. Wenn es wirklich ein außergewöhnlicher Umstand ist, dann verwenden Sie auf jeden Fall eine Ausnahme. Wenn Sie viele Ausnahmen haben, möchten Sie wahrscheinlich etwas anderes verwenden.

Answer 2

Wird nicht einfach die Reihenfolge der beiden Zeilen in IncreaseCounter ausgetauscht, um die Ausnahmesicherheit für Sie zu verstärken?

Oder wenn Sie NotwendigkeitCounter zu erhöhen, bevor Sie das Ereignis auslösen:

public void IncreaseCounter() 
{ 
    this.Counter += 1; 

    try 
    { 
     OnCounterChanged(EventArgs.Empty); 
    } 
    catch 
    { 
     this.Counter -= 1; 

     throw; 
    } 
} 

In einer Situation, wo Sie komplexere Zustandsänderungen (Nebenwirkungen) geht, dann wird es etwas komplizierter (Sie müssen zum Beispiel bestimmte Objekte klonen), aber für dieses Beispiel scheint das ziemlich einfach zu sein.

Answer 3

Das allgemeine Muster, das Sie für Frameworks sehen ist:

public class Example 
{ 
    public int Counter { get; private set; } 

    public void IncreaseCounter() 
    { 
     OnCounterChanging(EventArgs.Empty); 
     this.Counter = this.Counter + 1; 
     OnCounterChanged(EventArgs.Empty); 
    } 

    protected virtual void OnCounterChanged(EventArgs args) 
    { 
     if (CounterChanged != null) 
     CounterChanged(this, args); 
    } 

    protected virtual void OnCounterChanging(EventArgs args) 
    { 
     if (CounterChanging != null) 
     CounterChanging(this, args); 
    } 

    public event EventHandler<EventArgs> CounterChanging; 
    public event EventHandler<EventArgs> CounterChanged; 
} 

Wenn ein Benutzer möchte eine Ausnahme werfen, die Änderung des Wertes zu verhindern, dann sollten sie es in der OnCounterChanging tun() Ereignis statt der OnCounterChanged(). Nach Definition des Namens (Imperfekt, Suffix -ed) bedeutet dies, dass der Wert geändert wurde.

Edit:

Beachten Sie, dass Sie in der Regel weg von reichlichen Mengen an zusätzlichen try..catch bleiben wollen/finally Blöcke als Exception-Handler (einschließlich try..finally) sind teuer abhängig von der Sprache Umsetzung. h. Das win32-Stack-gerahmte Modell oder das PC-gemappte Exception-Modell haben beide ihre Vor- und Nachteile, wenn es jedoch zu viele dieser Frames gibt, sind sie beide teuer (entweder im Raum oder in der Ausführungsgeschwindigkeit). Eine weitere Sache, die man beim Erstellen eines Frameworks beachten sollte.

Answer 4

In diesem Fall sollten Sie einen Hinweis von Workflow Foundation nehmen. Umschließen Sie in der OnCounterChanged-Methode den Aufruf an den Delegaten mit einem generischen try-catch-Block. Im Catch-Handler müssen Sie tun, was effektiv eine Ausgleichsaktion ist - den Counter zurückrollen.

Answer 5

Nun könnte man kompensieren, wenn es kritisch ist:

public void IncreaseCounter() 
{ 
    int oldCounter = this.Counter; 
    try { 
     this.Counter = this.Counter + 1; 
     OnCounterChanged(EventArgs.Empty); 
    } catch { 
     this.Counter = oldCounter; 
     throw; 
    } 
} 

Offensichtlich wäre dies besser, wenn Sie sich auf das Gebiet sprechen können (da ein Feld zuweisen wird nicht Fehler).Sie können auch diese in bolierplate einpacken:

void SetField<T>(ref T field, T value, EventHandler handler) { 
    T oldValue = field; 
    try { 
     field = value; 
     if(handler != null) handler(this, EventArgs.Empty); 
    } catch { 
     field = oldField; 
     throw; 
    } 
} 

und rufen:

SetField(ref counter, counter + 1, CounterChanged); 

oder etwas ähnliches ...