【声明：本文没有贬低某个编程语言的意思】

你，一个DotNet程序员，刚刚加入一个新项目组。除了你之外，其他的成员包括：Ceer，一直从事C项目的程序员，他刚刚转入C#不到一个月； Jally，整天抱着本Design Pattern（没错，就是GoF的那本）在啃的前Java程序员；以及Semon，你对他完全不了解，只是听PM介绍说他是搞Scheme的（传说中的第二古老的语言LISP的方言之一）。不过你也没在意，毕竟计算机这玩意，老东西是不吃香的。

周一，刚打开电脑，老板就跑到你们组的办公座面前：“好吧，伙计们，现在有个function需要你们来搞定。具体是这样的：用户输入2个数，并输入一个操作符。你根据输入的情况来得出相应的运算结果。“

Example： Foo(+, 1, 2) = 3; Foo(*, 3, 6) = 18; Foo(/, 2, 4) = 0.5

Ceer最先作出反应：简单嘛，判断一下输入的操作符就好了。说着，他很快在白板上写出如下代码：
    public class CStyle_Calculator
    {
        static public double Foo(char op, double x, double y)
        {
            switch(op)
                case '+': return x + y; break;
                case '-': return x - y; break;
                case '*': return x * y; break;
                case '/': return x / y; break;
                default: throw new Exception(”What the Hell you have input?");
        }
    }
   
Jally只看了一遍，就捂着鼻子连连摇头：好一股的代码臭味【注1】。还不如看我用OO的方法来解决：
    public interface I操作符 //谁说代码不能写中文的？恩恩
    {
        double 运算(double x, double y);
    }
   
    public class OO_Calculator
    {
        private I操作符 m_op;
        public OO_Calculator(I操作符 op)
        {
            this.m_op = op; //依赖注入【注2】
        }
       
        public double Foo(double x, double y)
        {
            return this.m_op.运算(x, y);
        }
    }
   
    public class 加法:I操作符
    {
        public double 运算(double x, double y)
        {
            return x + y;
        }
    }
   
    public class 减法:I操作符
    {
        public double 运算(double x, double y)
        {
            return x - y;
        }
    }
   
    public class 乘法:I操作符
    {
        public double 运算(double x, double y)
        {
            return x * y;
        }
    }
   
    public class 除法:I操作符
    {
        public double 运算(double x, double y)
        {
            return x / y;
        }
    }
   
    public class TheMainClass
    {
        static public void Main()
        {
            I操作符 我的加法 = new 加法();
            OO_Calculator 我的加法器 = new OO_Calculator(我的加法);
            double sum  = 我的加法器.Foo(3, 4);
            System.Console.WriteLine(sum);
            //sum = 7
           
            //其他3个我就不废话了
        }
    }

你看着Jally把白板写得密密麻麻之后，耸耸肩，暗叹，你们这些用java的废柴，就一个运算器还搞出Interface这些东西，烦不烦啊。 让你们见识见识DotNet的强大吧. 那个运算符我直接用delegate传进去不就好了么.
    public delegate double TheOperator(double x, double y);
   
    public class Operators
    {
        static public double Add(double x, double y)
        {
            return x + y;
        }
       
        static public double Sub(double x, double y)
        {
            return x - y;
        }
       
        //乘，除法 我也懒得废话了
    }
   
    public class DotNet_Calculator
    {
        public double Foo(TheOperator op, double x, double y)
        {
            return op(x, y);
        }
    }
   
    public class TheMainClass
    {
        static public void Main()
        {
            TheOperator myAdd = new TheOperator(Operators.Add);
            TheOperator mySub = new TheOperator(Operators.Sub);
           
            DotNet_Calculator dc = new DotNet_Calculator();
            double sum = dc.Foo(myAdd, 2, 4); //sum = 6
            System.Console.WriteLine(sum);
            double sub = dc.Foo(mySub, 3, 7); //sub = -4
            System.Console.WriteLine(sub);
        }
    }
    //dot net 下面还可以用CodeDom动态构造C＃代码，然后在内存编译运行。
    //如果觉得专门写个Operators很烦的话，可以试试C＃2.0的匿名方法

很好，当你写完代码之后，挑衅的看着Jally，Ceer却开始抱怨起来：”这不就是C里面的函数指针么，我也会...“
“然则DotNet下面的Delegate是类型安全滴...”你继续洋洋得意.