Public Constructors in Classes should be usable in Generic Methods

[LupusInferni315]

If I have a type

public abstract class SomeAbstractClass {
    public string Key { get; set; }
    public SomeAbstractClass(string key) => Key = key;
    public abstract SomeAbstractClass(string key) => Key = key; // perhaps something like this, to ensure that a child class has exactly that constructor.
}

and a child class

public class SomeChildClass {
    public SomeChildClass(string key) : base(key) {}
}

and a method

public T CreateNewAbstractChild<T>(string key) where T : SomeAbstractClass {
    return new T(key); // this should 'call' the public constructor.
}

[HaloFour]

Constructors aren't inherited. There is no guarantee that any given class that extends SomeAbstractClass will have a compatible constructor.

Using abstract static interface members you can require that the generic type provide a factory method:

public interface ISomeInterface<T> where T : ISomeInterface<T> {
    string Key { get; set; }
    static abstract T Create(string key);
}

public class SomeChildClass : ISomeInterface<SomeChildClass> {
    public string Key { get; set; }

    private SomeChildClass(string key) => Key = key;

    public static SomeChildClass Create(string key) => new SomeChildClass(key);
}

public T CreateNew<T>(string key) where T : ISomeInterface<T> {
    return T.Create(key);
}

[LupusInferni315]

I am aware of that, hence the second portion of the abstract class with the 'abstract' constructor that would ensure that the child class must have a constructor with a matching signature, this would not prevent a class from implementing additional constructors simply that any abstract constructors must be implemented, perhaps a better modifier would be virtual but the idea is the same regardless.

[DavidArno]

Since a mechanism already exists to achieve what you want to achieve (abstract static interface members), what benefit would your request bring to the language that isn't already provided by the existing mechanism?

[LupusInferni315]

Given that prior to making this post I did not know that you could make an abstract static interface member the only additional benefit would be that it would not require an interface to be useable.

[LupusInferni315]

The specific case that led to my proposal, was such that the abstract class and it's intended children only differed in the exposed GetValue method, the only required field and it's initialization occurred within the abstract class