EventHandlers and Covariance

Question

I've been trying to create a generic event. Basically it should look like this:

namespace DelegateTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var lol = new SomeClass();
            lol.SomeEvent += handler;
        }

        static void handler(object sender, SomeDerivedClass e)
        {

        }

    }

    class SomeClass
    {

        public delegate void SomeEventDelegate<in T>(object sender, T data);
        public event SomeEventDelegate<ISomeInterface> SomeEvent;

    }

    interface ISomeInterface
    {
    }

    class SomeDerivedClass : ISomeInterface
    {
    }
}

I want to allow the user to pass any delegate which's second parameter is derived from "ISomeInterface."

"in" specifies contra-variance, right? That means if the API is expecting something more general, you can pass it something more specific (in my base "ISomeInterface" would be general, and my "SomeDerivedClass" would be specific.) I am, however, being told my the compiler that "no overload for method handler matches DelegateTest.SomeClass.SomeEventDelegate."

I am wondering why this isn't working. What are the problems that would be caused if it was? Or am I missing something for it to work?

Thanks in advance!

Answer 1

"in" specifies contra-variance, right?

Yes.

That means if the API is expecting something more general, you can pass it something more specific (in my base "ISomeInterface" would be general, and my "SomeDerivedClass" would be specific).

No. Delegate contravariance allows a delegate to reference a method with parameter types that are less derived than in the delegate type. For example, suppose ISomeInterface had a base interface:

interface ISomeBaseInterface
{
}

interface ISomeInterface : ISomeBaseInterface
{
}

And suppose handler took ISomeBaseInterface instead of SomeDerivedClass:

static void handler(object sender, ISomeBaseInterface e) 

Then new SomeClass().SomeEvent += handler would work.

Here's why the original code isn't type safe: When SomeClass raises SomeEvent, it can potentially pass anything that implements ISomeInterface as the data argument. For example, it could pass an instance of SomeDerivedClass, but it could also pass an instance of

class SomeOtherDerivedClass : ISomeInterface
{
}

If you were able to register void handler(object sender, SomeDerivedClass e) with the event, that handler would wind up being invoked with SomeOtherDerivedClass, which doesn't work.

In summary, you can register event handlers that are more general than the event type, not event handlers that are more specific.

UPDATE: You commented:

Well, I actually want to iterate through the list and check the types. So if the event was to be fired with a data object of type let's say SomeOtherDerivedObject, then the program would iterate through the list of methods that are subscribed to the event until it finds one that matches the signature (object, SomeOtherDerivedObject). So the event itself would only be used to store, not to actually call the delegates.

I don't think C# lets you declare an event that works with arbitrary delegate types. Here's how you can write methods that add event handlers and invoke them:

class SomeClass
{
    private Delegate handlers;

    public delegate void SomeEventDelegate<in T>(object sender, T data);

    public void AddSomeEventHandler<T>(SomeEventDelegate<T> handler)
    {
        this.handlers = Delegate.Combine(this.handlers, handler);
    }

    protected void OnSomeEvent<T>(T data)
    {
        if (this.handlers != null)
        {
            foreach (SomeEventDelegate<T> handler in
                this.handlers.GetInvocationList().OfType<SomeEventDelegate<T>>())
            {
                handler(this, data);
            }
        }
    }
}