Comment puis-je transmettre un événement à une fonction en C#?

Question

Je cherche à passer un événement à une fonction d'aide. Cette fonction va attacher une méthode à l'événement. Cependant, j'ai du mal à passer correctement l'événement. J'ai essayé de passer un EventHandler<TEventArgs>. Il compile, mais les événements ne sont pas attachés (mais sont toujours ajoutés, il semble qu'une copie du gestionnaire d'événement est faite).

Par exemple, si j'ai ceci:

public event EventHandler<EventArgs> MyEvent; 

Et la fonction d'aide:

public static void MyHelperFunction<TEventArgs>(EventHandler<TEventArgs> eventToAttachTo) 
{ 
    eventToAttachTo += (sender, e) => { Console.WriteLine("Hello world"); }; 
} 

Et l'appelant:

MyHelperFunction(MyEvent); 
MyEvent(null, new EventArgs()); // Does nothing. 

Answer 1

La raison pour laquelle cela ne fonctionne pas est + = lorsqu'elle est appliquée à un délégué crée un nouveau délégué qui est la combinaison de l'ancien et le nouveau. Cela ne modifie pas le délégué existant. Pour que cela fonctionne, vous devrez passer le délégué par référence.

public static void Helper(ref EventHandler<EventArgs> e) 
{ 
    e+= (x,y) => {}; 
} 

La raison pour laquelle cela fonctionne en dehors de la méthode est que le LHS est toujours le champ réel. So + = créera un nouveau délégué et assignera de nouveau au champ de membre.

Answer 2

juste deviner: Avez-vous essayé le passer comme ref?

public static void MyHelperFunction<TEventArgs>(ref EventHandler<TEventArgs> eventToAttachTo) 

MyHelperFunction(ref MyEvent); 

Answer 3

J'ai une solution où j'ai deux interfaces. La première interface a des méthodes pour lier certains événements, tandis que l'autre interface a des méthodes d'événement qui peuvent être liées à ces événements.

Les méthodes de liaison de la première interface prennent comme paramètre la seconde interface, ce qui permet de lier les événements aux méthodes d'événement de n'importe quelle classe qui implémente la seconde interface.

Est-ce compréhensible, ou préférez-vous du code? :)

Answer 4

Ce n'est pas vraiment agréable, mais vous pouvez utiliser la réflexion pour le faire.

public EventMonitor(object eventObject, string eventName) 
    { 
     _eventObject = eventObject; 
     _waitEvent = eventObject.GetType().GetEvent(eventName); 

     _handler = new EventHandler(SetEvent); 
     _waitEvent.AddEventHandler(eventObject, _handler); 
    } 

Où événementObjet est l'objet contenant l'événement et nomEvènement est le nom de l'événement. SetEvent est votre gestionnaire d'événements.

J'ai aussi une méthode Éliminez comme ceci:

public void Dispose() 
    { 
     _waitEvent.RemoveEventHandler(_eventObject, _handler); 
    } 

Answer 5

Comme beaucoup l'ont souligné, le passage d'un événement à une méthode est pas possible ou pas simple.

1. S'il vous plaît clarifier les choses, mais je soupçonne que l'usage prévu ressemblera à quelque chose comme:

   void Register() 
   { 
       var super = new SuperHandler(); 
   
       //not valid syntax: 
       super.HandleEvent(MyEvent1); 
       super.HandleEvent(MyEvent2); 
       super.HandleEvent(MyEvent3); 
       super.HandleEvent(MyEvent4); 
   } 
   

   Vous pouvez accomplir cela en faisant simplement vos gestionnaires d'événements génériques destinés accessibles au public (ou à l'intérieur, si vous le désirez) :

   public static class GenericHandler 
   { 
       public static void HandleAnyEvent(object sender, EventArgs e) 
       { 
        //handle 
       } 
   } 
   
   public class SomeClass 
   { 
       void RegisterEvents() 
       { 
        var r = new EventRaiser(); 
   
        r.ImportantThingHappened += GenericHandler.HandleAnyEvent; 
       } 
   } 
   

   dans cet exemple, mon fourre-tout gestionnaire est dans une classe statique, mais vous pouvez tout aussi bien utiliser une classe non statique. Aussi, je vois que dans votre exemple vous avez fait la méthode générique (TEventArgs). Étant donné que tous les dérivés EventHandler (tels que CancelEventHandler) correspondent à la classe EventHandler de base, vous n'avez pas besoin d'implémenter de génériques (ce qui ne serait pas utile).

2. Si la logique d'enregistrement est complexe ou si vous devez garder le gestionnaire d'événements privé, vous pouvez utiliser Événements d'interface. Cela peut ne pas atteindre votre objectif de réduire la quantité de code, mais cela vous permettra de créer une classe capable de gérer de façon prévisible tous les événements d'un type spécifique.

   interface IRaiseEvents 
   { 
       event EventHandler ConnectionCreated; 
       event EventHandler ConnectionLost; 
   } 
   
   public class SuperHandler 
   { 
       void RegisterEvents(IRaiseEvents raiser) 
       { 
        raiser.ConnectionCreated += (sender, args) => Console.WriteLine("Connected."); 
        raiser.ConnectionLost += (sender, args) => Console.WriteLine("Disconnected."); 
       } 
   } 
   

Answer 6

Tout est venu avec cette petite aide. Si c'est votre événement que vous avez créé vous-même, vous pouvez utiliser un wrapper comme celui-ci. Vous pouvez utiliser vos opérateurs + = pour attacher les gestionnaires comme d'habitude, mais pouvez passer l'encapsuleur et même élever l'événement d'ailleurs.

public class GenericEvent<T> where T:EventArgs 
{ 
    public event EventHandler<T> Source = delegate { }; 

    public void Raise(object sender, T arg = default(T)) 
    { 
     Source(sender, arg); 
    } 

    public void Raise(T arg = default(T)) 
    { 
     Source(this, arg); 
    } 

    public void AddHandler(EventHandler<T> handler) 
    { 
     Source += handler; 
    } 

    public void RemoveHandler(EventHandler<T> handler) 
    { 
     Source -= handler; 
    } 

    public static GenericEvent<T> operator +(GenericEvent<T> genericEvent, EventHandler<T> handler) 
    { 
     genericEvent.AddHandler(handler); 
     return genericEvent; 
    } 
} 

Créer l'événement comme:

public GenericEvent<EventArgs> MyEvent = new GenericEvent<EventArgs>(); 

Joindre les gestionnaires:

MyEvent += (s,e) => {}; 

Raise événement:

MyEvent.Raise(); 

Answer 7

passe quelque chose comme action e = e => monevenement + = e; Et appel de la méthode avec le gestionnaire? Il a l'avantage de travailler avec des classes .NET.