Can I inherit constructors?

69
votes

I know it's not possible to inherit constructors in C#, but there's probably a way to do what I want to do.

I have a base class that is inherited by many other classes, and it has an Init method that does some initializing taking 1 parameter. All other inheriting classes also need this initializing, but I'd need to create separate constructors for all of them that would like like this:

public Constructor(Parameter p) {
    base.Init(p);
}

That totally violates the DRY principles! How can I have all necessary stuff initialized without creating dozens of constructors?

5
c#dry
Worse than violating DRY principles is violating the invariant principle. Init as the name of a method is generally a strong sign that objects are needlessly existing in invalid states where the only thing they are good for is causing bugs. - Jon Hanna
C# in doesn't really follow DRY at all. This may be bothersome but… honestly, you can't tell me you're not tired of typing public, protected, and private over and over and over? - Slipp D. Thompson
@SlippD.Thompson: That's another area where C++ is actually less wordy than easier languages... The previous one I just saw was regarding exposing base constructors in a derived class. - Mark K Cowan
@SlippD.Thompson Every time you type public, etc., you're specifying a new piece of knowledge. Therefore, it doesn't violate DRY. - MarredCheese

5 Answers

114
votes

You don't need to create loads of constructors, all with the same code; you create only one, but have the derived classes call the base constructor:

public class Base
{
    public Base(Parameter p)
    {
        Init(p)
    }

    void Init(Parameter p)
    {
        // common initialisation code
    }
}

public class Derived : Base
{
    public Derived(Parameter p) : base(p)
    {
 
    }
}
15
votes

Change the init function to it is the constructor for the base class, and then call it from the inherited objects like this:

public InheritedObject(Parameter p) : base(p)
{
}

The base constructor will be invoked before any code in the constructor itself runs.

9
votes

The only way to not repeat the base.Init call is to instead call the base constructor

class Base
{
  public Base(Parameter p)
  {
    this.Init(p)
  }

  private void Init(Parameter p)
  {
      ...
  }
}

class Inherited : Base
{
   public Inherited(Parameter p)
     : base(p)
   {
      // other constructor logic, but Init is already called.
   }
}
4
votes

You can't inherit constructors but you can call them from your derived children's constructors. If you make the base classes default constructor private it will force you to select a base constructor every time you create a derived class. 

class A
{
    protected A(int x)
    {

    }
}
class B : A
{
    B(int x)
        : base(x)
    {

    }
}
3
votes

Something like this?

public Constructor(Parameter p) : base(p) {

}

And the base class:

public Base(Parameter p)
{
    Init(p);
}

You can even mark your Init method as virtual, so you can do some sweet override in your other classes, if need be! ;)

public virtual void Init() { }

and in your other classes:

public override void Init() { base.Init(); //Do other stuff }