C# 使用抽象重写并调用基类

考虑以下事项：

void Main()
{
    var c = new C();
    c.Print();
}

public abstract class A
{
    public virtual void Print()
    {
        Console.WriteLine("I'm in A!");
    }
}

public abstract class B : A
{
    public abstract override void Print();
}

public class C : B
{
    public override void Print()
    {
        Console.WriteLine("I'm in C!");

        base.Print();
    }
}

当然，这不会编译，因为它认为我试图调用B的print方法，这是抽象的。我想做的是调用C的print方法，然后让它调用base的print方法，这将“链接”回A的print方法。我希望输出为-

I'm in C!
I'm in A!

这样做可能吗？我做错了什么

---

编辑：我想补充一点，关于上面代码的要点是，我试图强制任何扩展B的人实现他们自己的打印方法。

如果您从

B

中删除覆盖的尝试：

public abstract override void Print();

这正是它将要做的

完整代码：

    static void Main(string[] args)
    {
        var c = new C();
        c.Print();

        Console.ReadLine();
    }

    public abstract class A
    {
        public virtual void Print()
        {
            Console.WriteLine("I'm in A!");
        }
    }

    public abstract class B : A
    {
    }

    public class C : B
    {
        public override void Print()
        {
            Console.WriteLine("I'm in C!");
            base.Print();
        }
    }

I'm in C!
I'm in A!

结果：

    static void Main(string[] args)
    {
        var c = new C();
        c.Print();

        Console.ReadLine();
    }

    public abstract class A
    {
        public virtual void Print()
        {
            Console.WriteLine("I'm in A!");
        }
    }

    public abstract class B : A
    {
    }

    public class C : B
    {
        public override void Print()
        {
            Console.WriteLine("I'm in C!");
            base.Print();
        }
    }

I'm in C!
I'm in A!

---

如果从

B

中删除覆盖尝试：

public abstract override void Print();

这正是它将要做的

完整代码：

    static void Main(string[] args)
    {
        var c = new C();
        c.Print();

        Console.ReadLine();
    }

    public abstract class A
    {
        public virtual void Print()
        {
            Console.WriteLine("I'm in A!");
        }
    }

    public abstract class B : A
    {
    }

    public class C : B
    {
        public override void Print()
        {
            Console.WriteLine("I'm in C!");
            base.Print();
        }
    }

I'm in C!
I'm in A!

结果：

    static void Main(string[] args)
    {
        var c = new C();
        c.Print();

        Console.ReadLine();
    }

    public abstract class A
    {
        public virtual void Print()
        {
            Console.WriteLine("I'm in A!");
        }
    }

    public abstract class B : A
    {
    }

    public class C : B
    {
        public override void Print()
        {
            Console.WriteLine("I'm in C!");
            base.Print();
        }
    }

I'm in C!
I'm in A!

好吧，你可以

public abstract class A
{
    public virtual void Print()
    {
        Console.WriteLine("I'm in A!");
    }
}

public abstract class B : A
{
    public override void Print()
    {
        base.Print();
    }
}

public class C : B
{
    public override void Print()
    {
        Console.WriteLine("I'm in C!");

        base.Print();
    }
}

这是有效的

public abstract class A
{
    public virtual void Print()
    {
        Console.WriteLine("I'm in A!");
    }
}

public abstract class B : A
{
}

public class C : B
{
    public override void Print()
    {
        Console.WriteLine("I'm in C!");

        base.Print();
    }
}

好吧，你可以

public abstract class A
{
    public virtual void Print()
    {
        Console.WriteLine("I'm in A!");
    }
}

public abstract class B : A
{
    public override void Print()
    {
        base.Print();
    }
}

public class C : B
{
    public override void Print()
    {
        Console.WriteLine("I'm in C!");

        base.Print();
    }
}

这是有效的

public abstract class A
{
    public virtual void Print()
    {
        Console.WriteLine("I'm in A!");
    }
}

public abstract class B : A
{
}

public class C : B
{
    public override void Print()
    {
        Console.WriteLine("I'm in C!");

        base.Print();
    }
}

---

您无法强制类提供自己的实现，毕竟它可以只调用

base.Print（）

，甚至只提供一个空的方法实现

有关类似的讨论，请参见：

---

您无法强制类提供自己的实现，毕竟它可以只调用

base.Print（）

，甚至只提供一个空的方法实现

有关类似的讨论，请参见：

---

使用它public c{public（）：base（）{}Print（）；}看起来层次结构很脆弱，应该重新设计。你需要考虑这里的继承是否合适。为什么你要强迫C的开发人员把代码从A拷贝到粘贴到C？JJMONENO：对不起，我不太明白。我是如何强迫他们这样做的？如果他们想要不同的结果，他们会自己推翻它。由于他们希望得到与A完全相同的结果，最好的方法是使用A中的代码。您阻止他们以一种方式执行此操作，因此他们必须以另一种方式执行此操作。使用它public c{public（）：base（）{}Print（）；}看起来层次结构很脆弱，应该重新设计。你需要考虑这里的继承是否合适。为什么你要强迫C的开发人员把代码从A拷贝到粘贴到C？JJMONENO：对不起，我不太明白。我是如何强迫他们这样做的？如果他们想要不同的结果，他们会自己推翻它。因为他们希望得到与A完全相同的结果，所以最好的方法是使用A中的代码。您阻止他们以一种方式执行此操作，因此他们必须以另一种方式执行此操作。这也是我能想到的最佳答案，但它丢失了我想要的一个元素，即强制扩展B的类实现自己的Print（）。除非B有不同的逻辑，否则您没有向我们展示的其他实现，为什么要包装A？为了添加更多的背景信息，我的大多数实现（比如D、E和F类）都直接扩展了A。在这些情况下，实现Print（）是可选的。但是，如果B用于扩展A，我不希望实现Print是可选的，我希望它是强制性的（我还希望它在另一个扩展层中完成）。这也是我能想到的最好的答案，但它失去了我想要的一个元素，那就是强制扩展B的类实现它们自己的Print（）。除非B有不同的逻辑，否则您没有向我们展示的其他实现，为什么要包装A？为了添加更多的背景信息，我的大多数实现（比如D、E和F类）都直接扩展了A。在这些情况下，实现Print（）是可选的。但是，如果B用于扩展A，我不希望实现Print是可选的，我希望它是强制性的（我还希望它在另一个扩展层中完成）