Ist es möglich, mehrere Ereignisse mit einem einzigen Methodenaufruf abzubestellen?

Question

Hier ist ein Szenario:

ich eine Klasse, die für viele verschiedene Veranstaltungen abonniert:

ProviderOfFruit.Event += OnFruitHarvested; 
ProviderOfCars.Event += OnCarBrokeDown; 
ProviderOfPeople.Event += OnPersonAwoke; 
...etc 

Später will ich von all diesen zugleich abzumelden. Bin ich verurteilen dies in vollem Umfang aus dem Schreiben:

ProviderOfFruit.Event -= OnFruitHarvested; 
ProviderOfCars.Event -= OnCarBrokeDown; 
ProviderOfPeople.Event -= OnPersonAwoke; 
...etc 

Oder ist es eine Möglichkeit, etwas entlang der Linien von dem zu tun:

ListOfEvents.Unsubscibe(); ? 

HINWEIS: Ich möchte nicht ein Ereignis von allen löschen seine Abonnenten, viele Klassen, die ich zu einer Veranstaltung abonniert habe. Ich möchte nur, dass eine dieser Klassen die abonnierten Ereignisse abbestellt. Das Ziel ist, dass ich nie vergesse, mich von einer bestimmten Veranstaltung abzumelden.

Answer 1

Sie können das folgende Muster verwenden. Erste Klasse erstellen, die beliebige Funktion ausgeführt wird passieren Sie auf dem Bau und dem anderen auf dispose:

public class EventSubscription : IDisposable { 
    private readonly Action _unsubscribe; 

    private EventSubscription(Action subscribe, Action unsubscribe) { 
     _unsubscribe = unsubscribe; 
     subscribe(); 
    } 

    public static IDisposable Create(Action subscribe, Action unsubscribe) { 
     return new EventSubscription(subscribe, unsubscribe); 
    } 

    public void Dispose() { 
     _unsubscribe(); 
    } 
} 

Dann Feld in Ihrer Klasse erstellen, wo Sie abonnieren Sie Ereignisse:

private static readonly List<IDisposable> _subscriptions = new List<IDisposable>(); 

und abonnieren wie folgt aus:

_subscriptions.Add(EventSubscription.Create(
    () => Event1 += OnEvent1, 
    () => Event1 -= OnEvent1)); 
_subscriptions.Add(EventSubscription.Create(
    () => Event2 += OnEvent2, 
    () => Event2 -= OnEvent2)); 

Wenn Sie wieder abbestellen müssen, tun gerade:

_subscriptions.ForEach(c => c.Dispose()); 

Vorteile sind das Abmelden von allen auf einmal, und viel weniger Chance zu vergessen, abzubestellen, weil Sie immer += und -= Handler in Paar, im selben Anruf übergeben.

Variation dieser ist dieser allgemeine Zweck Klasse:

public class Disposable : IDisposable { 
    private readonly Action _action; 
    private Disposable(Action action) { 
     _action = action; 
    } 
    public static IDisposable FromAction(Action action) { 
     return new Disposable(action); 
    } 
    public void Dispose() { 
     _action(); 
    } 
} 

Sie können es bereits an vielen Orten finden (wie .NET reaktive Erweiterungen), aber wenn nicht - Sie selbst umsetzen können. Dann obige Code wird:

Event1 += OnEvent1; 
_subscriptions.Add(Disposable.FromAction(() => Event1 -= OnEvent1)); 

Mit IDisposable natürlich nicht notwendig ist, können Sie nur Liste von Aktionen haben.

Answer 2

Ja, Sie können alle Ereignisse, die eine Klasse abonniert, in einer Sammlung behalten und über sie hinwegschleifen. Dadurch müssen Sie nicht jedes Ereignis während des Abonnements und dann noch einmal beim Abmelden auflisten - und als Bonus hilft es, die Möglichkeit zu verhindern, ein Ereignis an einem Ort zu verpassen.

Dies ist jedoch begrenzt und löst nicht das größte Problem Ihrer Klasse mit einer harten Abhängigkeit von so vielen anderen Klassen. Ihr Beispiel liefert nicht genügend Details, um es mit Sicherheit zu sagen, aber Sie können das Event Aggregator Nutzungsmuster finden.