Inheritance And Constructors In C#

In this blog, you will learn about inheritance and constructors in C#.

If you provide the constructor in the derived class, you must provide an appropriate constructor in the base class. If you have provided a constructor in the derived class and no constructor in the base class, the compiler will flag an error.

Now, suppose I have a constructor in the derived/subclass class and in the base class as well, remember that the base class constructor will be called first and then derived class constructor. If I create the instance of the derived class, let us see this behavior with an example.

Suppose, I have two classes, given below:

class Base
{
    public Base() {
        Console.WriteLine("Inside Base Constructor");
    }
    ~Base() {
        Console.WriteLine("Inside Base Destructor");
    }
}
class Derived: Base {
    public Derived() {
        Console.WriteLine("Inside The Derived Constructor");
    }
    ~Derived() {
        Console.WriteLine("Inside The Derived Destructor");
    }
}

The derived class is getting inherited from the base class. Both the classes have a default constructor, where I am printing appropriate messages.

Now, if I create an instance of a derived class as

Derived obj=new Derived();

The output of my program will be:



The important point to note from this output is that the base class constructor is being called first and then derived class constructor. Many interviewers will give code snap like this and will ask for the output. Thus, remember it. Another point to note is that the default constructor (constructor without any parameters is called a default constructor) of base class is being called automatically from the derived class constructor.

Now, I want to manually call the constructor of the base class from the derived class constructor. We need to do this, using base keyword.

Let us see the example.

Suppose, I have two classes, given below:

class Class1
{
    protected int a, b;
    public Class1() {
        a = 0;
        b = 0;
        Console.WriteLine("Inside base class default constructor");
    }
    public Class1(int a, int b) {
        this.a = a;
        this.b = b;
        Console.WriteLine("Inside base class parameterized constructor");
    }
}
class Class2: Class1 {
    int c;
    public Class2(int a, int b, int c): base(a, b) {
        this.c = c;
        Console.WriteLine("Inside derived class parametrized constructor");
    }
}

Observe the line public Class2(int a, int b, int c) : base(a, b)

Now, here I am calling the base class constructor, using base(a, b)

Now, when I create the instance of the derived class as

Class2 obj2 = new Class2(2, 3, 4);

Thus, the base class constructor, that takes two parameters is called first and then the derived class constructor. Output of this is:



Note that only the default constructors of the base class will be called automatically, when we create an instance of the derived class, as we have seen in the first example. If we want to call parameterized constructor of the base class, you need to use a base keyword. One thing to note is, in inheritance from the derived class constructor, the base class constructor will be called either automatically or manually (using base keyword)

If we create a constructor in the derived class, no constructor in the base class compiler will flag an error. Thus, when you create a constructor in the derived class, you must create a constructor in the base class as well.