设计之美——极限反射加速（代码）

  才起床的时候，总是感觉还是比较不错的感觉，虽然不怎么情愿起来，先来BS下移动，一个破电话给我吵醒，为何呢？說啥要开奥运手机报，還不是赚钱啊，有种免费开，nnd……

  废话不说了，这是骗还在床上写的，大家也就凑合着看，依然是上次的测试代码，贴一下。。

  我忽然觉得新贴下测试结果也许大家会更感兴趣

test1 time past 00:00:00.9062500
克隆加动态委托 time past 00:00:00.7031250
test1 time past 00:00:01.4687500
克隆加动态委托 time past 00:00:00.7031250
test1 time past 00:00:00.8750000
克隆加动态委托 time past 00:00:00.6875000

这是连续的3次测试，嗯 ？发现一个问题，居然比直接执行要快！我也很怀疑，但是不知道为什么，如果你找出原因請告诉我，我觉得也许是克隆比new块一些吧 ，猜的，好了 看起来也许你开始迫不及待了，来看测试代码。

 

            testclass clas = new testclass();
            clas.test1();
            clas.testdle();
            clas.test1();
            clas.testdle();
            clas.test1();
            clas.testdle();

这里是刚才的测试 main主题 大家看好了，我没作弊！

 

   public class CTester :  DesignPaterns.Reflection.Class
    ...{
        public CTester()
        ...{
            a = 10;
        }

        public void test1()
        ...{
            a = (a - 0.0001) * 1.0001;
        }
        private double a;
        public double geta() ...{ return a; }

        public object Clone()
        ...{
            return this.MemberwiseClone();
        }
    }

    public class CTestern : DesignPaterns.Reflection.Class
    ...{
        public CTestern()
        ...{
            a = 10;
        }

        public void test1()
        ...{
            a = (a - 0.0001) * 1.0001;
        }
        private double a;
        public double geta() ...{ return a; }

        public object Clone()
        ...{
            return this.MemberwiseClone();
        }
    }

一开始以为自定义类的构造时间长，所以特地分开了。结果还是一样的

 

    public class testclass
    ...{

       

       public void testdle()
        ...{
            

            DateTime now = DateTime.Now;
            
            for (int i = 0; i < 10000; i++)
            ...{
                for (int j = 0; j < 100; j++)
                ...{
                    CTester aTest = DesignPaterns.Reflection.DelegateReflection.Instance.GetObject<CTester>();

                    (aTest as DesignPaterns.Reflection.IReflection).InvokeMember("test1");
                }
            }

            TimeSpan spand = DateTime.Now - now;
            Console.WriteLine("克隆加动态委托 time past " + spand.ToString());
        }

        public void test1()
        ...{

            DateTime now = DateTime.Now;

            for (int i = 0; i < 10000; i++)
            ...{
                for (int j = 0; j < 100; j++)
                ...{
                    CTestern aTest = new CTestern();
                    
                    aTest.test1();
                }
            }

            TimeSpan spand = DateTime.Now - now;
            Console.WriteLine("test1 time past " + spand.ToString());
        }
}

是的没错，完全反射执行。。

