Why are constructors not inherited in C#?

Question

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

Answer 1

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 2

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 3

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 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 nearly every type in .NET inherits from Object (which has a parameterless constructor), that means almost 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, and a specific instance of the fragile base class problem.

There's also a more philosophical argument. Inheritance is about type responsibilities (this is what I do). Constructors are about type collaboration (this is what I need). So inheriting constructors would be mixing type responsibility with type collaboration, whereas those two concepts should really remain separate.