若一个实例方法的声明中含有 virtual 修饰符，则称该方法为虚方法 (virtual method)。若其中没有 virtual 修饰符，则称该方法为非虚方法 (non-virtual method)。

在调用一个虚方法时，该调用所涉及的那个实例的运行时类型 (runtime type) 确定要调用该方法的哪一个实现。在非虚方法调用中，实例的编译时类型 (compile-time type) 负责做出此决定。

虚方法可以在派生类中重写 (override)。当某个实例方法声明包括 override 修饰符时，该方法将重写所继承的具有相同签名的虚方法。虚方法声明用于引入新方法，而重写方法声明则用于使现有的继承虚方法专用化（通过提供该方法的新实现）。

抽象 (abstract) 方法是没有实现的虚方法。抽象方法使用 abstract 修饰符进行声明，并且只允许出现在同样被声明为 abstract 的类中。抽象方法必须在每个非抽象派生类中重写。

下面的示例声明一个抽象类 Expression，它表示一个表达式目录树节点；它有三个派生类 Constant、VariableReference 和 Operation，它们分别实现了常量、变量引用和算术运算的表达式目录树节点

 

    public abstract class Expression
    {
        public abstract double Evaluate(Hashtable vars);
    }

    public class Constant : Expression
    {
        double value;
        public Constant(double value)
        {
            this.value = value;
        }
        public override double Evaluate(Hashtable vars)
        {
            return value;
        }
    }
    public class VariableReference : Expression
    {
        string name;
        public VariableReference(string name)
        {
            this.name = name;
        }
        public override double Evaluate(Hashtable vars)
        {
            object value = vars[name];
            if (value == null)
            {
                throw new Exception("Unknown variable: " + name);
            }
            return Convert.ToDouble(value);
        }
    }
    public class Operation : Expression
    {
        Expression left;
        char op;
        Expression right;
        public Operation(Expression left, char op, Expression right)
        {
            this.left = left;
            this.op = op;
            this.right = right;
        }
        public override double Evaluate(Hashtable vars)
        {
            double x = left.Evaluate(vars);
            double y = right.Evaluate(vars);
            switch (op)
            {
                case '+': return x + y;
                case '-': return x - y;
                case '*': return x * y;
                case '/': return x / y;
            }
            throw new Exception("Unknown operator");
        }
    }

 

代码中调用了 Expression 实例的 Evaluate 方法，以计算给定表达式的值，从而生成一个 double 值。该方法接受一个包含变量名称（作为哈希表项的键）和值（作为项的值）的 Hashtable 作为参数。Evaluate 方法是一个虚抽象方法，意味着非抽象派生类必须重写该方法以提供具体的实现。

Constant 的 Evaluate 实现只是返回所存储的常量。VariableReference 的实现在哈希表中查找变量名称，并返回产生的值。Operation 的实现先对左操作数和右操作数求值（通过递归调用它们的 Evaluate 方法），然后执行给定的算术运算。

下面的程序使用 Expression 类，对于不同的 x 和 y 值，计算表达式 x * (y + 2) 的值。

 

        static void Main(string[] args)

        {

            Expression e = new Operation(

                new VariableReference("x"),

                '*',

                new Operation(

                    new VariableReference("y"),

                    '+',

                    new Constant(2)

                )

            );

            Hashtable vars = new Hashtable();

            vars["x"] = 3;

            vars["y"] = 5;

            Console.WriteLine(e.Evaluate(vars));        // Outputs "21"

            vars["x"] = 1.5;

            vars["y"] = 9;

            Console.WriteLine(e.Evaluate(vars));        // Outputs "16.5"

            Console.ReadLine();

        }