Coulée et types Question

Question

Je fais bouillonner des événements dans mon application et donc en utilisant la méthode des bulles d'événements. Comme cette méthode gère toutes sortes d'événements à bulles, il s'agit d'une instruction switch ou if pour déterminer le type d'événement auquel nous traitons. Je me demandais si je pouvais contourner cela en créant différentes versions de la classe args d'événements. Alors laissez-moi vous expliquer, disons que j'ai deux types d'événements qui sont gérés différemment appelés X et Y, je crée de nouvelles classes d'arguments pour ces deux événements car ils stockent différents types d'informations.

public class EventsArgsX : EventsArgs 

public class EventsArgsY : EventsArgs 

puis quand je RaiseBubbleEvent de quelque part dans ma demande je peux passer ou l'autre des deux types en fonction arg événement, donc ..

EventArgsX foox = new EventArgsX(); 
RaiseBubbleEvent(null,foox); 

ou

EventArgsY fooy = new EventArgsY(); 
RaiseBubbleEvent(null,fooy); 

alors la méthode OnBubbleEvent ramasse cela, dont la signature est override OnBubbleEvent (source de l'objet, EventArgs e)

maintenant je ne peux pas surcharger cette méthode comme surchargée en premier lieu, donc ce que je pensais que je pouvais faire était une autre méthode avec surcharge en elle pour gérer cela, donc

protected override OnBubbleEvent(object source, EventArgs e) 
{ 
    DoStuff(e); 
} 

private void DoStuff(EventArgsY args) 
{} 

private void DoStuff(EventArgsX args) 
{} 

mais bien sûr, le problème est que EventArgs e dans la méthode OnBubbleEvent est de type EventArgs au moment de l'appel. Cependant nous savons que ce n'est pas le cas. Alors, comment est-ce que je reviendrai à son type réel pour que l'appel de méthode fonctionne?

Un grand merci, espérons que vous pouvez me aider, son semble vraiment facile comme un pourrait manquer quelque chose ou qu'il ne peut pas simplement être fait

des idées ??

Answer 1

Il est simple:

protected override OnBubbleEvent(object source, EventArgs e) 
{ 
    if(e is EventArgsX) 
     DoStuff((EventArgsX)e); 
    else if(e is EventArgsY) 
     DoStuff((EventArgsY)e); 
} 

Ce, étant KISS, n'est pas très extensible. Si vous prévoyez d'ajouter plus de types d'événements, vous pouvez essayer double dispatch:

public abstract class EventArgsBase : EventArgs 
{ 
    public abstract void Bubble(IEventBubbler eb);   
} 

public interface IEventBubbler 
{ 
    Bubble(EventArgsX ex); 

    Bubble(EventArgsY ey); 
} 

public class EventArgsX : EventArgsBase 
{ 
    public virtual void Bubble(IEventBubbler eb) 
    { 
     eb.Bubble(this); 
    } 
} 

public class EventArgsY : EventArgsBase 
{ 
    public virtual void Bubble(IEventBubbler eb) 
    { 
     eb.Bubble(this); 
    } 
}