Make Generic EventHandler Contravariant

[TylerBrinkley]

Is there any reason the generic EventHandler delegate was not made contravariant? As opposed to creating my own custom EventHandler delegate it would be much better if I could just use the built-in one for my use case listed below.

public abstract class Foo
{
    public event EventHandler<FooEventArgs> FooEvent
    {
        add
        {
            FooEventAddOrRemove(value, true);
        }
        remove
        {
            FooEventAddOrRemove(value, false);
        }
    }

    protected abstract void FooEventAddOrRemove(EventHandler<FooEventArgs> handler, bool toAdd);
}

public sealed class Foo<T> : Foo
{
    public new event EventHandler<FooEventArgs<T>> FooEvent;

    protected override void FooEventAddOrRemove(EventHandler<FooEventArgs> handler, bool toAdd)
    {
        if (toAdd)
        {
            FooEvent += handler; // Compile error, Cannot implicitly convert type 'System.EventHandler<FooEventArgs>' to 'System.EventHandler<FooEventArgs<T>>'
        }
        else
        {
            FooEvent -= handler; // Compile error, Cannot implicitly convert type 'System.EventHandler<FooEventArgs>' to 'System.EventHandler<FooEventArgs<T>>'
        }
    }
}

public abstract class FooEventArgs : EventArgs
{
    public object Value => GetValue();

    protected abstract object GetValue();
}

public sealed class FooEventArgs<T> : FooEventArgs
{
    public new T Value { get; set; }

    protected override object GetValue() => Value;
}

[JanEggers]

this cant work,

when raising the event in Foo you pass FooEventArgs.

but all handlers you register in Foo<T>require FooEventArgs<T>

if u flip inheritance it can work, remove eventhandler in Foo and derive Foo from Foo<object>
`

[TylerBrinkley]

If you swap EventHandler with ContravariantEventHandler as defined below this works just fine. Events can only be raised in the defining type or nested types. Since Foo only specifies the add and remove event handler operations this is entirely legal.

public delegate void ContravariantEventHandler<in TEventArgs>(object sender, TEventArgs e);

[TylerBrinkley]

After poking around on StackOverflow I found this question which seems to imply that it was originally made contravariant but there were issues internally related to combining multi-cast delegates. Does anyone know if this is still an issue?

http://stackoverflow.com/questions/1120688/event-and-delegate-contravariance-in-net-4-0-and-c-sharp-4-0

[iskiselev]

I believe #4556 is root cause for this restriction.

[dotnet-policy-service]

Due to lack of recent activity, this issue has been marked as a candidate for backlog cleanup. It will be closed if no further activity occurs within 14 more days. Any new comment (by anyone, not necessarily the author) will undo this process.

This process is part of our issue cleanup automation.

[dotnet-policy-service]

This issue will now be closed since it had been marked no-recent-activity but received no further activity in the past 14 days. It is still possible to reopen or comment on the issue, but please note that the issue will be locked if it remains inactive for another 30 days.