Will CLR check the whole inheritance chain to determine which virtual method to call? : <p>The inheritance chain is as follows:</p>

<pre><code>class A
    {
        public virtual void Foo()
        {
            Console.WriteLine("A's method");
        }
    }

class B:A
    {
        public override void Foo()
        {
            Console.WriteLine("B's method");
        }
    }

class C:B
    {
        public new virtual void Foo()
        {
            Console.WriteLine("C's method");
        }
    }

class D:C
    {
        public override void Foo()
        {
            Console.WriteLine("D's method");
        }
    }
</code></pre>

<p>then:</p>

<pre><code>class Program
    {
        static void Main(string[] args)
        {
            A tan = new D();
            tan.Foo();
            Console.Read();
        }
    }
</code></pre>

<p>The result is, the method foo() in class B is called. </p>

<p>But in the <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/virtual" rel="noreferrer">reference</a>:</p>

<blockquote>
  <p>When a virtual method is invoked, the run-time type of the object is
  checked for an overriding member. The overriding member in the most
  derived class is called, which might be the original member, if no
  derived class has overridden the member.</p>
</blockquote>

<p>In my logic, CLR first finds <code>Foo()</code> is a virtual method, it looks into the method table of <code>D</code>, the runtime type, then it finds out there is an overriding member in this most derived class, it should call it and never realizes there is a <code>new Foo()</code> in the inheritance chain.</p>

<p>What's wrong with my logic? </p>
