Jak mogę przekazać zdarzenie do funkcji w C#?

Question

Chciałbym przekazać zdarzenie do funkcji pomocnika. Ta funkcja spowoduje dołączenie metody do zdarzenia. Mam jednak problemy z prawidłowym przekazaniem zdarzenia. Próbowałem przekazać EventHandler<TEventArgs>. Kompiluje się, ale zdarzenia nie są dołączone (ale nadal są dodawane, wydaje się, że tworzona jest kopia procedury obsługi zdarzeń).

Na przykład, jeśli mam to:

public event EventHandler<EventArgs> MyEvent; 

a funkcja pomocnika:

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

a dzwoniący:

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

Answer 1

Powodem dlaczego to nie działa, jest + = po nałożeniu na delegata tworzy nowy delegata, który jest połączeniem starego i nowego. Nie modyfikuje istniejącego uczestnika.

Aby to zadziałało, musisz przekazać delegatowi przez odniesienie.

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

Powodem tego działania poza metodą jest to, że LHS jest nadal rzeczywistym polem. Więc + = utworzy nowego delegata i przypisze z powrotem pole członka.

Answer 2

tylko zgadywać: Czy próbowałeś przepuszczenie jako ref?

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

MyHelperFunction(ref MyEvent); 

Answer 3

Mam rozwiązanie, w którym mam dwa interfejsy. Pierwszy interfejs ma metody wiązania określonych zdarzeń, podczas gdy drugi interfejs ma metody zdarzeń, które można powiązać z tymi zdarzeniami.

Metody wiązania pierwszego interfejsu pobierają drugi interfejs jako parametr, który umożliwia powiązanie zdarzeń z metodami zdarzeń dowolnej klasy implementującej drugi interfejs.

Czy to zrozumiałe, czy też wolisz kod? :)

Answer 4

To niezbyt miłe, ale możesz użyć do tego celu refleksji.

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

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

Gdzie eventObject jest obiekt zawierający zdarzenie, a EventName to nazwa imprezy. SetEvent to program obsługi zdarzeń.

Mam też sposób rozporządzać takiego:

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

Answer 5

Jak wielu wskazał, przechodząc zdarzenie sposobu jest albo nie jest możliwe lub nie jest proste.

1. Proszę wyjaśnić, ale podejrzewam, że Twój przeznaczone użytkowanie będzie wyglądać następująco:

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

   Można to osiągnąć jedynie poprzez planowaną rodzajowe obsługi zdarzeń dostępne publicznie (lub wewnętrznie, jeśli chcecie) :

   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; 
       } 
   } 
   

   w tym przykładzie moja catch-all Wózek jest w klasie statycznej, ale można równie dobrze użyć klasy non-statyczne. Widzę również, że w twoim przykładzie stworzyłeś metodę ogólną (TEventArgs). Ponieważ wszystkie pochodne EventHandler (takie jak CancelEventHandler) pasują do podstawowego EventHandler, nie trzeba włączać generycznych (ani nie byłoby to pomocne).

2. Jeśli logika rejestracji jest złożona lub musisz przechowywać EventHandler jako prywatny, rozważ użycie zdarzeń interfejsu. Może to nie odpowiadać zamierzonemu celowi zmniejszenia ilości kodu, ale pozwoli ci utworzyć klasę, która może w sposób przewidywalny obsłużyć wszystkie zdarzenia określonego typu.

   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

Wystarczy wymyślił tego małego pomocnika. Jeśli jest to Twoje własne utworzone Wydarzenie, możesz użyć takiego otoki. Możesz użyć operatorów + = do załączania procedur obsługi jako normalnych, ale możesz przekazać opakowanie, a nawet podnieść wydarzenie z innego miejsca.

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; 
    } 
} 

Utwórz wydarzenie jak:

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

Attach teleskopowe: Event

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

podbicie:

MyEvent.Raise(); 

Answer 7

Przełęcz coś Action e = e => myevent + = e; A wywołanie metody z obsługą? Ma zaletę pracy z klasami .NET.