En C#, qué se necesita para llamar al constructor base?

Question

En C#, si he heredado una clase con un constructor por defecto, tengo que llamar explícitamente a la clase base' o constructor se llama implícitamente?

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

Usted no necesita llamar explícitamente al constructor base, que se llama implícitamente.

Extender su ejemplo un poco y crear una Aplicación de Consola y se puede comprobar este comportamiento por sí mismo:

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

Es implícita, siempre que sea sin parámetros.Esto es debido a que necesidad de implementar los constructores que tomar los valores, ver el código de abajo para ver un ejemplo:

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

Es implícita para la base de constructores sin parámetros, pero es necesario para valores predeterminados en la clase actual:

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

Es implícita.

Answer 5

Una clase derivada es construido sobre la base de la clase.Si usted piensa acerca de ello, el objeto base tiene que ser instanciado en la memoria antes de la clase derivada puede ser anexado a ella.Así que la base objeto será creado en el camino a la creación de la derivada de objeto.Así que no, no se llama al constructor.

Answer 6

AFAIK, sólo necesitas llamar al constructor base si necesita pasar por cualquiera de sus valores.

Answer 7

Usted no necesita llamar al constructor base explícitamente que se llama implícitamente, pero a veces se necesita pasar parámetros al constructor en ese caso, puedes hacer algo como:

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:Si alguien sabe una mejor solución, por favor me dice.