C# virtual function

If an instance method is declared with the virtual keyword, then this method is a virtual method.
The biggest difference between virtual methods and non-virtual methods is that the implementation of virtual methods can be replaced by derived classes. This replacement is achieved by rewriting the method (more on this later)
Characteristics of virtual methods:
Virtual methods are not preceded by Static, abstract, or override modifiers are allowed
Virtual methods cannot be private, so the private modifier cannot be used
Execution of virtual methods:
We know that general functions are statically compiled into the execution file at compile time, and their relative addresses It does not change during the running of the program,
The virtual function is not statically compiled during compilation, and its relative address is uncertain. It will dynamically determine the function to be called based on the runtime object instance,
where The class defined during declaration is called the declaration class, and the class instantiated during execution is called the instance class.
For example: A a =new B(); where A is the declaration class and B is the instance class.
1. When calling a function of an object, the system will directly check the class declared by the object, that is, the declared class, to see whether the called function is a virtual function;
2. If it is not a virtual function, then it will be executed directly this function. And if it is a virtual function, then it will not execute the function immediately at this time, but start checking the instance class of the object.
3. In this instance class, it will check whether there is a method to implement the virtual function or re-implement the virtual function (through the override keyword) in the definition of the instance class.
If there is, it will not look for it again. , but immediately executes the method of the virtual function implemented in the instance class. And if not, the system will keep looking up the parent class of the instance class, and repeat the check just now in the instance class until it finds the first parent class that overloads the virtual function. Then execute the overloaded function in the parent class.
Example 1:

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new A();   // 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,A是a的实例类   
             a.Sum();
             Console.Read();
        }
    }

1. First check the declaration class A 2. Check that sum is a virtual method 3. Turn to check the instance class A, the result is the question itself
4. Execute the instance class A Method to implement Sum 5. Output the result I am A Class, I am virtual sum().
Example 2:

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public override void Sum() // 重新实现了虚函数   
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();  // 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,B是a的实例类              
             a.Sum();
             Console.Read();
        }
    }

1. First check the declaration class A 2. Check that it is a virtual method 3. Transfer Check instance class B, there are overridden methods 4. Execute the method in instance class B 5. Output the result I am B Class, I am override sum().
Example 3:

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public override void Sum() // 重新实现了虚函数   
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class C : B
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new C();// 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,C是a的实例类              
             a.Sum();
             Console.Read();
        }
    }

1 . First check the declaration class A 2. Check that it is a virtual method 3. Go to check the instance class C, there is no overridden method 4. Go to the parent class B of class C, there is an overridden method
5. Execute the parent class Sum method in B 6. Output the result I am B Class, I am override sum().
Example 4:

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public new void Sum() //覆盖父类里的同名函数，而不是重新实现  
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();
             a.Sum();
             Console.Read();
        }
    }

1. First check the declaration class A 2. Check that it is a virtual method 3. Go to check instance class B, there is no overriding (note here, although Sum() is implemented in B, the override keyword is not used, so it will not be considered as rewriting) 4. Go to check class B The parent class A is itself 5. Execute the Sum method in the parent class A 6. Output the result I am A Class, I am virtual sum(). So what if in Example 4, class B is declared?

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public new void Sum() //覆盖父类里的同名函数，而不是重新实现  
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             B b=new B();
             b.Sum();
             Console.Read();
        }
    }

The answer is yes.

class A
    {
        public virtual void PrintFriends()
        {
            Console.WriteLine("A.PrintFriends()");   
        }  
    }
    abstract class B : A    
    {
        public abstract override void PrintFriends();   //使用override 修饰符，表示抽象重写了基类中该函数的实现
    }
    abstract class C : A
    {
        public abstract new void PrintFriends();        //使用 new 修饰符显式声明，表示隐藏了基类中该函数的实现
    }

class A
    {
        public virtual void Fun()
        {
            Console.WriteLine("I am A.");
        }
    }
    sealed class Program:A
    {
        public override void Fun()
        {
            Console.WriteLine("I am B.");
        }
        static void Main(string[] args)
        {
            Program p = new Program();
            p.Fun();
            Console.Read();
        }
    }