En C#, faut-il appeler le constructeur de base ?

Question

En C#, si j'ai une classe héritée avec un constructeur par défaut, dois-je appeler explicitement le constructeur de la classe de base ou sera-t-il implicitement appelé ?

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

Vous n'avez pas besoin d'appeler explicitement le constructeur de base, il sera appelé implicitement.

Étendez un peu votre exemple et créez une application console et vous pourrez vérifier ce comportement par vous-même :

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

C’est implicite, à condition qu’il soit sans paramètre.C'est parce que tu besoin d'implémenter des constructeurs qui prennent des valeurs, voir le code ci-dessous pour un exemple :

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

C'est implicite pour les constructeurs de base sans paramètre, mais c'est nécessaire pour les valeurs par défaut dans la classe actuelle :

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

C’est implicite.

Answer 5

Une classe dérivée est construite sur la classe de base.Si vous y réfléchissez, l'objet de base doit être instancié en mémoire avant que la classe dérivée puisse y être ajoutée.Ainsi, l'objet de base sera créé lors de la création de l'objet dérivé.Alors non, vous n'appelez pas le constructeur.

Answer 6

AFAIK, vous n'avez besoin d'appeler le constructeur de base que si vous devez lui transmettre des valeurs.

Answer 7

Vous n'avez pas besoin d'appeler explicitement le constructeur de base, il sera implicitement appelé, mais parfois vous devez transmettre des paramètres au constructeur dans ce cas, vous pouvez faire quelque chose comme :

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();
        }
    }
}

Note:Si quelqu'un connaît une meilleure solution, dites-le-moi.