当您希望继承者根据需要扩展功能时，基本上可以使用虚拟方法。

当您希望继承者实现功能时，可以使用抽象方法（在这种情况下，他们别无选择）

虚拟方法：

虚拟意味着我们可以超越它。虚拟函数有一个实现。当我们继承类时可以重写虚拟函数并提供我们自己的逻辑。我们可以在实现子类中的函数（可以说是阴影）。

抽象方法

抽象意味着我们必须重写它。抽象函数没有实现，必须在抽象类中。它只能声明。这迫使派生类提供它的实现。抽象成员是隐式虚拟的。在某些语言中，抽象可以称为纯虚拟。公共抽象类BaseClass{ 受保护的抽象void xAbstractMethod（）；公共虚拟void xVirtualMethod（）{变量x=3+4；}}

只有抽象类才能有抽象成员。从抽象类继承的非抽象类必须重写其抽象成员。抽象成员是隐式虚拟的。抽象成员不能提供任何实现（抽象在某些语言中称为纯虚拟）。

从C++背景来看，C#虚拟对应于C++虚拟，而C#抽象方法对应于C++纯虚拟函数

据我所知：

抽象方法：

只有抽象类才能保存抽象方法。派生类也需要实现该方法，并且类中没有提供任何实现。

虚拟方法：

类可以声明这些并提供其实现。派生类还需要实现方法来重写它。

我通过对以下课程（从其他答案）进行一些改进，使这一点更简单：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestOO
{
    class Program
    {
        static void Main(string[] args)
        {
            BaseClass _base = new BaseClass();
            Console.WriteLine("Calling virtual method directly");
            _base.SayHello();
            Console.WriteLine("Calling single method directly");
            _base.SayGoodbye();

            DerivedClass _derived = new DerivedClass();
            Console.WriteLine("Calling new method from derived class");
            _derived.SayHello();
            Console.WriteLine("Calling overrided method from derived class");
            _derived.SayGoodbye();

            DerivedClass2 _derived2 = new DerivedClass2();
            Console.WriteLine("Calling new method from derived2 class");
            _derived2.SayHello();
            Console.WriteLine("Calling overrided method from derived2 class");
            _derived2.SayGoodbye();
            Console.ReadLine();
        }
    }


    public class BaseClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }
        public virtual void SayGoodbye()
        {
            Console.WriteLine("Goodbye\n");
        }

        public void HelloGoodbye()
        {
            this.SayHello();
            this.SayGoodbye();
        }
    }


    public abstract class AbstractClass
    {
        public void SayHello()
        {
            Console.WriteLine("Hello\n");
        }


        //public virtual void SayGoodbye()
        //{
        //    Console.WriteLine("Goodbye\n");
        //}
        public abstract void SayGoodbye();
    }


    public class DerivedClass : BaseClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }

        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }

    public class DerivedClass2 : AbstractClass
    {
        public new void SayHello()
        {
            Console.WriteLine("Hi There");
        }
        // We should use the override keyword with abstract types
        //public new void SayGoodbye()
        //{
        //    Console.WriteLine("See you later2");
        //}
        public override void SayGoodbye()
        {
            Console.WriteLine("See you later");
        }
    }
}