重写被重写的方法（C#）

我试图在C#中重写一个被重写的方法（如果有意义的话！）

我有一个类似于下面的场景，但是当我在“C”类的SampleMethod（）中有一个断点时，它没有被命中，而在“B”方法中有相同的断点被命中

public class A
{
      protected virtual void SampleMethod() {}
}

public class B : A 
{
      protected override void SampleMethod()
      {
           base.SampleMethod(); 
      }
}

public class C : B
{
      protected override void SampleMethod() 
      {
           base.SampleMethod(); 
      }
}

提前谢谢

---

编辑：

好的，上下文将有助于：

---

这是在复合控件的上下文中，因此类a继承自CompositeControl，并在重写CreateChildControls（）方法后调用SampleMethod（）

如果没有看到调用SampleMethod的代码，我的猜测是您有一个类型为B的对象并在其上调用SampleMethod。

可以在一个链中执行覆盖，只要您愿意。您显示的代码是正确的

---

对于您看到的行为，唯一可能的解释是您所指的对象实际上是

B

类型。我建议您仔细检查一下，如果仍然没有意义，请发布其他合适的代码。

该解决方案很好；虽然要在方法所在的类之外实际使用它，但在出现的所有情况下，都需要将

SampleMethod

的访问权限设置为

public

，而不是

protected

，因此：

public class A
{
    public virtual void SampleMethod() 
    {
        Console.WriteLine("lol");
    }
}

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

public class C : B
{
    public override void SampleMethod()
    {
        base.SampleMethod();
    }
}

---

断点很可能不会被命中，因为您实际实例化了“B”类的一个实例

方法重写解析根据应调用其方法的类的实际运行时类型工作。因此，如果您有以下代码：

C c = new C();
c.SampleMethod();

以及以下各项：

C c = new C();
B b = (B)c;
b.SampleMethod();

---

将调用其

SampleMethod

的类的两种运行时类型都是type

B

方法重写是OOP特性，它允许子类提供其父类之一已经提供的方法的特定实现。

要在层次结构中重写多次，请使用某种方法像这样

// abstract class
abstract class A
    {
        public abstract void MethodOne();
    }

// class B inherits A
class B : A
{
    public override void MethodOne()
    {
        Console.WriteLine("From Class B");
    }
}

// class C inherits B
class C : B
{
    public override void MethodOne()
    {
        Console.WriteLine("From Class C");
    }
}

// class D inherits C
class D : C
{
    public override void MethodOne()
    {
        Console.WriteLine("From Class D");
    }
}

// etc......

// class Main method Class

class MainClass
{
    public static void Main()
    {
        B[] TestArray = new B[3];
        B b1 = new B();
        C c1 = new C();
        D d1 = new D();

        TestArray[0] = b1;
        TestArray[1] = c1;
        TestArray[2] = d1;

        for (int i = 0; i < TestArray.Length; i++)
        {
            TestArray[i].MethodOne();
        }

        Console.ReadLine();
    }
}

//抽象类
抽象A类
{
公开摘要void MethodOne（）；
}
//B类继承A类
B类：A
{
公共覆盖无效MethodOne（）
{
Console.WriteLine（“来自B类”）；
}
}
//C类继承B类
丙类：乙类
{
公共覆盖无效MethodOne（）
{
控制台写入线（“C类”）；
}
}
//类D继承C
D类：C类
{
公共覆盖无效MethodOne（）
{
控制台写入线（“来自D类”）；
}
}
//等等。。。。。。
//类主方法类
类主类
{
公共静态void Main（）
{
B[]TestArray=新的B[3]；
B b1=新的B（）；
C c1=新的C（）；
D d1=新的D（）；
TestArray[0]=b1；
TestArray[1]=c1；
TestArray[2]=d1；
对于（int i=0；i

我在这个链接的代码中这样做了

---

这取决于从何处访问SampleMethod。虚拟/重写方法不必公开。是的，这只是我犯的一个愚蠢的错误-感谢您（以及所有其他人）在这方面花费的时间。遇到同样的情况，检查

调用代码后，问题解决了。