Question

要消除复杂性，让我使用下面的代码片段进行解释。我想调用父母的 sum 方法。现在，此代码将递归调用并最终导致stackoverflow错误

public class Program
{
    public static void Main()
    {
        var chd_obj = new child();
        chd_obj.x = 10;
        chd_obj.y=20;
        chd_obj.sum();
    }

    class parent {
        public int x {get;set;}
        public int y {get;set;}

        public  virtual void sum(){
            Console.WriteLine("From Base" + x+y);   
        }
        public virtual void DoSum(){
            this.sum(); // this should call the sum method in the parent class . 
                        //But it is calling the child *sum* method
        }
    }

    class child:parent {

        public override void sum(){
            base.DoSum();
        }

    }
}

Answer 1

我不知道是否有更好的解决方案，但是我会声明一个私有方法，基类中的sum和基类中的DoSum都将调用：

private void SumImpl() {
    Console.WriteLine("From Base" + x+y);   
}

public virtual void sum(){
    SumImpl();
}
public virtual void DoSum(){
    SumImpl();
}

Answer 2

您无法在C＃中执行此操作。有一些解决方法，具体取决于您的实际应用。

通常，该解决方案要求您将基本功能提取到一种或多种非虚拟方法中。

private void SumCore()
{
    // Do stuff.
}

public virtual void Sum()
{
    SumCore();
}

Answer 3

您陷入无限循环，导致子类在基类中调用Dosum方法，并再次从基类调用子类中调用Dosum，这就是为什么您看到StackOverflow异常的原因。

您应定义对编译器的总和，以使派生类无法多次从基类中再次调用。

  static void Main(string[] args)
    {
        child sample = new child();
        sample.x = 20;
        sample.y = 15;
        sample.sum();
        Console.ReadLine();
    }

    public class parent
    {
        public int x { get; set; }
        public int y { get; set; }

        public virtual void sum()
        {
            Console.WriteLine("From Base " + (x + y));
        }
        public virtual void DoSum()
        {
            parent a = new parent();
            a.x = this.x;
            a.y = this.y;
            a.sum();
        }

    }

    class child : parent
    {
        public override void sum()
        {
            base.DoSum();
        }
    }

通过这种方式，无需创建新方法

从基类调用基方法

3 个答案: