C# evento con argumentos personalizados

Question

Quiero tener un evento que toma una enumeración solo como argumento. Por ejemplo

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

se declara un delegado para los parámetros:

public enum MyEvents { Event1 } 

public delegate void MyEventHandler(MyEvents e); 

public static event MyEventHandler EventTriggered; 

A pesar de todos los eventos en el marco toma un parámetro que es o se deriva de EventArgs, puede utilizar cualquier parámetro que le gustan. Sin embargo, es probable que las personas esperen utilizar el patrón en el marco, lo que podría hacer que su código sea más difícil de seguir.

Answer 2

Es necesario declarar un manejador de sucesos personalizado.

public class MyEventArgs: EventArgs 
{ 
    ... 
} 

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

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

Answer 3

EventHandler recibe EventArgs como un parámetro. Para resolver su problema, puede crear su propio 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

Aquí es una reelaboración de su muestra para que pueda empezar.

• su muestra tiene un evento estático - es más habitual para un evento que venir de una instancia de clase, pero lo he dejado estática a continuación.

• En el ejemplo siguiente también se utiliza el nombre más estándar OnXxx para el método que genera el evento.

• El ejemplo siguiente no considera la seguridad de subprocesos, que bien puede ser un problema si insiste en que su evento sea estático.

.

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

que podría ser el final del partido, pero ¿qué tal:

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

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

Ajuste del evento a un delegado anónimo evita para mí comprobar para ver si el evento no es nulo.

Encuentro que esto es útil al usar MVVM, como cuando se usa el método ICommand.CanExecute.