Passing related classes to a common event handler

Question

I have several classes derived from a base class

public interface IBase {}
public class Base : IBase {}

public class ClassA : Base, IBase {}
public class ClassB : Base, IBase {}
public class ClassC : Base, IBase {}

Now I want to send instances of each of these classes via an event handler to a common location, so I thought "Great .. I'll just subclass Base from EventArgs and pass each of my instances into a common method that can send it off" (note that the following is not real code)

public interface IBase : IEventArgs
public class Base : EventArgs, IBase {}

public class ClassA : Base, IBase {}
public class ClassB : Base, IBase {}
public class ClassC : Base, IBase {} 

EventHandler Update;
void SendClass(IEventArgs data)
{
   Update?.Invoke(this,data);
}

..
SendClass(new ClassA());
SendClass(new ClassB());
SendClass(new ClassC());

Except that IEventArgs is apparently a figment of my imagination. So this can't be done.

It look like the only valid solution is to define a customs Send method for each class that I want to send. EG:

void SendClassA(ClassA data)
{
   Update?.Invoke(this,data);
}

void SendClassB(ClassB data)
{
   Update?.Invoke(this,data);
}

void SendClassC(ClassC data)
{
   Update?.Invoke(this,data);
}

While this works, it gives me a bad code smell feeling as I am basically repeating a very simple method many times.

Is there another design that achieves what I want from an imaginary IEventArgs?

I could achieve what I want with a bunch of Up and Down casting, but again that also gives me a bad feeling (see Casting vs using the 'as' keyword in the CLR)

What problem do you face if you use interface instead of classes? — Chetan, Aug 24 '17 at 14:02
@ChetanRanpariya It doesn't work. `Invoke` can't determine that the parameter was derived from `EventArgs` if you pass it as an interface. — Peter M, Aug 24 '17 at 14:04

score 0 · Accepted Answer · answered Aug 24 '17 at 14:05

0

Is this what you're looking for?

public class BaseEventArgs : EventArgs {
    public IBase Data;
}

public event EventHandler<BaseEventArgs> Update;

void SendData(IBase data)
{
    Update?.Invoke(this, new BaseEventArgs { Data = data } );
}

answered Aug 24 '17 at 14:05

15ee8f99-57ff-4f92-890c-b56153

36,786
7
62
114

I see what you are doing but I was hoping to avoid another level of indirection. But I may just have to accept that. – Peter M Aug 24 '17 at 14:07
It's not the prettiest code on Earth, but it's been the standard .NET event pattern for so many years that it seems best to stick with it. – 15ee8f99-57ff-4f92-890c-b56153 Aug 24 '17 at 14:12
1

Yeah .. and I was so fixated on what I wanted to do that I couldn't step back and see the obvious solution. – Peter M Aug 24 '17 at 14:16
Well, that only happened to me once this morning so far. – 15ee8f99-57ff-4f92-890c-b56153 Aug 24 '17 at 14:16

score 0 · Answer 2 · answered Aug 24 '17 at 14:23

You might want something like this:

void Main()
{
    SendClass(new ClassA());
    SendClass(new ClassB());
    SendClass(new ClassC());
}

public class Base { }

public class ClassA : Base { }
public class ClassB : Base { }
public class ClassC : Base { }

public delegate void SendClassHandler(Base data);

public event SendClassHandler Update;

public void SendClass(Base data)
{
    Update?.Invoke(data);
}

Passing related classes to a common event handler

2 Answers2