Make static factory methods possible.

[procodix]

public class A {
	public static A Factory() {
		return new A();
	}
}

public class B : A {}

B::Factory() returns an A not a B, which is a violation of inheritance.

There should be a new keyword like "This". During compilation all static methods with this keyword have to be copied for all subtypes and "This" has to be replaced with the Copy's type. That saves the burden of manually copying the method into every class.

public class A {
	public static This Factory() {
		return new This();
	}
}

public class B : A {
       //compiler generated copy of A.Factory() :
	public static B Factory() {
		return new B();
	}
}

[bernd5]

You may be able to accomplish this by a source generator.

[procodix]

How would that work?

[bernd5]

You would need to make your classes partial.
Then you need something which controls where and what code should be generated. Often this is done with attributes (but you could look for a pattern, too - e.g. static method named "Factory" returning the containing type.

You could write e.g.:

public class A {
        [DynFactory] // this may controls the source generator (could be located in an another assembly)
	public static A Factory() {
		return new A();
	}
}

public partial class B : A 
{      
}

Then the generator could create something like this:

partial class B
{
	public static B Factory() {
		return new B();
	}
}

(containing type replaced with the new containing type)

[procodix]

Thats sounds way too complicated compared to compiler support. A keyword is cleaner and preferred over attributes. Plus: no refactoring, IDE support, ...

[HaloFour]

See: #5413

[yaakov-h]

"copying the method" is impossible due to ref assemblies.

[procodix]

Why? Its a forwarw-only-feature for methods containing the new keyword. Even if you'd write a new app with B::Factory which overrides an ancient assembly's A::Factory, the compiler could generate code to call A::Factory and type cast the result to a B.

[HaloFour]

and type cast the result to a B.

Which would fail because the instance is not a B.

[procodix]

but covariant to B

[HaloFour]

Which doesn't change that the instance is not a B and cannot be cast to B. This is why the generic aspect of the linked proposal is necessary.

[FaustVX]

The proposal is very simple. Copy the method and replace the return types. That is what happens when you copy and paste the method manually.

What happens if your derived class has not he same parameters as the base class:

class Animal(int numOfLegs) {
  public static Animal Factory(int numOfLegs) => new Animal(numOfLegs);
}

class Cat(Color furColor) : Animal(4);

[procodix]

First: You are thinking it completely wrong. Instead of hardcoded class names, you would use This keyword
Second: Your example indeed enforces a constraint to have a specific constructor. Thats totally not a problem to detect. However it would be much easier to use a parameterlesss constructor constraint new(), (compare Swift documentation for requirements of a single parameterless constructor, and constructor chaining), and assign the property manually. The constructor property promotion is a reduced, bad replacement for real universal static methods as factories.

class Animal(int numOfLegs) {
  // this gets copied to Cat class. This gets replaces by the current class
  public static *This* Factory(int numOfLegs) => new *This*(numOfLegs);
}

class Cat(Color furColor) : Animal(4);

// this is, how Swift an PHP do it:
class Cat {
  // copy from anchestor
  public static *This* Factory(int numOfLegs) => new *This*(numOfLegs);
  // call inherited static Factory method. 
  public static *This* Factory(int numOfLegs = 4, int color = "white") => base/This.Factory(numOfLegs).ColorSet(color)
}