C# 编译时多态和运行时多态

C#支持两种类型的多态性：

● 编译时的多态性

编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。

● 运行时的多态性

运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多态性通过虚成员实现。

具体的检查的流程如下：

1、当调用一个对象的函数时，系统会直接去检查这个对象申明定义的类，即申明类，看所调用的函数是否为虚函数；

2、如果不是虚函数，那么它就直接执行该函数。而如果有virtual关键字，也就是一个虚函数，那么这个时候它就不会立刻执行该函数了，而是转去检查对象的实例类。

3、在这个实例类里，他会检查这个实例类的定义中是否有重新实现该虚函数（通过override关键字），如果是有，那么OK，它就不会再找了，而马上执行该实例类中的这个重新实现的函数。而如果没有的话，系统就会不停地往上找实例类的父类，并对父类重复刚才在实例类里的检查，直到找到第一个重载了该虚函数的父类为止，然后执行该父类里重载后的函数。

 class A
        {
            public void Greeding()
            {
                Console.WriteLine("A:Hello!");
            }

            public virtual void Gree2()
            {
                Console.WriteLine("A:Gree2!");
            }

            public virtual void G3()
            {
                Console.WriteLine("A:G3!");
            }
        }

        class B : A
        {
            public void Greeding()
            {
                Console.WriteLine("B:Hello!");
            }

            public override void Gree2()
            {
                Console.WriteLine("B:Gree2!");
            }

            public override void G3()
            {
                Console.WriteLine("B:G3!");
            }
        }

        class C : B
        {
            public void GreedC()
            {
                base.Greeding();
            }
            public void Gree2()
            {
                Console.WriteLine("C:Gree2!");
            }

            public void G3()
            {
                base.Gree2();
            }
        }
        class Test
        {
            static void Main()
            {
                A aa = new C();
                //aa.GreedC(); 报错
                C cc = new C();
                aa.Greeding();// A:Hello!
                aa.Gree2();   // B:Gree2!
                aa.G3();      // B:G3!
                cc.Gree2();   // C:Gree2!
                cc.Greeding();// B:Hello!
                cc.GreedC();  // B:Hello!
            }
        }

对于非虚方法来说，调用哪个方法取决于该实例编译时的类型。

但对于虚方法来说，调用哪个方法取决于该实例运行时的类型。

转：https://www.cnblogs.com/zhaoshujie/p/10502404.html