Ejemplo n.º 1
0
        /// <summary>
        /// 删除钩子
        /// </summary>
        /// <param name="obj">目标对象</param>
        /// <param name="method">目标方法</param>
        /// <param name="action">要删除的钩子</param>
        public static void DeHookAfter(object obj, MethodInfo method, Action <HookArgs> action)
        {
            MethodSign m = new MethodSign(obj, method);

            //检测是否存在,不存在则抛出错误
            if (!After[m].Contains(action))
            {
                throw new ArgumentException("要删除的钩子不存在", "action");
            }
            After[m].Remove(action);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// 注入代码于方法执行前
        /// </summary>
        /// <param name="obj">目标对象,为null则注入所有对象的该方法或注入静态方法</param>
        /// <param name="method">目标方法对象,可将目标方法转为委托后通过Method属性获得</param>
        /// <param name="action">要注入的方法</param>
        public static void HookBefore(object obj, MethodInfo method, Action <HookArgs> action)
        {
            MethodSign m = new MethodSign(obj, method);

            if (!Before.ContainsKey(m))
            {
                //如果不存在映射列表,创建列表
                Before.Add(m, new List <Action <HookArgs> >());
            }
            Before[m].Add(action);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// 注入代码顶替原先方法
        /// </summary>
        /// <param name="obj">目标对象,为null则注入所有对象的该方法或注入静态方法</param>
        /// <param name="method">目标方法对象,可将目标方法转为委托后通过Method属性获得</param>
        /// <param name="action">要注入的方法</param>
        public static void HookInstead(object obj, MethodInfo method, Action <HookArgs> action)
        {
            MethodSign m = new MethodSign(obj, method);

            if (Instead.ContainsKey(m))
            {
                //当已被替代时,抛出此错误
                throw new HookInsteadException();
            }
            Instead.Add(m, action);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// 注入代码于方法执行后
        /// </summary>
        /// <param name="obj">目标对象,为null则注入所有对象的该方法或注入静态方法</param>
        /// <param name="method">目标方法对象,可将目标方法转为委托后通过Method属性获得</param>
        /// <param name="action">要注入的方法</param>
        public static void HookAfter(object obj, MethodInfo method, Action <HookArgs> action)
        {
            MethodSign m = new MethodSign(obj, method);

            if (!After.ContainsKey(m))
            {
                //如果不存在映射列表,创建列表
                After.Add(m, new List <Action <HookArgs> >());
            }
            After[m].Add(action);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// 注入代码顶替原先方法
        /// </summary>
        /// <param name="obj">目标对象,为null则注入所有对象的该方法或注入静态属性</param>
        /// <param name="property">目标属性对象,可以通过目标对象的Type中的GetProperty获得</param>
        /// <param name="action">要注入的方法</param>
        /// <param name="isGet">是否是Get访问器</param>
        public static void HookInstead(object obj, PropertyInfo property, Action <HookArgs> action, bool isGet)
        {
            MethodSign m;

            if (isGet)
            {
                //注入Get方法
                m = new MethodSign(obj, property.GetGetMethod());
            }
            else
            {
                //注入Set方法
                m = new MethodSign(obj, property.GetSetMethod());
            }
            if (Instead.ContainsKey(m))
            {
                //当已被替代时,抛出此错误
                throw new HookInsteadException();
            }
            Instead.Add(m, action);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// 注入代码于属性执行前
        /// </summary>
        /// <param name="obj">目标对象,为null则注入所有对象的该方法或注入静态属性</param>
        /// <param name="property">目标属性对象,可以通过目标对象的Type中的GetProperty获得</param>
        /// <param name="action">要注入的方法</param>
        /// <param name="isGet">是否是Get访问器</param>
        public static void HookBefore(object obj, PropertyInfo property, Action <HookArgs> action, bool isGet)
        {
            MethodSign m;

            if (isGet)
            {
                //注入Get方法
                //当obj为null,标识为0
                m = new MethodSign(obj, property.GetGetMethod());
            }
            else
            {
                //注入Set方法
                m = new MethodSign(obj, property.GetSetMethod());
            }
            if (!Before.ContainsKey(m))
            {
                //如果不存在映射列表,创建列表
                Before.Add(m, new List <Action <HookArgs> >());
            }
            Before[m].Add(action);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// 注入代码于属性执行后
        /// </summary>
        /// <param name="obj">目标对象,为null则注入所有对象的该方法或注入静态属性</param>
        /// <param name="property">目标属性对象,可以通过目标对象的Type中的GetProperty获得</param>
        /// <param name="action">要注入的方法</param>
        /// <param name="isGet">是否是Get访问器</param>
        public static void HookAfter(object obj, PropertyInfo property, Action <HookArgs> action, bool isGet)
        {
            MethodSign m;

            if (isGet)
            {
                //注入Get方法

                m = new MethodSign(obj, property.GetGetMethod());
            }
            else
            {
                //注入Set方法
                m = new MethodSign(obj, property.GetSetMethod());
            }
            if (!After.ContainsKey(m))
            {
                //如果不存在映射列表,创建列表
                After.Add(m, new List <Action <HookArgs> >());
            }
            After[m].Add(action);
        }
Ejemplo n.º 8
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="method">方法标识</param>
        /// <param name="args">方法信息</param>
        /// <returns>方法返回值</returns>
        public static object Execute(MethodSign method, HookArgs args)
        {
            //检查是否存在注入Before的函数
            if (Before.ContainsKey(method))
            {
                //注入before的函数列表
                var list = Before[method];
                //长度
                int length = list.Count;
                //遍历执行
                for (int i = 0; i < length; i++)
                {
                    list[i](args);
                    //检测是否要停止执行函数
                    if (args.IsReturn)
                    {
                        //如果是立即停止,跳转到Return
                        if (args.IsReturnNow)
                        {
                            goto Return;
                        }
                        else
                        {
                            //否则执行注入After的内容
                            goto After;
                        }
                    }
                }
            }
            //如果该方法是对象方法,检测是否存在注入所有对象的该方法before的函数
            if (method.obj != 0 && Before.ContainsKey(new MethodSign(0, method.method)))
            {
                //注入before的函数列表
                var list = Before[new MethodSign(0, method.method)];
                //长度
                int length = list.Count;
                //遍历执行
                for (int i = 0; i < length; i++)
                {
                    list[i](args);
                    //检测是否要停止执行函数
                    if (args.IsReturn)
                    {
                        //如果是立即停止,跳转到Return
                        if (args.IsReturnNow)
                        {
                            goto Return;
                        }
                        else
                        {
                            //否则执行注入After的内容
                            goto After;
                        }
                    }
                }
            }
            //检测原方法是否被代替
            if (Instead.ContainsKey(method))
            {
                Instead[method](args);
                //检测是否直接返回,跳过注入After的函数的执行
                if (args.IsReturnNow)
                {
                    goto Return;
                }
            }
            else if (method.obj != 0 && Instead.ContainsKey(new MethodSign(0, method.method)))
            {
                Instead[new MethodSign(0, method.method)](args);
                //检测是否直接返回,跳过注入After的函数的执行
                if (args.IsReturnNow)
                {
                    goto Return;
                }
            }
            else
            {
                args.Original();
            }
After:
            //检查是否存在注入After的函数
            if (After.ContainsKey(method))
            {
                //注入After的函数列表
                var list = After[method];
                //长度
                int length = list.Count;
                //遍历执行
                for (int i = 0; i < length; i++)
                {
                    list[i](args);
                    //检测是否要直接返回
                    if (args.IsReturnNow)
                    {
                        goto Return;
                    }
                }
            }
            //同理
            if (method.obj != 0 && After.ContainsKey(new MethodSign(0, method.method)))
            {
                //注入After的函数列表
                var list = After[new MethodSign(0, method.method)];
                //长度
                int length = list.Count;
                //遍历执行
                for (int i = 0; i < length; i++)
                {
                    list[i](args);
                    //检测是否要直接返回
                    if (args.IsReturnNow)
                    {
                        goto Return;
                    }
                }
            }
Return:
            return(args.ReturnValue);
        }