[13年迁移] C# yAspectF,轻量级的aop实现,编入分离阻断

介绍一下AspectF这个东西,诞生于一位微软mvp之手,介绍它首先要从c#说起,当引入了委托这个概念的时候,它也只是c++的函数指针的封装而 已,但是后续陆续引入的lambda表达式,匿名方法,泛型,扩展方法语法糖,让其一次又一次的升华,一切都是如此美妙,可以说如果我把泛型的封装再做上 去,这个框架基本就可以代表近期c#的新特征的一个集合.在不用反射或者编译优化,这些解释器的手段,可以说c#应该是最好,抽象程度最高的高级语言了 (如果用的话就是java好,不过那些都是写生涩的技术,所以java的企业级框架,如此的强大)

public class AspectF
{//泛型的封装太麻烦,而且暂时用不到,故只根据需要做个string的
//在AspectF上加入了前阻断,并修改返回值,你要抛错也是行的
    public delegate string yson(string i);
    public delegate string yDelegate(yson work,string i);
    public yDelegate yChain = null;
    /// <summary>
    /// 如果方面在work前面返回值了不是null的值,那么阻断,后面的话
    /// </summary>
    [DebuggerStepThrough]
    public AspectF yCombine(yDelegate newAspectReturnDelegate)
    {
        if (this.yChain == null)
        {
            this.yChain = newAspectReturnDelegate;
        }
        else
        {
            yDelegate existingChain = this.yChain;
            yDelegate callAnother = (work,i) =>
                existingChain((ii) => newAspectReturnDelegate(work,ii),i);
            this.yChain = callAnother;
        }
        return this;
    }
    [DebuggerStepThrough]
    public string yReturn(Func<string> work)
    {
        if (this.yChain == null)
        {
            return work();
        }
        else
        {
            var returnValue = string.Empty;
            this.yChain((i) =>
            {//每个yDelegate的匿名方法参数都再执行一次自己的work委托,同时加一个标识,说明是后执行,那么就不在执行这里的work委托,
         //那么后修改返回值就出来了,而委托链之间,直接用它们自己的返回值了递归传获得的执行结果,由里到外的获得结果,用来调用,
         //比如work("根据返回值后修改",代表执行后的常量)
                if (i != null) {//判定泛型封装用define(T)
                    returnValue = i;
                    return returnValue;
                }  
                returnValue= work();//执行这个
                return returnValue;
            },null);//泛型的话,这里传入define(T)即可
            return returnValue;
        }
    }
}
   class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine("最后返回"+saaddsad());   
        }
        public static string saaddsad() {
            return AspectF.Define
        .aPointer()
        .bPointer()
        .yReturn(() =>
        {
            var ddd="执行方法";
            Console.WriteLine(ddd);
            return ddd;
        });
        }
     }
    static class AspectFExt
    {//语法糖的扩展类,怎么用不到呢?好像只能系统的?
        public static AspectF aPointer(this AspectF aspect)
        {
       
            return aspect.yCombine((work,i) =>
            {
                 Console.WriteLine("a切点前");     
                string a= work("截断改变");          
                 Console.WriteLine("a切点后"+a);
                 work("a");
                return "da";
            });
        }
        public static AspectF bPointer(this AspectF aspect)
        {
       //一个需要(func<string>)的方法,判断如果work指向底层,就执行一个空的
            return aspect.yCombine((work,i) =>
            {               
                Console.WriteLine("b切点前");
                string b = work(i);//不想改变就返回i参数即可,不要使用null
                Console.WriteLine("b切点后"+b);
                return "fsa";
            });
        }
    }

 

 

还能实现执行后获得返回值,然后改变,执行前改变,泛型封装的话,委托和匿名方法的约束写起来估计是比较烦的,也还有点小问题.,项目就用到前阻断,并改变返回值,那就这样吧,其实只要再执行一个work,然后给一个标识,就能实现后阻断,然后根据返回值再修改并传递,修改一下yReturn方法就行了.小型项目就不需要去借助企业框架,虽然编入的方式只能手动,不过效率是大型框架不能比的.
如果我也能就钻研一门语言,专心做一门学问,或者一项工艺,无疑是幸福的吧,有一天一定要把你们全部画出来.也许最近的伤感就是项目的后台要做完了,分离的日子越来越近了..C#不舍得啊..但是js又在等着我.我依然前行,因为有很多未知的奇迹在等着我.