在C#中,你需要调用基础构造函数吗?

时间:2008-08-20 14:26:33

标签: c# inheritance constructor

在C#中,如果我有一个带有默认构造函数的继承类,我是否必须显式调用基类的构造函数或者是否会隐式调用它?

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

7 个答案:

答案 0 :(得分:53)

您不需要显式调用基础构造函数,它将被隐式调用。

稍微扩展您的示例并创建一个控制台应用程序,您可以自己验证此行为:

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.");
        }
    }
}

答案 1 :(得分:28)

如果它是无参数的,则暗示。这是因为您需要实现带值的构造函数,请参阅下面的代码示例:

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!
    }
}

答案 2 :(得分:8)

它隐含在基本无参数构造函数中,但当前类中的默认值需要它:

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"
    }
}

答案 3 :(得分:6)

暗示。

答案 4 :(得分:4)

派生类是基于基类构建的。如果你考虑一下,基础对象必须在内存中实例化,然后才能将派生类附加到它上面。因此,将在创建派生对象的方式上创建基础对象。所以不,你不要调用构造函数。

答案 5 :(得分:0)

AFAIK,如果你需要传递任何值,你只需要调用基础构造函数。

答案 6 :(得分:-3)

您不需要显式调用基本构造函数,它将被隐式调用,但有时您需要将参数传递给构造函数,在这种情况下,您可以执行以下操作:

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

注意:如果有人知道更好的解决方案,请告诉我。