Proposal: Contravariant parameter types

[Lehonti]

As we all know, the feature of covariant return types will likely be added to C# 9

What about contravariant parameter types, for symmetry? Something like this:

class StringWriterHandler
{
    virtual void Handle (StringWriter writer)...
}

class TextWriterHandler : StringWriterHandler
{
    // Handles broader class of objects, can of course still handle original
    override void Handle (TextWriter writer)...
}

Do you see any issues with a feature like this?

[svick]

I think the main issue is that this feature is quite a lot less useful than covariant return types, especially considering that C# doesn't support overloading on return types, but it does support overloading on parameter types.

This means that if you want to have covariant return types in C# 8.0, you can't work around the missing feature by writing e.g.:

class Base
{
    public virtual Base Clone() { … };
}

class Derived : Base
{
    public virtual Derived Clone() { … }
    public sealed override Base Clone() => Clone(); // somehow call the other overload here
}

But you can quite easily work around missing contravariant parameter types by writing:

class TextWriterHandler : StringWriterHandler
{
    // Handles broader class of objects, can of course still handle original
    public virtual void Handle(TextWriter writer) { … }
    public sealed override void Handle(StringWriter writer) => Handle((TextWriter)writer);
}

[HaloFour]

@Lehonti

Symmetry is not a goal of the language. If the proposal can't provide enough benefit to stand on its own it wouldn't be considered. Contravariant parameters would be a lot more effort for a lot less reward. With return types there is exactly one type that can be covariant which makes the rules that govern the language feature very simple. You can have any number of parameters, each of which being potentially contravariant. Covariant returns have a real impact on the caller of those methods allowing for properly fluent calls without requiring the consumer to interpret and cast the result. There's no such benefit to the caller with contravariant parameters.

[CyrusNajmabadi]

The demand for covariant returns is also consistently far higher than that if contravariance.

[333fred]

Personally, the only time I would think that this would be actually useful would be delegate relaxation. Otherwise, introducing a new overload with wider parameter types on a derived class, and overriding the original method to forward seems perfectly reasonable.

[ViIvanov]

@gafter answered about this here

It would involve extreme breaking changes in common scenarios. In other words, impossible.

with example here:

One example of a breaking change that we would have if we add contravariant parameters:

class Base
{
    public virtual void M(string o) { }
    public virtual void M(object o) { }
}
class Derived : Base
{
    public override void M(object o) { } // oops, now overrides both methods
}

[Dylan-Erskine]

Would contravariant properties with setters be a possibility, or does it have the same problems?