Abstract virtual constructors

[CypherPotato]

Currently, if an abstract class has many constructors, those constructors must be specified in all the derived classes, which leads to a lot of code repetition. Note this example:

public abstract class Animal {
    
    public string Name { get; }
    public AnimalSpecie Specie { get; }
    public AnimalSound[] Sounds { get; }
    
    protected Animal(string name) {
        this.Name = name;
        this.Specie = AnimalSpecie.Unknown;
        this.Sounds = Array.Empty<AnimalSound>();
    }
    
    protected Animal(string name, AnimalSpecie specie) {
        this.Name = name;
        this.Specie = specie;
        this.Sounds = Array.Empty<AnimalSound>();
    }
    
    protected Animal(string name, AnimalSpecie specie, AnimalSound[] sounds) {
        this.Name = name;
        this.Specie = specie;
        this.Sounds = sounds;
    }
}

The example above contains three constructors. For each derived type, I need to implement all three constructors.

public sealed class Dog : Animal {
    public Dog(string name) : base(name) { }
    public Dog(string name, AnimalSpecie specie) : base(name, AnimalSpecie.Dog) { }
    public Dog(string name, AnimalSpecie specie, AnimalSound[] sounds) : base(name, AnimalSpecie.Dog, sounds) { }
}

Note that I want to use the same implementation of the abstract constructor without changing its body. Therefore, I keep the constructor of Dog empty. My proposal is for virtual constructors, which do not need to be implemented in the derived classes to function, and yet still have an implementation.

public abstract class Animal {
    
    public string Name { get; }
    public AnimalSpecie Specie { get; }
    public AnimalSound[] Sounds { get; }
    
    virtual protected Animal(string name) {
        this.Name = name;
        this.Specie = AnimalSpecie.Unknown;
        this.Sounds = Array.Empty<AnimalSound>();
    }
    
    virtual protected Animal(string name, AnimalSpecie specie) {
        this.Name = name;
        this.Specie = specie;
        this.Sounds = Array.Empty<AnimalSound>();
    }
    
    virtual protected Animal(string name, AnimalSpecie specie, AnimalSound[] sounds) {
        this.Name = name;
        this.Specie = specie;
        this.Sounds = sounds;
    }
}

In this way, every class that inherits from Animal will already have its constructor defined, and I will be able to call it as follows:

public sealed class Dog : Animal
{
}

// create my dog instance using the abstract construtor
Dog myDog = new Dog("Bethoven", AnimalSpecie.Dog, AnimalSoundList.Dog);

I could also overload constructors if I wanted to.

public sealed class Dog : Animal
{
    public override Dog(string name, AnimalSpecie specie) : base(name, specie) {
        // do something special in this constructor
    }
}

[HaloFour]

IMO, I'd rather it be a feature of the deriving class, that instructs the compiler to copy the constructors of the base class automatically, as it already does for parameterless constructors. That's how it works in C++:

class A
{
    public: 
        explicit A(int x) {}
};

class B: public A
{
     using A::A; // this syntax in C++ causes the A constructors to be copied to B
};

[CypherPotato]

I think there should still be a separation of a mandatory implementation of the abstract constructor and being able to define that a constructor can be virtua/"copied" by the derived class.

[HaloFour]

See also: #806, #5601, #5732

[HaloFour]

I think it's simpler to support such a feature through constructor copying. Constructors in most OOP languages are intentionally not virtual/inherited because that would make it a challenge to support declaring a derived class that requires more constructor parameters. For example, you couldn't require that string dogTag be a required parameter passed to the constructor of Dog because it would needlessly have to inherit those Animal constructors which do not accept a dogTag. At most you could declare new constructors, and override the existing constructors to throw, but those existing constructors would always erroneously be there.

[TahirAhmadov]

I think this is a textbook scenario for a source generator. If a constructor with the given signature is defined on the derived class, the SG omits that one.

[CyrusNajmabadi]

Omits, or emits? :-)

[TahirAhmadov]

Omits. Meaning, we see the attribute, and copy all the constructors, except for those which were defined by the user.