Comment puis-je passer d'un événement à une fonction en C#?

Juste venu avec ce petit assistant. Si il est de votre auto-Événement créé, vous pouvez utiliser un wrapper de ce genre. Vous pouvez utiliser votre += opérateurs de joindre les gestionnaires comme normal, mais peut passer le wrapper autour et même d'accroître le cas 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>();

Associer des gestionnaires:

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

Élever événement:

MyEvent.Raise();

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

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

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

Où eventObject est l'objet contenant l'événement, et eventName est le nom de l'événement.
SetEvent est votre gestionnaire d'événement.

J'ai aussi une méthode dispose comme ceci:

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

Comme beaucoup l'ont souligné, en passant par un événement, une méthode n'est pas possible ou n'est pas simple.

1. Préciser, mais je soupçonne votre 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 tout simplement en faisant votre générique des gestionnaires d'événements accessibles publiquement (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 non-statique de la classe. Aussi, je vois que dans votre exemple, vous avez fait la méthode générique (TEventArgs). Parce que tout ce Gestionnaire de produits dérivés (tels que CancelEventHandler) correspondent à la base de ce Gestionnaire, vous n'avez pas besoin d'impliquer les génériques (il ne serait pas utile).

2. Si l'enregistrement logique est complexe ou que vous devez garder le Gestionnaire privé, envisagez d'utiliser les Événements de l'Interface. Cela peut ne pas répondre à votre objectif de réduire la quantité de code, mais il vous permettra de créer une classe qui peut, de manière prévisible, gérer 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.");
       }
   }