Constructor Call Question

[dhuan]

using System;

namespace myProgram
{

    class BaseClass
    {
        public BaseClass()
        {
            Console.WriteLine("Base Class Constructor has been called!");
        }
    }

    class DerivedClass : BaseClass
    {
        public DerivedClass()
        {
            Console.WriteLine("Derived Class Constructor has been called!");
        }
    }

    class Program
    {
        static void Main()
        {
            DerivedClass myObj = new DerivedClass();
        }
    }
}

When making an object of the Derived Class the program calls the constructors from both the base class and the derived class. Is there anyway I can make use of the derived class as an object without calling the constructor from its base class?

[kairozamorro]

Base classes should not include anything you would not want in the derived class. You can however override methods in the base class with methods in the derived class.

[DanFraser]

This is the inheritance effect. DerivedClass is BaseClass, so it will do everything BaseClass does unless you override the method. Constructors can be overriden but only if they are not the default constructor. In this example you have shown it will always run the BaseClass constructor.

[pianorain]

Is there anyway I can make use of the derived class as an object without calling the constructor from its base class?

Why would you want to do this? What problem are you trying to solve?

[C_ntua]

Read here

I believe that a :base() is added to your constructor. Thus

class DerivedClass : BaseClass
    {
        public DerivedClass() :base()
        {
            Console.WriteLine("Derived Class Constructor has been called!");
        }
    }

thus you cannot avoid calling the base constructor. This should be done in all constructors that don't specify an initializer.

What you would do is have a base class with an empty constructor. And derive from there. In your case you could have a BaseBaseClass() the same as BaseClass() with an empty constructor. Preferably it will be an abstract class since you won't want to use it.

Eh, of course you can get tricky and specify two constructors in the base class. One can be

public BaseClass(int useless) {}

and now you can do

 class DerivedClass : BaseClass
    {
        public DerivedClass() : base(0)
        {
            Console.WriteLine("Derived Class Constructor has been called!");
        }
    }

and call the empty constructor.

The best is the first method (base abstract class). This implies good class planning. But you can use a workaround in case you already have planned/coded your classes and you just need to do this modification.

The reason this happens is that the compiler needs to call a constructor for the base class so what you want is to have an empty constructor and then it is just a matter of coding it nicely to call that empty constructor