要看大类么？想看么？ 嘿嘿 会给你看的

 

    /**//// <summary>
    /// #region license
    /// // **************************************************
    /// // Copyright (c) 2008 fengjian (icesun963@Gmail.com)
    /// // All rights reserved.
    /// // **************************************************
    /// #endregion
    /// 对象缓存
    /// </summary>
    public class ReflectionCache : Classes.DisposableClass
    ...{

         protected ReflectionCache()
         ...{
         }


        /**//// <summary>
        /// 反射对象母模版
        /// </summary>
        List<ICloneable> _ReflectionObjMaster = new List<ICloneable>();

        /**//// <summary>
        /// 反射对象字典 用于检索对象
        /// </summary>
        Dictionary<Type, ReflectionObjectInfo> _ReflectionDic = new Dictionary<Type, ReflectionObjectInfo>();

        Dictionary<string, Type> _TypeDic = new Dictionary<string, Type>();


        /**//// <summary>
        /// 获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public object GetObject(string type, params object[] args)
        ...{
            if (_TypeDic.ContainsKey(type))
            ...{
                return GetObject<ICloneable>(_TypeDic[type], args);
            }
            else
            ...{
                return null;
            }
        }

        /**//// <summary>
        /// 注册一个类
        /// </summary>
        /// <param name="type"></param>
        public void RegType(Type type)
        ...{
            if (!_TypeDic.ContainsKey(type.FullName))
            ...{
                _TypeDic.Add(type.FullName, type);
            }
        }

        /**//// <summary>
        /// 注册一个别名
        /// </summary>
        /// <param name="type"></param>
        public void RegType(Type type, string newname)
        ...{
            if (!_TypeDic.ContainsKey(newname))
            ...{
                _TypeDic.Add(newname, type);
            }
        }

        public T GetObject<T>( params object[] args)
        ...{
            Type type = typeof(T);
            int index = FindObject(type, args);
            if (index >= 0)
            ...{
                return (T)_ReflectionObjMaster[index];
            }
            else
            ...{
                ICloneable newobj = Activator.CreateInstance(type, args) as ICloneable;
                if (newobj == null)
                ...{
                    throw new Exception("不提供不支持克隆接口的对象!");
                }
                return (T)_ReflectionObjMaster[AddtoCache(newobj, args)];
            }
        }


        /**//// <summary>
        /// 查找对象
        /// </summary>
        /// <param name="t"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        protected int FindObject(Type t, params object[] args)
        ...{
            if (_ReflectionDic.ContainsKey(t))
            ...{

                    foreach (KeyValuePair<int, object[]> var in _ReflectionDic[t].ArgsDic)
                    ...{
                        if (var.Value.Length == args.Length)
                        ...{
                            int cout = 0;
                            for (int i = 0; i < var.Value.Length; i++)
                            ...{
                                if (var.Value[i].GetType() == args[i].GetType())
                                ...{
                                    cout++;
                                }
                            }
                            if (cout == var.Value.Length )
                            ...{
                                return var.Key;
                            }
                        }
                    }
                
            }
            return -1;
        }

        protected override void Dispose(bool disposing)
        ...{
            //由于Dispose方法可能被多线程调用，
            //所以加锁以确保线程安全
            lock (this)
            ...{
                if (disposing)
                ...{

                    try
                    ...{
                        _ReflectionDic.Clear();
                        _ReflectionObjMaster.Clear();
                        //说明对象的Finalize方法并没有被执行，
                        //在这里可以安全的引用其他实现了Finalize方法的对象
                    }
                    finally
                    ...{
                        base.Dispose(disposing);
                    }
                }
            }
           
        }

        /**//// <summary>
        /// 添加到缓存
        /// </summary>
        /// <param name="obj">The obj.</param>
        /// <param name="args">The args.</param>
        /// <returns></returns>
        protected virtual int AddtoCache(ICloneable obj, object[] args)
        ...{
            lock (_ReflectionObjMaster)
            ...{
               
                lock (_ReflectionDic)
                ...{
                    _ReflectionObjMaster.Add(obj);
                    if (_ReflectionDic.ContainsKey(obj.GetType()))
                    ...{
                        _ReflectionDic[obj.GetType()].ArgsDic.Add(_ReflectionObjMaster.Count -1, args);
                     
                    }
                    else
                    ...{
                        _ReflectionDic.Add(obj.GetType(), new ReflectionObjectInfo(obj.GetType(), _ReflectionObjMaster.Count -1, args));
                    }

                    return _ReflectionObjMaster.Count -1;
                }
            }

        }


    }

就是一个对对象缓存然后克隆的，demodemo 大家参考下就好了。

 

    /**//// <summary>
    /// #region license
    /// // **************************************************
    /// // Copyright (c) 2008 fengjian (icesun963@Gmail.com)
    /// // All rights reserved.
    /// // **************************************************
    /// #endregion
    ///  反射对象定义
    /// </summary>
    class ReflectionObjectInfo : Classes.DisposableClass
    ...{

        public ReflectionObjectInfo(Type type, int index, params object[] args)
        ...{
            _Type = type;
            ArgsDic.Add(index, args);
        }

        Type _Type;
        /**//// <summary>
        /// 类型
        /// </summary>
        public Type Type
        ...{
            get ...{ return _Type; }
        }

        /**//// <summary>
        /// 参数和对象索引
        /// </summary>
        Dictionary<int, object[]> _ArgsDic = new Dictionary<int, object[]>();

        /**//// <summary>
        /// 参数和对象索引
        /// </summary>
        public Dictionary<int, object[]> ArgsDic
        ...{
            get ...{ return _ArgsDic; }
        }

    }

    /**//// <summary>
    /// 委托接口
    /// </summary>
    public interface IReflection
    ...{
        /**//// <summary>
        /// 执行一个方法
        /// </summary>
        /// <param name="name"></param>
        /// <param name="target"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        object InvokeMember(string name, params object[] args);
        List<IDelegateDefine> DelegateDefine ...{ get;set;}

    }


    /**//// <summary>
    /// #region license
    /// // **************************************************
    /// // Copyright (c) 2008 fengjian (icesun963@Gmail.com)
    /// // All rights reserved.
    /// // **************************************************
    /// #endregion
    /// 
    /// </summary>
    public class Class : DisposableClass, IReflection
    ...{

        List<IDelegateDefine> _DelegateDefine = new List<IDelegateDefine>();

        List<IDelegateDefine> IReflection.DelegateDefine
        ...{
            get ...{ return _DelegateDefine; }
            set ...{ _DelegateDefine = value; }
        }

        IReflection 成员#region IReflection 成员

        object IReflection.InvokeMember(string name,params object[] args)
        ...{
            foreach (IDelegateDefine var in _DelegateDefine)
            ...{
                if (name == var.DelegateName)
                ...{
                    var.Args = args;
                    return var.Invoke();
                }
            }

            /**////使用反射调用
            return this.GetType().GetMethod(name).Invoke(this, args);
        }

        #endregion
    }

