Question

Pass a derived class reference to a base class reference

does this means that call a base class from the derived class, like the constructor triangle will call the base class?

class Shape {
public int width, height;
 public Shape(int x) { 
    width = height = x; 
    } 
}

class Triangle : Shape { 
 public string style;
  public Triangle(int x) : base(x) { 
    style = "isosceles";  
  } 
}

Answer 1

Yes, it will instruct the runtime to invoke that base Shape constructor before Triangle’s.

The logic executes in this order:

1. Execute Shape(int x)
2. Execute Triangle(int x)

You can therefore direct calls to different constructor overloads if you have them. Also note that if your base class has a parameterless constructor, there’s essentially an implicit base() added if you do not specify one. That means if your base class does not have a parameterless constructor, all subclasses must make a valid base(...parameters...) in their constructor.

Also, you can use this() instead of base to target a constructor on the current subclass class.

public class MyBaseClass
{
    public MyBaseClass()
    {
        Console.WriteLine("MyBaseClass Parameterless");
    }

    public MyBaseClass(string message)
    {
        Console.WriteLine("MyBaseClass Message: " + message);
    }
}

public class MySubClass
{
    public MySubClass()
    {
        Console.WriteLine("MySubClass Parameterless");
    }

    public MySubClass(string message)
        : base(message)
    {
        Console.WriteLine("MySubClass Message: " + message);
    }

    public MySubClass(bool someUselessFlag)
        : this()
    {
        Console.WriteLine("MySubClass bool someUselessFlag constructor");
    }
}

The outputs would be:

var a = new MySubClass();
//outputs:
//MyBaseClass Parameterless
//MySubClass Parameterless

var b = new MySubClass("Hello World!");
//outputs:
//MyBaseClass Message: Hello World!
//MySubClass Message: Hello World!

var c = new MySubClass(true);
//outputs:
//MyBaseClass Parameterless
//MySubClass Parameterless
//MySubClass bool someUselessFlag constructor

Constructors chain on themselves until they eventually call the Object() base constructor. That’s why var c = new MySubClass(true) calls more than two constructors.