1.     using System;  
       namespace Smz.Test  
       {  
           class A  
           {  
               public virtual void Func() // 注意virtual,表明這是一個虛擬函式  
               {  
                   Console.WriteLine("Func In A");  
               }  
         
               public void Non_virtual()  
               {  
                   Console.WriteLine("Non virtual func in A");  
               }  
           }  
           class B : A // 注意B是從A類繼承,所以A是父類,B是子類  
           {  
               public override void Func() // 注意override ,表明重新實現了虛擬函式  
               {  
                   Console.WriteLine("Func In B");  
               }  
         
               public void Non_virtual()  
               {  
                   Console.WriteLine("Non virtual func in B");  
               }  
           }  
           class C : B // 注意C是從A類繼承,所以B是父類,C是子類  
           {  
               public void Non_virtual()  
               {  
                   Console.WriteLine("Non virtual func in C");  
               }  
           }  
           class D : A // 注意D是從A類繼承,所以A是父類,D是子類  
           {  
               public new void Func() // 注意new ，表明覆蓋父類裡的同名類，而不是重新實現  
               {  
                   Console.WriteLine("Func In D");  
               }  
         
               public new void Non_virtual()  
               {  
                   Console.WriteLine("Non virtual func in D");  
               }  
           }  
           class program  
           {  
               static void Main()  
               {  
                   A a;         // 定義一個a這個A類的物件.這個A就是a的申明類  
                   A b;         // 定義一個b這個A類的物件.這個A就是b的申明類  
                   A c;         // 定義一個c這個A類的物件.這個A就是c的申明類  
                   A d;         // 定義一個d這個A類的物件.這個A就是d的申明類  
                   a = new A(); // 例項化a物件,A是a的例項類  
                   b = new B(); // 例項化b物件,B是b的例項類  
                   c = new C(); // 例項化c物件,C是c的例項類  
                   d = new D(); // 例項化d物件,D是d的例項類  
                   a.Func();    // 執行a.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類A，就為本身 4.執行例項類A中的方法 5.輸出結果 Func In A  
                   b.Func();    // 執行b.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類B，有重寫的 4.執行例項類B中的方法 5.輸出結果 Func In B  
                   c.Func();    // 執行c.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類C，無重寫的 4.轉去檢查類C的父類B，有過載的 5.執行父類B中的Func方法 5.輸出結果 Func In B  
                   d.Func();    // 執行d.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類D，無重寫的（這個地方要注意了，雖然D裡有實現Func()，但沒有使用override關鍵字，所以不會被認為是重寫） 4.轉去檢查類D的父類A，就為本身 5.執行父類A中的Func方法 5.輸出結果 Func In A  
                   D d1 = new D();  
                   d1.Func(); // 執行D類裡的Func()，輸出結果 Func In D  
                     
                   a.Non_virtual(); //執行A類的Non_virtual  
                   b.Non_virtual(); //執行A類的Non_virtual  
                   c.Non_virtual(); //執行A類的Non_virtual  
                   d.Non_virtual(); //執行A類的Non_virtual  
                   d1.Non_virtual(); //執行D類的Non_virtual  
         
                   Console.ReadLine();  
               }  
           }  
       }  
    
   

   
   
2.             b.Non_virtual(); //執行A類的Non_virtual  
3.             c.Non_virtual(); //執行A類的Non_virtual  
4.             d.Non_virtual(); //執行A類的Non_virtual
     
5.             d1.Non_virtual(); //執行D類的Non_virtual  
6.   
7.             Console.ReadLine();  
8.         }  
9.     }  
10. }  

具體在檢查的時候，遵循的規則，已經有人在網上做了很詳細的闡述，我在這裡引用一下：

虛擬函式從C#的程式編譯的角度來看，它和其它一般的函式有什麼區別呢？一般函式在編譯時就靜態地編譯到了執行檔案中，其相對地址在程式執行期間是不發生變化的，也就是寫死了的！而虛擬函式在編譯期間是不被靜態編譯的，它的相對地址是不確定的，它會根據執行時期物件例項來動態判斷要呼叫的函式，其中那個申明時定義的類叫申明類，那個執行時例項化的類叫例項類。

如：飛禽 bird = new 麻雀();
那麼飛禽就是申明類，麻雀是例項類。

具體的檢查的流程如下

1、當呼叫一個物件的函式時，系統會直接去檢查這個物件申明定義的類，即申明類，看所呼叫的函式是否為虛擬函式；

2、如果不是虛擬函式，那麼它就直接執行該函式。而如果有virtual關鍵字，也就是一個虛擬函式，那麼這個時候它就不會立刻執行該函數了，而是轉去檢查物件的例項類。

3、在這個例項類裡，他會檢查這個例項類的定義中是否有重新實現該虛擬函式（通過override關鍵字），如果是有，那麼OK，它就不會再找了，而馬上執行該例項類中的這個重新實現的函式。而如果沒有的話，系統就會不停地往上找例項類的父類，並對父類重複剛才在例項類裡的檢查，直到找到第一個過載了該虛擬函式的父類為止，然後執行該父類裡過載後的函式。

在上面的規則中，可以看到，如果子類沒有override的修飾，那麼就算父類是virtual的方法，子類的方法也無法被呼叫，而會去它的父類中找override的方法，直到找到祖先類。所以在面向物件的開發過程中，如果要實現Dependency Injection、IoC等設計模式，就必須非常留意類設計中繼承方法的宣告，否則很可能導致實際的程式執行與預期不符。