有点乱，而且肚子饿了，直接贴代码了，有空再补说明了。。。

 

    /**//// <summary>
    /// 基本对象定义
    /// </summary>
    public abstract class DelegateDefine : IDelegateDefine
    ...{

        string _DelegateName;

        /**//// <summary>
        /// 名称
        /// </summary>
        /// <value></value>
        public string DelegateName
        ...{
            get ...{ return _DelegateName; }
            protected set ...{ _DelegateName = value; }
        }

        object[] _Args;

        Delegate _Delegate;


        IDelegateDefine 成员#region IDelegateDefine 成员

        /**//// <summary>
        /// 参数
        /// </summary>
        /// <value></value>
        public object[] Args
        ...{
            get ...{ return _Args; }
            set ...{ _Args = value; }
        }

        /**//// <summary>
        /// 委托
        /// </summary>
        /// <value></value>
        public Delegate Delegate
        ...{
            get ...{ return _Delegate; }
            protected set ...{ _Delegate = value; }
        }

        /**//// <summary>
        /// 调用
        /// </summary>
        /// <returns></returns>
        public abstract object Invoke();

        #endregion
    }

    /**//// <summary>
    /// 委托对象定义
    /// </summary>
    public interface IDelegateDefine
    ...{
        /**//// <summary>
        /// 名称
        /// </summary>
        string DelegateName ...{ get;}
        /**//// <summary>
        /// 参数
        /// </summary>
        object[] Args ...{ get;set;}
        /**//// <summary>
        /// 委托
        /// </summary>
        Delegate Delegate ...{ get;}
        /**//// <summary>
        /// 调用
        /// </summary>
        /// <returns></returns>
        object Invoke();
    }
}

    public class ObjectDelegateDefine : DelegateDefine
    ...{

        /**//// <summary>
        /// 建立的速度不快　很慢！！
        /// </summary>
        /// <param name="t"></param>
        /// <param name="obj"></param>
        /// <param name="methodname"></param>
        protected ObjectDelegateDefine(Type delegatetype, object obj, string methodname)
        ...{
            this.Delegate = Delegate.CreateDelegate(delegatetype, obj, methodname);
            this.DelegateName = methodname;
        }

        public ObjectDelegateDefine(object obj, string methodname)
            : this(typeof(voidDelegate), obj, methodname)
        ...{

        }

        delegate void voidDelegate();

        public override object Invoke()
        ...{
            (this.Delegate as voidDelegate)();
            return null;
        }

        /**//// <summary>
        /// 用于注册
        /// </summary>
        public static void Method()
        ...{
        }

    }

    /**//// <summary>
    /// #region license
    /// // **************************************************
    /// // Copyright (c) 2008 fengjian (icesun963@Gmail.com)
    /// // All rights reserved.
    /// // **************************************************
    /// #endregion
    /// 反射执行助手类
    /// </summary>
    class InvokeMemberHelper
    ...{

        反射对象帮助#region 反射对象帮助
        //由于需要进行反射对象的匹配不得不进行反射对象的注册问题
        //就是判断一个过程和函数是否拥有匹配的注册对象，如果拥有则使用委托执行
        //如果不存在则直接调用反射执行
        //当然也可以申明成通用的调用函数 object tager ( object );
        //这里需要几个函数 类型判断
        //委托查找


        #endregion

        /**//// <summary>
        /// 反射注册类型列表
        /// </summary>
        List<Type> _DelegateTypeList = new List<Type>();

        Dictionary<Type, Dictionary<ParameterInfo[], int>> _TypeDic = new Dictionary<Type, Dictionary<ParameterInfo[], int>>();

        delegate void voiddelgate();

       static InvokeMemberHelper _Instance;
        public static InvokeMemberHelper Instance
        ...{
            get
            ...{
                if (_Instance == null)
                ...{
                    _Instance = new InvokeMemberHelper();
                }
                return InvokeMemberHelper._Instance;
            }
            set ...{ _Instance = value; }
        }

        private InvokeMemberHelper()
        ...{
            RegDelegateType(typeof(ObjectDelegateDefine), typeof(ObjectDelegateDefine).GetMethod("Method"));
        }

        public void build(IReflection myclass)
        ...{
            //反射委托建立
            foreach (MethodInfo var in myclass.GetType().GetMethods())
            ...{
                Type t = GetDelegate(var);
                if (t != null)
                ...{
                    //建立委托
                    //这里该使用一个工厂生产对象 为了演示就不管了
                    myclass.DelegateDefine.Add(new ObjectDelegateDefine(myclass, var.Name));
                }
            }
        }



        /**//// <summary>
        /// 获取委托类型
        /// </summary>
        /// <param name="minfo"></param>
        /// <returns></returns>
        public Type GetDelegate(MethodInfo minfo)
        ...{
            int index = FindDelegate(minfo);
            if (index != -1)
            ...{
                return _DelegateTypeList[index];
            }
            return null;
        }

        /**//// <summary>
        /// 注册一个反射类型
        /// </summary>
        /// <param name="dtype"></param>
        public void RegDelegateType(Type dtype, MethodInfo minfo)
        ...{
            lock (_DelegateTypeList)
            ...{
                lock (_TypeDic)
                ...{
                    Type returntype = minfo.ReturnType;
                    ParameterInfo[] argstype = minfo.GetParameters();

                    if (_TypeDic.ContainsKey(returntype))
                    ...{

                        Dictionary<ParameterInfo[], int> subdic = _TypeDic[returntype];
                        if (!subdic.ContainsKey(argstype))
                        ...{
                            _DelegateTypeList.Add(dtype);
                            subdic.Add(argstype, _DelegateTypeList.Count);
                        }
                    }
                    else
                    ...{
                        Dictionary<ParameterInfo[], int> subdic = new Dictionary<ParameterInfo[], int>();
                        _DelegateTypeList.Add(dtype);
                        subdic.Add(argstype, _DelegateTypeList.Count -1);
                        _TypeDic.Add(returntype, subdic);
                    }
                }
            }
        }

        /**//// <summary>
        /// 通过成员定义查找匹配的对象
        /// </summary>
        /// <param name="minfo"></param>
        /// <returns></returns>
        protected int FindDelegate(MethodInfo minfo)
        ...{
            Type returntype = minfo.ReturnType;
           
            if (_TypeDic.ContainsKey(returntype))
            ...{
                 ParameterInfo[] argstype = minfo.GetParameters();
                Dictionary<ParameterInfo[], int> subdic = _TypeDic[returntype];
                if (subdic.ContainsKey(argstype))
                ...{
                    return subdic[argstype];
                }
                foreach (KeyValuePair<ParameterInfo[], int> var in subdic)
                ...{
                    int count = 0;
                    if (var.Key.Length == argstype.Length)
                    ...{
                        for (int i = 0; i < var.Key.Length ; i++)
                        ...{
                            if (var.Key[i] == argstype[i]) count++;
                        }
                    }
                    if (count == var.Key.Length)
                    ...{
                        return var.Value;
                    }
                }
            }

            return -1;
        }

    }

   /**//// <summary>
    /// #region license
    /// // **************************************************
    /// // Copyright (c) 2008 fengjian (icesun963@Gmail.com)
    /// // All rights reserved.
    /// // **************************************************
    /// #endregion
    /// 委托反射
    /// </summary>
    public class DelegateReflection : ReflectionCache
    ...{
        static DelegateReflection _Instance;
        public static DelegateReflection Instance
        ...{
            get
            ...{
                if (_Instance == null)
                ...{
                    _Instance = new DelegateReflection();
                }
                return DelegateReflection._Instance;
            }
            set ...{ _Instance = value; }
        }

        private DelegateReflection()
        ...{
        }

        protected override int AddtoCache(ICloneable obj, object[] args)
        ...{
            if (obj is IReflection)
            ...{
                InvokeMemberHelper.Instance.build(obj as IReflection);
            }
            return base.AddtoCache(obj, args);
        }
    }

贴完了，有点多。。。。

也很乱，我知道，嗯，这里只对 void (void) 这样的函数进行了处理，本来还有个工厂的，不过暂时懒得写了，代码有点乱，大家也多担待，有什么问题，可以直接留言，如果少了那部分，如果我有贴漏的话无会补上，如果需要完整代码請留言，有空我会打包上来的。

希望大家喜欢她 ：）

PS:那个速度有点问题 由于个人的粗心忘记修改了一个过程也就是直接运算的类的继承，直接的运算速度是

00:00:00.04750000左右。我这里加上了初始化也就慢了20倍但是相对以前的数百倍来说 ，确实是个好消息，不是么，如果除去初始化，我相信效果会让人满意的 ！