胡乱写的一点利用C#中闭包模拟OOP的代码

先来看一段JS代码:

function Outer()
{
 var count = 0;
 var Inner = function(){
  alert(count++);
 }
 return Inner;
}

var f = Outer();
var k = Outer();
f();
f();
k();
f();
k();

这就是JS中最简单的闭包实现,可以类似对象的操作,以函数的形式内聚一些数据.

我们知道C#中是支持闭包的,一个方法(函数)引用了其作用域以外的变量,进行操作.具体实现原理可以自己用IL或者找些文章来了解.

那如果一个OOP的语言,使用FP的特性,再来模拟出OOP的特性,那真是吃饱了撑的,不过肯定好玩.

今天学习了这篇文章 http://www.cnblogs.com/weidagang2046/archive/2010/11/01/1865899.html,照葫芦画瓢写了几行代码,全为了加深理解.

先写一个最简单的类

public class OOPer
    {
        private int count = 0;

        public void Say()
        {
            Console.WriteLine(count++);
        }

        public void Reset()
        {
            count = 0;
            Console.WriteLine("Have Reset");
        }

        public void Set(int newcount)
        {
            count = newcount;
            Console.WriteLine("Set");
        }
    }

你可以实现此类若干事例,不断调用Say,Set,Reset方法。那如果使用闭包的形式会是怎样的？

public class FPer
    {
        Func<FPerMethod, object> fpfunc = null;

        public FPer()
        {
            fpfunc = GetClosure();
        }

        public void Say()
        {
            Action act = fpfunc(FPerMethod.Say) as Action;
            act();
        }

        public void Reset()
        {
            Action act = fpfunc(FPerMethod.Reset) as Action;
            act();
        }

        public void Set(int newcount)
        {
            Action<int> act = fpfunc(FPerMethod.Set) as Action<int>;
            act(newcount);
        }

        private enum FPerMethod
        {
            Say,
            Reset,
            Set
        }

        /// <summary>
        /// 使用不同的枚举类型作为参数，选择返回不同的操作方法
        /// </summary>
        /// <returns></returns>
         private Func<FPerMethod, object> GetClosure()
        {
            int count = 0;

            Func<FPerMethod, object> func = 
            (method) =>
            {
                if (method == FPerMethod.Say)
                {
                    Action act = () => { Console.WriteLine(count++); };
                    return act;
                }
                else if (method == FPerMethod.Reset)
                {
                    Action act = () =>
                    {
                        count = 0;
                        Console.WriteLine("Have Reset");
                    };
                    return act;
                }
                else if (method == FPerMethod.Set)
                {
                    Action<int> act = (c) =>
                    {
                        count = c;
                        Console.WriteLine("Set");
                    };

                    return act;
                }

                return null;
            };

            return func;
        }
    }

使用方式和OOper一模一样，只要new一个FPer，就可以使用了。其核心就是GetClosure()，相当于一个FactoryMothed，每次Create一个用闭包是实现的特殊对象，又像是一个对象，因为你所使用核心数据count也是在它的作用域中。所以，如果你把 Action act = fpfunc(FPerMethod.Say) as Action;换成了Action act = GetClosure()(FPerMethod.Say) as Action;所得的结果就不会是现在这样了。