Access subclass' property from base class' constructor

Question

I discovered something strange, which I didn't expect to work, actually works. I can access a subclass' (constant) property from the base class' constructor:

public abstract class Parent {

  public Parent() {
    var constName = ConstName;            // <-- surprisingly, this works  
    var randomName = RandomName;          // <-- surprisingly, this works  
  }

  public abstract string ConstName { get; }

  public abstract string RandomName { get; }

}


public class Child : Parent {

  public override string ConstName { get { return "Mike"; } }

  public override string RandomName { get { return new Random().Next().ToString(); } }

}

Name is a non-static property rather than field. I always thought a type's initializers (for static and const fields) were executed, then those of its base class, then the base ctor and then the subclass' ctor. Which means that the child is not fully constructed yet while in the parent ctor.

Is this "legal" C# which will work under all circumstances? Why does this work?

EDIT:

No it's not a dupe question. That one doesn't have the class schema in my question.

Answer 1

Parent has an abstract property Parent.Name. Because of the word abstract, you promise that instances of (subclasses of) Parent will implement property Name. if they don't, you can't create an object of it.

Note that I say: instances cannot be created. If a subclass doesn't implement property Name, the class can exist, but you can't instantiate it.

Class Parent doesn't implement property Name, hence you can't instantiate Parent.

Class Child however implements Name, hence you can instantiate it, and because you promised that every object (=instantiation) of class Parent has a property Name, you can be sure that although all you know is that it is a Parent, you also know that it has a Name.

This is the basic principle of polymorphism in subtyping Wikipedia about polymorphism

It might be the main reason why you would want to subclass.