Why are constructors not inherited?

Question

I'm guessing there's something really basic about C# inheritance that I don't understand. Would someone please enlighten me?

Answer 1

Constructors in superclasses are called, whether you explicitly call them or not. They chain from the parent class down. If your constructor doesn't explicitly call a constructor in it's superclass then the default constructor in that class is called implicitly before the code of your constructor.

Answer 2

The default constructor will always be called .

class Bar : Foo { }

When Bar is instantiated it will call the Foo() constructor by default.

class Foo {
    public Foo(int someVar) {}
}

class Bar : Foo {
    public Bar() : base(42) {}
}

If there is not parameterless constructor you will be required to define which one to use and pass the parameters.

Answer 3

Sometimes, when subclassing, you want to restrict the conditions required to create an instance of the class.

Let me give you an example. If classes did inherit their superclass constructors, all classes would have the parameterless constructor from Object. Obviously that's not correct.

Answer 4

I assume you mean:

class Foo
{
   public Foo(int someVar) {}
}

class Bar : Foo
{
    // Why does Bar not automatically have compiler generated version of 
    Bar(int someVar): Foo(someVar) {}
}

I believe this is inherited from C++ (and Java).
But assuming you did have this and Bar had some other member variables. Would this not introduce the posability of the compiler generated constructor accdently being used and not initialising the members of BAr.

Answer 5

If you think about what would happen if constructors were inherited, you should start to see the problem.

As every type in .NET inherits from Object (which has a parameterless constructor), that means every type that you create would be forced to have a parameterless constructor. But there are many types where a parameterless constructor doesn't make sense.

There would also be a problem with versioning. If a new version of your base type appears with a new constructor, you would automatically get a new constructor in your derived type. This would be a bad thing.

There's also a more philosophical argument. Constructors are really concerned with type collaboration rather than type responsibilities. It's saying "This is what I need" and not "This is what I do."