PROPOSAL: Constraint Inheritance / Inference

[TonyValenti]

Today in C#, constraints on methods get automatically "inherited" by derived classes and do not need to be redefined. This is a good thing and helps keep my code clean, concise, and readable, and when you need to refactor a base method, you only have to refactor the base method.

    public class BaseClass {
        public virtual string DoSomething<T>(T Item) where T : new() {
            return new T().ToString();
        }
    }


    public class DerivedClass : BaseClass {
        public override string DoSomething<T>(T Item) 
            //where T : new() <- This is not necessary.
            {
            return base.DoSomething<T>(Item);
        }
    }

That is all goodwhen you're working with generic methods, but when you're working with Generic classes, you have a different story. Here is an example:

    public class BaseClass<T> where T : new() {
        public virtual string DoSomething(T Item) {
            return new T().ToString();
        }

    }

    public class DerivedClass<T> : BaseClass<T>
        //This line should not be needed but it is.
        where T : new()
        {

    }

Today, with a class definition like this, if I refactor BaseClass<T> and add a new constraint onto <T>, I then have to go find every derived class that extend's BaseClass<T> and copy/paste that new constraint into DerivedClass<T>'s definition. This has a couple of problems:

1. I have to clutter DerivedClass<T> with redefinitions of base class stuff.
2. When refactoring the base class, I am forced to refactor the derived class.

In the example above, DerivedClass's <T> should automatically "inherit" the constraints that are placed on it by BaseClass<T>.

In order to simplify things and preserve compatibility with existing code, using the where clause in a derived class should specify additional constraints that may or may not already be inferred from its usage.

[axel-habermaier]

Eric Lippert outlined the problems with this proposal in an interesting-to-read (as usual) blog post.

[alrz]

Dupe of #8041

[gafter]

We are now taking language feature discussion on https://github.com/dotnet/csharplang for C# specific issues, https://github.com/dotnet/vblang for VB-specific features, and https://github.com/dotnet/csharplang for features that affect both languages.