C#: inheriting constructors

Question

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?

Answer 1

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.

Answer 2

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

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

public class Derived : Base
{
   public Derived(Parameter p) : base(p)
   {

   }
}

Answer 3

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 }

Answer 4

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.
   }
}

Answer 5

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)
    {

    }
}