ajouter/supprimer des gestionnaires d'événements C# avec une seule méthode

Question

Existe-t-il un moyen d'ajouter et de supprimer des gestionnaires d'événements dans C# en transmettant les opérateurs + = et - = comme arguments, donc une seule méthode pourrait le faire?

J'essaie d'éviter la répétition:

AttachHandlers() 
{ 
    event1 += handler1; 
    event2 += handler2; 
    // etc... 
} 

DetachHandlers() 
{ 
    event1 -= handler1; 
    event2 -= handler2; 
    // etc... 
} 

ou

AttachDetachHandlers(bool attach) 
{ 
    if (attach) 
    { 
    event1 += handler1; 
    event2 += handler2; 
    // etc... 
    } 
    else 
    { 
    event1 -= handler1; 
    event2 -= handler2; 
    } 
} 

Au lieu de cela, je voudrais écrire quelque chose comme ceci:

AttachDetachHandlers(operator addRemove) 
{ 
    addRemove(event1, handler1); 
    addRemove(event2, handler2); 
    // etc... 
} 

être utilisé avec quelque chose comme :

AttachDetachHandlers(+=); 

Idéalement, cela devrait fonctionner avec les gestionnaires d'événements & ayant des signatures différentes (comme + = & - = do).

Answer 1

Vous pouvez essayer ceci:

public static void Attach<T>(ref EventHandler<T> a, EventHandler<T> b) 
    { 
     a += b; 
    } 

    public static void Detach<T>(ref EventHandler<T> a, EventHandler<T> b) 
    { 
     a -= b; 
    } 

    public static void AttachDetachHandlers<T>(Action<ref EventHandler<T>, EventHandler<T>> op) 
    { 
     op(ref event1, handler1); 
     op(ref event2, handler2); 
     //etc... 
    } 

Utilisez ensuite comme ceci:

 AttachDetachHandlers<int>(Attach); 
     //... 
     AttachDetachHandlers<int>(Detach); 

Answer 2

Utilisez cet exemple de code. Mais notez que la signature des gestionnaires d'événements doit être la même. Pourquoi ne pas simplement utiliser une instruction if basée sur un booléen?

class Program 
{ 
    delegate void dlgHandlerOperation<T>(ref EventHandler<T> Event, EventHandler<T> Handler); 

    static void SetHandler<T>(ref EventHandler<T> Event, EventHandler<T> Handler) { Event += Handler; } 
    static void UnsetHandler<T>(ref EventHandler<T> Event, EventHandler<T> Handler) { Event -= Handler; } 

    static void SetAll(dlgHandlerOperation<int> Op) 
    { 
     Op(ref ev, foo); 
     Op(ref ev, bar); 
    } 

    static event EventHandler<int> ev; 

    static void Main(string[] args) 
    { 
     SetAll(SetHandler); 
     ev?.Invoke(null, 5); 

     SetAll(UnsetHandler); 
     ev?.Invoke(null, 6); 
    } 

    static void foo(object sender, int e) { Console.WriteLine("foo => " + e); } 
    static void bar(object sender, int e) { Console.WriteLine("bar => " + e); } 
}