In C#, è necessario chiamare il costruttore di base?

Question

In C#, se ho una classe ereditata con un costruttore predefinito, devo chiamare esplicitamente il costruttore della classe base o verrà chiamato implicitamente?

class BaseClass
{
    public BaseClass()
    {
        // ... some code
    }
}
class MyClass : BaseClass
{
    public MyClass() // Do I need to put ": base()" here or is it implied?
    {
        // ... some code
    }
}

Answer 1

Non è necessario chiamare esplicitamente il costruttore di base, verrà chiamato implicitamente.

Estendi un po' il tuo esempio e crea un'applicazione console e potrai verificare tu stesso questo comportamento:

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClass foo = new MyClass();

            Console.ReadLine();
        }
    }

    class BaseClass
    {
        public BaseClass()
        {
            Console.WriteLine("BaseClass constructor called.");
        }
    }

    class MyClass : BaseClass
    {
        public MyClass()
        {
            Console.WriteLine("MyClass constructor called.");
        }
    }
}

Answer 2

È implicito, a condizione che non abbia parametri.Questo perché tu è necessario implementare costruttori che assumano valori, vedere il codice seguente per un esempio:

public class SuperClassEmptyCtor
{
    public SuperClassEmptyCtor()
    {
        // Default Ctor
    }
}

public class SubClassA : SuperClassEmptyCtor
{
    // No Ctor's this is fine since we have
    // a default (empty ctor in the base)
}

public class SuperClassCtor
{
    public SuperClassCtor(string value)
    {
        // Default Ctor
    }
}

public class SubClassB : SuperClassCtor
{
    // This fails because we need to satisfy
    // the ctor for the base class.
}

public class SubClassC : SuperClassCtor
{
    public SubClassC(string value) : base(value)
    {
        // make it easy and pipe the params
        // straight to the base!
    }
}

Answer 3

È implicito per i costruttori di base senza parametri, ma è necessario per i valori predefiniti nella classe corrente:

public class BaseClass {
    protected string X;

    public BaseClass() {
        this.X = "Foo";
    }
}

public class MyClass : BaseClass
{
    public MyClass() 
        // no ref to base needed
    {
        // initialise stuff
        this.X = "bar";
    }

    public MyClass(int param1, string param2)
        :this() // This is needed to hit the parameterless ..ctor
    {
         // this.X will be "bar"
    }

    public MyClass(string param1, int param2)
        // :base() // can be implied
    {
         // this.X will be "foo"
    }
}

Answer 4

È implicito.

Answer 5

Una classe derivata è costruita sulla classe base.Se ci pensi, l'oggetto base deve essere istanziato in memoria prima che la classe derivata possa essere aggiunta ad esso.Quindi l'oggetto base verrà creato durante la creazione dell'oggetto derivato.Quindi no, non chiami il costruttore.

Answer 6

Per quanto ne so, devi chiamare il costruttore di base solo se devi trasmettergli dei valori.

Answer 7

Non è necessario chiamare esplicitamente il costruttore di base, verrà chiamato implicitamente, ma a volte è necessario passare i parametri al costruttore, in tal caso puoi fare qualcosa del tipo:

using System;
namespace StackOverflow.Examples
{
    class Program
    {
        static void Main(string[] args)
        {
            NewClass foo = new NewClass("parameter1","parameter2");
            Console.WriteLine(foo.GetUpperParameter());
            Console.ReadKey();
        }
    }

    interface IClass
    {
        string GetUpperParameter();
    }

    class BaseClass : IClass
    {
        private string parameter;
        public BaseClass (string someParameter)
        {
            this.parameter = someParameter;
        }

        public string GetUpperParameter()
        {
            return this.parameter.ToUpper();
        }
    }

    class NewClass : IClass
    {
        private BaseClass internalClass;
        private string newParameter;

        public NewClass (string someParameter, string newParameter)
        {
            this.internalClass = new BaseClass(someParameter);
            this.newParameter = newParameter;
        }

        public string GetUpperParameter()
        {
            return this.internalClass.GetUpperParameter() + this.newParameter.ToUpper();
        }
    }
}

Nota:Se qualcuno conosce una soluzione migliore, per favore, me lo dica.