EventHandler delegate accepts methods with the following signature, but event implementing EventHandler doesn’t

Question

Assuming we declare a class DerivedEventArgs:

public class DerivedEventArgs : EventArgs { ... }

then EventHandler delegate is able to accept methods with the following signature:

public static void Some_Method(object o, DerivedEventArgs e) { ... }

But if we try to subscribe a method with the above signature to the event implementing EventHandler delegate:

public event EventHandler MyEvent;

, then we get an error. Why is that?

thanx

Answer 1

Suppose the code raising the event specified a value which wasn't a DerivedEventArgs - what would you expect it to do? Basically you'd lose type safety.

EDIT Note that you can do it the other way round - you can subscribe to an event with a more specific parameter type using a method with a less specific parameter type - because the event is still guaranteeing that it will call the handler with something compatible. Here's an example:

using System;

class Test
{
    public class DerivedEventArgs : EventArgs { }

    public EventHandler<DerivedEventArgs> SpecialistEvent;

    static void Main()
    {
        Test t = new Test();
        t.SpecialistEvent += GeneralHandler;
    }

    static void GeneralHandler(object sender, EventArgs e)
    {
    }
}

Answer 2

MyEvent(this, EventArgs.Empty)

would try to pass a regular EventArgs to DerivedEventArgs in

Some_Method(object o, DerivedEventArgs e) 

and then if Some_Method tried to do an

e.PropertyInDerivedClass

it'd fail.

Answer 3

try using an EventHandler<T> for your event, where T is your DerivedEventArgs class.

Answer 4

From MSDN EventHandler documentation...

EventHandler is a predefined delegate that specifically represents an event handler method for an event that does not generate data. If your event does generate data, you must supply your own custom event data type and either create a delegate where the type of the second parameter is your custom type, or use the generic EventHandler< TEventArgs > delegate class and substitute your custom type for the generic type parameter.

The EventHandler Delegate was not made to do what you're trying to do. It's a simple convenience delegate for use in cases where event data is unimportant. The event that utilizes this delegate type may send a EventArgs with the least derived event argument type possible. That means your delegate should be ready to receive anything.

But in your example, you're specifying a more derived event argument type in your handler. Hence, if allowed by the compiler, your code can actually receive another EventArgs type that's not what you expect but defined as your derived type; breaking type safety as mentioned earlier.