在.NET 4.0中，有没有更优雅的方法？

Question

It appears that C# 4.0 does not support covariance (using the "in" keyword) on parameters in overrides; is that the case?

If so, is there a more elegant way to do this?

CONTEXT

public interface IBaseEvent { /* ... */ }

public interface IDerivedEvent : IBaseEvent { /* ... */ }

public class MoreDerivedEvent : IDerivedEvent { /* ... */ }

I have a set of classes that handle MoreDerivedEvent . Due to limitations of the event handling code, I can only register a single event handler for MoreDerivedEvent , and I don't know that it will handle registering interfaces as events (I don't believe it will, as the guidance is to use classes explicitly). So, in order to handle the event appropriately, I've defined the handlers as follows:

public class BaseType
{
    protected virtual void Handle(IBaseEvent @event) { /* Do Base Stuff */ }
}

public class DerivedType
{
    protected virtual void Handle(IDerivedEvent @event)
    {
        /* Do Derived Stuff */
        Handle((IBaseEvent)@event);
    }

    protected override sealed void Handle(IBaseEvent @event)
    {
        base.Handle(@event);
    }
}

This obviously does not provide true inheritance, and I'll probably just flatten the types derived from DerivedType and BaseType if I can't solve this issue. But I figured I'd put it to the Stack Overflow community first.

Answer 1

First off, parameter type covariance is not typesafe . Suppose we allowed parameter type covariance:

class B 
{
    public virtual void Frob(Animal a)
    {
    }
}
class D : B
{
    public override void Frob(Giraffe g)
    {
    }
}
....
B b = new D();
b.Frob(new Tiger());  // Calls D.Frob, which takes a giraffe.

No, covariance is not at all what you want. It is unsafe. You want covariance on return types , not on parameter types . On parameter types you want contravariance :

class B 
{
    public virtual void Frob(Giraffe g)
    {
    }
}
class D : B
{
    public override void Frob(Animal a)
    {
    }
}
....
B b = new D();
b.Frob(new Giraffe());  // Calls D.Frob, which takes any animal.

No problem there.

Unfortunately for you, C# supports neither return type covariance nor parameter type contravariance. Sorry!

Answer 2

First you need an interface to specify the contra-variance on

public interface IBaseHandler<in T> where T : IBaseEvent
{
    void Handle(T handle);
}

Then you can define a base class to do 'base stuff'

public class BaseType<T> : IBaseHandler<T> where T : IBaseEvent
{
    public virtual void Handle(T handle) { /* do base stuff */} 
}

which will then allow you to override for the MoreDerivedEvent

public class MoreDerivedType : BaseType<MoreDerivedEvent>
{
    public override void Handle(MoreDerivedEvent handle)
    {
        base.Handle(handle);
    }
}