Evénement C# avec des arguments personnalisés

Question

Je souhaite avoir un événement qui prend une énumération uniquement en tant qu'argument. Par exemple

public enum MyEvents{ 
    Event1 
} 

// how do I declare this to take enum MyEvents as argument 
public static event EventHandler EventTriggered; 

public static void Trigger(MyEvent event) 
{ 
    if (EventTriggered != null) 
    { 
     EventTriggered(event); 
    } 
} 

Answer 1

Vous déclarez un délégué pour les paramètres:

public enum MyEvents { Event1 } 

public delegate void MyEventHandler(MyEvents e); 

public static event MyEventHandler EventTriggered; 

Bien que tous les événements dans le cadre prend un paramètre qui est ou dérive de EventArgs, vous pouvez utiliser tous les paramètres que vous aimez. Cependant, les gens sont susceptibles d'attendre le modèle utilisé dans le cadre, ce qui pourrait rendre votre code plus difficile à suivre.

Answer 2

Vous devez déclarer un gestionnaire d'événements personnalisé.

public class MyEventArgs: EventArgs 
{ 
    ... 
} 

public delegate void MyEventHandler(object sender, MyEventArgs e); 

public class MyControl: UserControl 
{ 
    public event MyEventHandler MyEvent; 
    ... 
} 

Answer 3

EventHandler reçoit EventArgs en tant que paramètre. Pour résoudre votre problème, vous pouvez créer votre propre MyEventArgs.

public enum MyEvents 
{ 
    Event1 
} 

public class MyEventArgs : EventArgs 
{ 
    public MyEvents MyEvent { get; set; } 
} 

public static event EventHandler<MyEventArgs> EventTriggered; 

public static void Trigger(MyEvents ev) 
{ 
    if (EventTriggered != null) 
    { 
     EventTriggered(null, new MyEventArgs { MyEvent = ev }); 
    } 
} 

Answer 4

public enum MyEvents 
{ 
    Event1 
} 

public class CustomEventArgs : EventArgs 
{ 
    public MyEvents MyEvents { get; set; } 
} 


private EventHandler<CustomEventArgs> onTrigger; 

public event EventHandler<CustomEventArgs> Trigger 
{ 
    add 
    { 
     onTrigger += value; 
    } 
    remove 
    { 
     onTrigger -= value; 
    } 
} 

protected void OnTrigger(CustomEventArgs e) 
{ 
    if (onTrigger != null) 
    { 
     onTrigger(this, e); 
    } 
} 

Answer 5

est ici un remaniement de votre échantillon pour vous aider à démarrer.

• votre échantillon a un événement statique - il est plus habituel pour un événement à venir d'une instance de classe, mais je l'ai laissé statique ci-dessous. L'exemple ci-dessous utilise également le nom plus classique OnXxx pour la méthode qui déclenche l'événement. L'exemple ci-dessous ne tient pas compte de la sécurité des threads, ce qui peut poser plus de problèmes si vous insistez pour que votre événement soit statique.

.

public enum MyEvents{ 
    Event1 
} 

public class MyEventArgs : EventArgs 
{ 
    public MyEventArgs(MyEvents myEvents) 
    { 
     MyEvents = myEvents; 
    } 

    public MyEvents MyEvents { get; private set; } 
} 

public static class MyClass 
{ 
    public static event EventHandler<MyEventArgs> EventTriggered; 

    public static void Trigger(MyEvents myEvents) 
    { 
     OnMyEvent(new MyEventArgs(myEvents)); 
    } 

    protected static void OnMyEvent(MyEventArgs e) 
    { 
     if (EventTriggered != null) 
     { 
      // Normally the first argument (sender) is "this" - but your example 
      // uses a static event, so I'm passing null instead. 
      // EventTriggered(this, e); 
      EventTriggered(null, e); 
     } 
    } 
} 

Answer 6

je pourrais être en retard dans le jeu, mais que diriez-vous:

public event Action<MyEvent> EventTriggered = delegate { }; 

private void Trigger(MyEvent e) 
{ 
    EventTriggered(e); 
} 

Réglage de l'événement à un délégué anonyme évite pour moi de vérifier pour voir si l'événement est non nul. Je trouve que cela est pratique lorsque vous utilisez MVVM, comme lorsque vous utilisez ICommand.CanExecute Method.