c# - c# 中的阴影 - 基方法被调用而不是派生

Question

我正在尝试弄清楚 c# 中阴影的概念。这是我的代码，它的行为与我预期的不一样:

public class Animal
{
    public virtual void Foo()
    {
        Console.WriteLine("Foo Animal");
    }
}

public class Dog : Animal
{
    public new void Foo()
    {
        Console.WriteLine("Foo Dog");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dog dog1 = new Dog();
        ((Animal)dog1).Foo();
        Animal dog2 = new Dog();
        dog2.Foo();
    }
}

当 Main 中的代码被执行时，基类 (Animal) 中的 Foo() 被调用，从我读到的关于阴影，应该调用 Dog 中的 Foo()。有人可以解释我错过了什么吗？

我的例子是这样的: https://msdn.microsoft.com/en-us/library/ms173153.aspx

更新:这是来自 msdn 的示例:

class Program
{
    static void Main(string[] args)
    {
        BaseClass bc = new BaseClass();
        DerivedClass dc = new DerivedClass();
        BaseClass bcdc = new DerivedClass();

        // The following two calls do what you would expect. They call
        // the methods that are defined in BaseClass.
        bc.Method1();
        bc.Method2();
        // Output:
        // Base - Method1
        // Base - Method2


        // The following two calls do what you would expect. They call
        // the methods that are defined in DerivedClass.
        dc.Method1();
        dc.Method2();
        // Output:
        // Derived - Method1
        // Derived - Method2


        // The following two calls produce different results, depending 
        // on whether override (Method1) or new (Method2) is used.
        bcdc.Method1();
        bcdc.Method2();
        // Output:
        // Derived - Method1
        // Base - Method2
    }
}

class BaseClass
{
    public virtual void Method1()
    {
        Console.WriteLine("Base - Method1");
    }

    public virtual void Method2()
    {
        Console.WriteLine("Base - Method2");
    }
}

class DerivedClass : BaseClass
{
    public override void Method1()
    {
        Console.WriteLine("Derived - Method1");
    }

    public new void Method2()
    {
        Console.WriteLine("Derived - Method2");
    }
}

当 bcdc.Method1() 被执行时，派生类中的 Method1() 被调用，在我的示例中不是这种情况。

Answer 1

在 ((Animal)dog1).Foo() 行中，首先将对象 dog1 从 Dog 转换为 Animal 类型。所以它调用基类 Animal 中的方法。

如果在 dog 类的 Foo 方法中使用 override 而不是 new 关键字，您将得到预期的结果(即， Dog 类的 Foo 方法将被调用。

在您的代码 Animal dog2 = new Dog(); 中，dog2 将被创建为 Animal 而不是 Dog 的对象。因此，调用 Foo 方法将调用 Animal 类中的方法。

您可以使用以下代码((Dog)dog2).Foo(); 调用Dog 类中的Foo 方法。这里从 Animal 到 Dog 类的转换是可能的，因为变量 dog2 最初是从Dog 类的构造函数创建的