una - En C#, ¿necesita llamar al constructor base?

sobrecarga de metodos en java

Question

En C #, si tengo una clase heredada con un constructor predeterminado, ¿tengo que llamar explícitamente al constructor de la clase base o se llamará 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

AFAIK, solo necesitas llamar al constructor base si necesitas pasarle cualquier valor.

Answer 2

Está implícito para los constructores sin parámetros base, pero es necesario para los 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 3

Está implícito, siempre que no tenga parámetros. Esto se debe a que necesita implementar constructores que tomen valores ; consulte el siguiente código 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 4

Esta implicado.

Answer 5

No necesita llamar al constructor base explícitamente, se llamará implícitamente, pero a veces necesita pasar parámetros al constructor, en ese caso puede hacer algo como:

using System;
namespace .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 conoce una mejor solución, por favor me dice.

Answer 6

No necesita llamar explícitamente al constructor base, se llamará implícitamente.

Extienda un poco su ejemplo y cree una Aplicación de consola y puede verificar este comportamiento usted 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 7

Una clase derivada se basa en la clase base. Si lo piensas, el objeto base debe crearse una instancia en la memoria antes de que la clase derivada se pueda agregar a él. Por lo tanto, el objeto base se creará en el camino para crear el objeto derivado. Entonces no, no llamas al constructor.