diff --git a/DotNetDetour/AssemblyUtil.cs b/DotNetDetour/AssemblyUtil.cs
index 1e7cb62..71838f1 100644
--- a/DotNetDetour/AssemblyUtil.cs
+++ b/DotNetDetour/AssemblyUtil.cs
@@ -124,7 +124,7 @@ public static IEnumerable<TBaseInterface> GetImplementedObjectsByInterface<TBase
         public static IEnumerable<TBaseInterface> GetImplementedObjectsByInterface<TBaseInterface>(this Assembly assembly, Type targetType)
             where TBaseInterface : class
         {
-            Type[] arrType = assembly.GetExportedTypes();
+            Type[] arrType = assembly.GetTypes();
 
             var result = new List<TBaseInterface>();
 
diff --git a/DotNetDetour/DetourWays/NativeDetourFor32Bit.cs b/DotNetDetour/DetourWays/NativeDetourFor32Bit.cs
index fdaf7ad..5d097c1 100644
--- a/DotNetDetour/DetourWays/NativeDetourFor32Bit.cs
+++ b/DotNetDetour/DetourWays/NativeDetourFor32Bit.cs
@@ -16,68 +16,97 @@ namespace DotNetDetour.DetourWays
     /// <summary>
     /// inline hook,通过修改函数的前5字节指令为jmp target_addr实现
     /// </summary>
-    public unsafe class NativeDetourFor32Bit: IDetour
+    public unsafe class NativeDetourFor32Bit : IDetour
     {
         //protected byte[] originalInstrs = new byte[5];
         protected byte[] newInstrs = { 0xE9, 0x90, 0x90, 0x90, 0x90 }; //jmp target
-        protected byte* srcPtr;
+        protected byte* rawMethodPtr;
 
         public NativeDetourFor32Bit()
         {
         }
 
-        public virtual void Patch(MethodInfo src, MethodInfo dest,MethodInfo ori)
+        public virtual bool Patch(MethodBase rawMethod/*要hook的目标函数*/, 
+            MethodInfo customImplMethod/*用户定义的函数，可以调用占位函数来实现对原函数的调用*/, 
+            MethodInfo placeholder/*占位函数*/)
         {
             //确保jit过了
-            var typeHandles = src.DeclaringType.GetGenericArguments().Select(t => t.TypeHandle).ToArray();
-            RuntimeHelpers.PrepareMethod(src.MethodHandle, typeHandles);
-            
-            srcPtr = (byte*)src.MethodHandle.GetFunctionPointer().ToPointer();
-            var destPtr = (byte*)dest.MethodHandle.GetFunctionPointer().ToPointer();
-            if (ori != null)
+            var typeHandles = rawMethod.DeclaringType.GetGenericArguments().Select(t => t.TypeHandle).ToArray();
+            RuntimeHelpers.PrepareMethod(rawMethod.MethodHandle, typeHandles);
+
+            rawMethodPtr = (byte*)rawMethod.MethodHandle.GetFunctionPointer().ToPointer();
+
+            var customImplMethodPtr = (byte*)customImplMethod.MethodHandle.GetFunctionPointer().ToPointer();
+            //生成跳转指令，使用相对地址，用于跳转到用户定义函数
+            fixed (byte* newInstrPtr = newInstrs)
+            {
+                *(uint*)(newInstrPtr + 1) = (uint)customImplMethodPtr - (uint)rawMethodPtr - 5;
+            }
+
+            //因测试项目的特殊性，确保测试项目代码不会重入
+            if (IsDetourInstalled())
             {
-                CreateOriginalMethod(ori); //生成原函数
+                return false;
             }
-            fixed (byte* newInstrPtr=newInstrs)
+
+            //将对占位函数的调用指向原函数，实现调用占位函数即调用原始函数的功能
+            if (placeholder != null)
             {
-                *(uint*)(newInstrPtr + 1) = (uint)destPtr - (uint)srcPtr - 5;
+                MakePlacholderMethodCallPointsToRawMethod(placeholder);
             }
+
+
+            //并且将对原函数的调用指向跳转指令，以此实现将对原始目标函数的调用跳转到用户定义函数执行的目的
             Patch();
+            return true;
         }
 
         protected virtual void Patch()
         {
             uint oldProtect;
             //系统方法没有写权限，需要修改页属性
-            NativeAPI.VirtualProtect((IntPtr)srcPtr, 5, Protection.PAGE_EXECUTE_READWRITE, out oldProtect);
+            NativeAPI.VirtualProtect((IntPtr)rawMethodPtr, 5, Protection.PAGE_EXECUTE_READWRITE, out oldProtect);
             for (int i = 0; i < newInstrs.Length; i++)
             {
-                *(srcPtr + i) = newInstrs[i];
+                *(rawMethodPtr + i) = newInstrs[i];
             }
         }
 
-        protected virtual void CreateOriginalMethod(MethodInfo method)
+        /// <summary>
+        /// 将对placeholder的调用指向原函数
+        /// </summary>
+        /// <param name="placeholder"></param>
+        protected virtual void MakePlacholderMethodCallPointsToRawMethod(MethodInfo placeholder)
         {
             uint oldProtect;
-            var needSize = LDasm.SizeofMin5Byte(srcPtr);
+            var needSize = LDasm.SizeofMin5Byte(rawMethodPtr);
             var total_length = (int)needSize + 5;
             byte[] code = new byte[total_length];
             IntPtr ptr = Marshal.AllocHGlobal(total_length);
             //code[0] = 0xcc;//调试用
             for (int i = 0; i < needSize; i++)
             {
-                code[i] = srcPtr[i];
+                code[i] = rawMethodPtr[i];
             }
             code[needSize] = 0xE9;
             fixed (byte* p = &code[needSize + 1])
             {
-                *((uint*)p) = (uint)srcPtr - (uint)ptr - 5;
+                *((uint*)p) = (uint)rawMethodPtr - (uint)ptr - 5;
             }
             Marshal.Copy(code, 0, ptr, total_length);
             NativeAPI.VirtualProtect(ptr, (uint)total_length, Protection.PAGE_EXECUTE_READWRITE, out oldProtect);
-            RuntimeHelpers.PrepareMethod(method.MethodHandle);
-            *((uint*)method.MethodHandle.Value.ToPointer() + 2) = (uint)ptr;
+            RuntimeHelpers.PrepareMethod(placeholder.MethodHandle);
+            *((uint*)placeholder.MethodHandle.Value.ToPointer() + 2) = (uint)ptr;
         }
 
+        public virtual bool IsDetourInstalled()
+        {
+            byte[] v = new byte[newInstrs.Length];
+            for (int i = 0; i < v.Length; i++)
+            {
+                v[i] = *(rawMethodPtr + i);
+            }
+            return v.SequenceEqual(newInstrs);
+        }
     }
 }
diff --git a/DotNetDetour/DetourWays/NativeDetourFor64Bit.cs b/DotNetDetour/DetourWays/NativeDetourFor64Bit.cs
index 680510f..fc0f04f 100644
--- a/DotNetDetour/DetourWays/NativeDetourFor64Bit.cs
+++ b/DotNetDetour/DetourWays/NativeDetourFor64Bit.cs
@@ -21,18 +21,18 @@ public unsafe class NativeDetourFor64Bit : NativeDetourFor32Bit
             0xC2,0x08,0x00                                     //ret 8
         };
 
-        protected override void CreateOriginalMethod(MethodInfo method)
+        protected override void MakePlacholderMethodCallPointsToRawMethod(MethodInfo method)
         {
             uint oldProtect;
-            var needSize = LDasm.SizeofMin5Byte(srcPtr);
+            var needSize = LDasm.SizeofMin5Byte(rawMethodPtr);
             byte[] src_instr = new byte[needSize];
             for (int i = 0; i < needSize; i++)
             {
-                src_instr[i] = srcPtr[i];
+                src_instr[i] = rawMethodPtr[i];
             }
             fixed (byte* p = &jmp_inst[3])
             {
-                *((ulong*)p) = (ulong)(srcPtr + needSize);
+                *((ulong*)p) = (ulong)(rawMethodPtr + needSize);
             }
             var totalLength = src_instr.Length + jmp_inst.Length;
             IntPtr ptr = Marshal.AllocHGlobal(totalLength);
diff --git a/DotNetDetour/DotNetDetour.csproj b/DotNetDetour/DotNetDetour.csproj
index a8bb5fc..a6aa03d 100644
--- a/DotNetDetour/DotNetDetour.csproj
+++ b/DotNetDetour/DotNetDetour.csproj
@@ -57,6 +57,12 @@
     <Compile Include="OriginalAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="..\README.md">
+      <Link>README.md</Link>
+    </None>
+    <None Include="DotNetDetour.nuspec" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/DotNetDetour/DotNetDetour.nuspec b/DotNetDetour/DotNetDetour.nuspec
index 76af7dd..835c05f 100644
--- a/DotNetDetour/DotNetDetour.nuspec
+++ b/DotNetDetour/DotNetDetour.nuspec
@@ -1,10 +1,10 @@
 <?xml version="1.0"?>
 <package >
   <metadata>
-    <id>DotNetDetour</id>
+    <id>kissstudio.DotNetDetour</id>
     <version>1.0.2.0</version>
-    <authors>bigbaldy</authors>
-    <owners>bigbaldy</owners>
+    <authors>kissstudio</authors>
+    <owners>kissstudio</owners>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>dotnet hook库</description>
     <copyright>Copyright 2016</copyright>
diff --git a/DotNetDetour/IDetour.cs b/DotNetDetour/IDetour.cs
index 2adebfd..9a62a6d 100644
--- a/DotNetDetour/IDetour.cs
+++ b/DotNetDetour/IDetour.cs
@@ -9,6 +9,15 @@ namespace DotNetDetour
 {
     public interface IDetour
     {
-        void Patch(MethodInfo src, MethodInfo dest, MethodInfo ori);
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="rawMethod">要hook的目标函数</param>
+        /// <param name="customImplMethod">用户定义的函数，可以调用占位函数来实现对原函数的调用</param>
+        /// <param name="placeholder">占位函数</param>
+        bool Patch(MethodBase rawMethod/*要hook的目标函数*/,
+            MethodInfo customImplMethod/*用户定义的函数，可以调用占位函数来实现对原函数的调用*/,
+            MethodInfo placeholder/*占位函数*/);
+        bool IsDetourInstalled();
     }
 }
diff --git a/DotNetDetour/IMethodMonitor.cs b/DotNetDetour/IMethodMonitor.cs
index 4128083..6b28779 100644
--- a/DotNetDetour/IMethodMonitor.cs
+++ b/DotNetDetour/IMethodMonitor.cs
@@ -6,7 +6,7 @@
 
 namespace DotNetDetour
 {
-    public interface IMethodMonitor
+    public interface IMethodHook
     {
     }
 }
diff --git a/DotNetDetour/Monitor.cs b/DotNetDetour/Monitor.cs
index 97fdb65..4bd2182 100644
--- a/DotNetDetour/Monitor.cs
+++ b/DotNetDetour/Monitor.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -8,13 +9,28 @@
 
 namespace DotNetDetour
 {
+    [DebuggerDisplay("{TargetTypeFullName}.{MethodName}")]
     class DestAndOri
     {
-        public MethodInfo Dest;
-        public MethodInfo Ori;
+        /// <summary>
+        /// 代理方法
+        /// </summary>
+        public MethodInfo ProxyMethod;
+        public string MethodName;
+        public Type TargetType;
+        /// <summary>
+        /// 目标方法的影子方法，用于确认签名
+        /// </summary>
+        public MethodInfo ShadowMethod;
+
+        public string TargetTypeFullName { get; internal set; }
+        public override string ToString()
+        {
+            return $"{TargetTypeFullName}.{MethodName}".ToString();
+        }
     }
 
-    public class Monitor
+    public class ClrMethodHook
     {
         static bool installed = false;
         static List<DestAndOri> destAndOris = new List<DestAndOri>();
@@ -27,32 +43,49 @@ public static void Install(string dir = null)
                 return;
             installed = true;
             var assemblies = AppDomain.CurrentDomain.GetAssemblies();
-            IEnumerable<IMethodMonitor> monitors;
+            IEnumerable<IMethodHook> monitors;
             if (string.IsNullOrEmpty(dir))
             {
-                monitors = assemblies.SelectMany(t => t.GetImplementedObjectsByInterface<IMethodMonitor>());
+                monitors = assemblies.SelectMany(t => t.GetImplementedObjectsByInterface<IMethodHook>());
             }
             else
             {
-                monitors = Directory
-                            .GetFiles(dir)
-                            .SelectMany(d => Assembly.LoadFrom(d).GetImplementedObjectsByInterface<IMethodMonitor>());
+                assemblies = assemblies.Concat(Directory
+                            .GetFiles(dir, "*.dll")
+                            .Select(d => { try { return Assembly.LoadFrom(d); } catch { return null; } })
+                            .Where(x => x != null))
+                            .Distinct()
+                            .ToArray();
+                monitors = assemblies
+                            .SelectMany(d => d.GetImplementedObjectsByInterface<IMethodHook>());
             }
+            List<MethodInfo> proxyMethods = new List<MethodInfo>();
+            List<MethodInfo> clrMethods = new List<MethodInfo>();
             foreach (var monitor in monitors)
             {
-                DestAndOri destAndOri = new DestAndOri();
-                destAndOri.Dest= monitor
-                            .GetType()
-                            .GetMethods()
-                            .FirstOrDefault(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(MonitorAttribute)));
-                destAndOri.Ori = monitor
-                            .GetType()
-                            .GetMethods()
-                            .FirstOrDefault(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(OriginalAttribute)));
-                if (destAndOri.Dest != null)
-                {
-                    destAndOris.Add(destAndOri);
-                }
+                var type = monitor.GetType();
+
+
+
+                proxyMethods.AddRange(type.GetMethods().Where(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(RelocatedMethodAttribute))));
+                proxyMethods.AddRange(type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic).Where(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(RelocatedMethodAttribute))));
+                proxyMethods.AddRange(type.GetMethods(BindingFlags.Static | BindingFlags.NonPublic).Where(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(RelocatedMethodAttribute))));
+
+                clrMethods.AddRange(type.GetMethods().Where(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(ShadowMethodAttribute))));
+                clrMethods.AddRange(type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic).Where(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(ShadowMethodAttribute))));
+                clrMethods.AddRange(type.GetMethods(BindingFlags.Static | BindingFlags.NonPublic).Where(t => t.CustomAttributes.Any(a => a.AttributeType == typeof(ShadowMethodAttribute))));
+            }
+            foreach (var item in proxyMethods.Distinct())
+            {
+                DestAndOri detour = new DestAndOri();
+                var proxyMethodAttr = item.GetCustomAttribute<RelocatedMethodAttribute>();
+                var clrMethod = clrMethods.FirstOrDefault(x => ParametersSequenceEqual(x, item) && x.GetCustomAttribute<ShadowMethodAttribute>().TargetMethodName == proxyMethodAttr.TargetMethodName);
+                detour.ProxyMethod = item;
+                detour.ShadowMethod = clrMethod;
+                detour.MethodName = proxyMethodAttr.TargetMethodName;
+                detour.TargetType = proxyMethodAttr.TargetType;
+                detour.TargetTypeFullName = proxyMethodAttr.TargetTypeName;
+                destAndOris.Add(detour);
             }
             InstallInternal(assemblies);
             AppDomain.CurrentDomain.AssemblyLoad += CurrentDomain_AssemblyLoad;
@@ -60,36 +93,129 @@ public static void Install(string dir = null)
 
         private static void InstallInternal(Assembly[] assemblies)
         {
-            foreach (var destAndOri in destAndOris)
+            foreach (var detour in destAndOris)
             {
-                MethodInfo src = null;
-                var dest = destAndOri.Dest;
-                var monitorAttribute = dest.GetCustomAttribute(typeof(MonitorAttribute)) as MonitorAttribute;
-                var methodName = dest.Name;
-                var paramTypes = dest.GetParameters().Select(t => t.ParameterType).ToArray();
-                if (monitorAttribute.Type != null)
+                MethodBase rawMethod = null;
+                var customImplMethod = detour.ProxyMethod;
+                var methodName = detour.MethodName;
+                var paramTypes = customImplMethod.GetParameters().Select(t => t.ParameterType).ToArray();
+                foreach (var asm in assemblies)
                 {
-                    src = monitorAttribute.Type.GetMethod(methodName, paramTypes);
+                    Type type = null;
+                    if (detour.TargetType.IsGenericType)
+                    {
+                        type = asm.GetTypes().FirstOrDefault(t => t.BaseType == detour.TargetType.DeclaringType && detour.TargetType.GenericTypeArguments.SequenceEqual(t.GenericTypeArguments));
+                        if (type == null)
+                        {
+                            type = asm.GetTypes().FirstOrDefault(t => t.Name == detour.TargetType.Name && t.Namespace == detour.TargetType.Namespace && t.Module.FullyQualifiedName == detour.TargetType.Module.FullyQualifiedName);
+                            if (type == null)
+                            {
+                                var types = asm.GetTypes().Where(t => t.Name.StartsWith("Computer"));
+                                if (types.Any())
+                                {
+                                    var m = type.GenericTypeArguments.SequenceEqual(detour.TargetType.GenericTypeArguments);
+                                }
+                            }
+                            else
+                            {
+                                type = type.MakeGenericType(detour.TargetType.GenericTypeArguments);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        type = asm.GetTypes().FirstOrDefault(t => t.FullName == detour.TargetTypeFullName);
+                    }
+                    if (type != null)
+                    {
+                        if (methodName == ".ctor")
+                        {
+                            rawMethod = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                                .FirstOrDefault(item => item.Name == methodName
+                                && ParametersSequenceEqual(item.GetParameters().ToList(), (detour.ShadowMethod ?? customImplMethod).GetParameters().ToList(), assemblies));
+                        }
+                        else
+                        {
+                            rawMethod = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)
+                            //src = type.GetMethods((detour.ShadowMethod.IsPublic ? BindingFlags.Public : BindingFlags.NonPublic) | (detour.ShadowMethod.IsStatic ? BindingFlags.Static : BindingFlags.Instance))
+                                .FirstOrDefault(item => item.Name == methodName
+                                && ParametersSequenceEqual(item.GetParameters().ToList(), (detour.ShadowMethod ?? customImplMethod).GetParameters().ToList(), assemblies));
+
+                        }
+                        break;
+                    }
+                }
+                if (rawMethod == null)
+                {
+                    Debug.WriteLine("没有找到与试图Hook的方法\"{0}\"匹配的目标方法.", new object[] { detour.TargetTypeFullName + "." + detour.MethodName });
+                    continue;
+                }
+
+                var shadowMethod = detour.ShadowMethod;
+
+                //IsStatic必须一致，否则报内存访问错误
+                if (rawMethod.IsStatic != shadowMethod.IsStatic)
+                {
+                    var clrDesc = rawMethod.IsStatic ? "static" : "  non static";
+                    var shadowDesc = shadowMethod.IsStatic ? "static" : "  non static";
+                    throw new Exception(string.Format("the method \"{0}\" you implemented is {1}, but the target method \"{2}\" is {3}",
+                        shadowMethod.DeclaringType + "." + shadowMethod.Name,
+                        shadowDesc,
+                        rawMethod.DeclaringType + "." + rawMethod.Name,
+                        clrDesc
+                        ));
+                }
+                var engine = DetourFactory.CreateDetourEngine();
+                if (engine.Patch(rawMethod, customImplMethod, shadowMethod))
+                {
+                    Debug.WriteLine("已将目标方法 \"{0}\" 的调用指向 \"{1}\".", new object[] { rawMethod.DeclaringType + "." + rawMethod.Name, customImplMethod.DeclaringType + "." + customImplMethod.Name });
                 }
                 else
                 {
-                    var srcNamespaceAndClass = monitorAttribute.NamespaceName + "." + monitorAttribute.ClassName;
-                    foreach (var asm in assemblies)
+                    Debug.WriteLine("可能在历史调用中已将目标方法的调用\"{0}\"指向\"{1}\".", new object[] { rawMethod.DeclaringType + "." + rawMethod.Name, customImplMethod.DeclaringType + "." + customImplMethod.Name });
+                }
+            }
+        }
+        public static bool ParametersSequenceEqual(MethodBase p1, MethodBase p2)
+        {
+            return p1.GetParameters().Select(x => x.ParameterType).SequenceEqual(p2.GetParameters().Select(x => x.ParameterType));
+        }
+        public static bool ParametersSequenceEqual(List<ParameterInfo> p1, List<ParameterInfo> p2, Assembly[] assemblies)
+        {
+            if (p1.SequenceEqual(p2))
+            {
+                return true;
+            }
+            else if (p1.Count() != p2.Count())
+            {
+                return false;
+            }
+            else
+            {
+                foreach (var type2 in p2)
+                {
+                    var index = p2.IndexOf(type2);
+                    var d = type2.GetCustomAttributesData();
+                    var opt = type2.GetCustomAttribute<NonPublicParameterTypeAttribute>();
+                    if (opt != null)
                     {
-                        var type= asm.GetExportedTypes().FirstOrDefault(t => t.FullName == srcNamespaceAndClass);
-                        if (type != null)
+                        var itemType = assemblies.SelectMany(x => x.GetTypes()).FirstOrDefault(x => x.FullName == opt.FullName);
+                        if (itemType != null && itemType.Equals(p1[index].ParameterType))
+                        {
+                            continue;
+                        }
+                        else
                         {
-                            src = type.GetMethod(methodName, paramTypes);
-                            break;
+                            return false;
                         }
                     }
+                    else if (!type2.ParameterType.Equals(p1[index].ParameterType))
+                    {
+                        return false;
+                    }
                 }
-                if (src == null)
-                    continue;
-                var ori = destAndOri.Ori;
-                var engine = DetourFactory.CreateDetourEngine();
-                engine.Patch(src, dest, ori);
             }
+            return true;
         }
 
         private static void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
diff --git a/DotNetDetour/MonitorAttribute.cs b/DotNetDetour/MonitorAttribute.cs
index 487bb9d..3533782 100644
--- a/DotNetDetour/MonitorAttribute.cs
+++ b/DotNetDetour/MonitorAttribute.cs
@@ -6,22 +6,34 @@
 
 namespace DotNetDetour
 {
+    /// <summary>
+    /// 标记一个方法，使其作为目标方法的替代，这将使.NET框架执行到原始方法时转而执行被此特性标记的方法
+    /// </summary>
     [AttributeUsage(AttributeTargets.Method)]
-    public class MonitorAttribute:Attribute
+    public class RelocatedMethodAttribute : Attribute
     {
-        public string NamespaceName { get; set; }
-        public string ClassName { get; set; }
-        public Type Type { get; set; }
+        public string TargetTypeName { get; set; }
+        public string TargetMethodName { get; private set; }
+        public Type TargetType { get; set; }
+        public string AssemblyQualifiedName { get; set; }
 
-        public MonitorAttribute(string NamespaceName,string ClassName)
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="targetClassName">target class full name</param>
+        /// <param name="methodName"></param>
+        public RelocatedMethodAttribute(string targetClassName, string methodName)
         {
-            this.NamespaceName = NamespaceName;
-            this.ClassName = ClassName;
+            this.TargetTypeName = targetClassName;
+            this.TargetMethodName = methodName;
         }
 
-        public MonitorAttribute(Type type)
+        public RelocatedMethodAttribute(Type targetType, string methodName)
         {
-            this.Type = type;
+            this.TargetType = targetType;
+            this.TargetTypeName = targetType.FullName;
+            this.TargetMethodName = methodName;
+            this.AssemblyQualifiedName = targetType.AssemblyQualifiedName;
         }
     }
 }
diff --git a/DotNetDetour/OriginalAttribute.cs b/DotNetDetour/OriginalAttribute.cs
index 2aa2987..5344668 100644
--- a/DotNetDetour/OriginalAttribute.cs
+++ b/DotNetDetour/OriginalAttribute.cs
@@ -6,8 +6,38 @@
 
 namespace DotNetDetour
 {
+    /// <summary>
+    /// 标记一个方法，使得该方法代表原始方法，从而可以被用户代码调用
+    /// </summary>
     [AttributeUsage(AttributeTargets.Method)]
-    public class OriginalAttribute:Attribute
+    public class ShadowMethodAttribute : Attribute
     {
+        public string TargetMethodName;
+        public string TargetTypeName { get; set; }
+        public Type TargetType { get; private set; }
+        public ShadowMethodAttribute(string targetTypeName, string methodName)
+        {
+            this.TargetTypeName = targetTypeName;
+            this.TargetMethodName = methodName;
+        }
+
+        public ShadowMethodAttribute(Type classType, string methodName)
+        {
+            this.TargetType = classType;
+            this.TargetTypeName = classType.FullName;
+            this.TargetMethodName = methodName;
+        }
+    }
+    /// <summary>
+    /// 标记函数参数，指明其类型
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Parameter)]
+    public class NonPublicParameterTypeAttribute : Attribute
+    {
+        public NonPublicParameterTypeAttribute(string fullName)
+        {
+            this.FullName = fullName;
+        }
+        public string FullName { get; set; }
     }
 }
diff --git a/README.md b/README.md
index d7d6ef5..3b90b75 100644
--- a/README.md
+++ b/README.md
@@ -1,46 +1,124 @@
+
+[![Build Status](https://dev.azure.com/kissstudio/DotNetDetour/_apis/build/status/kissstudio.DotNetDetour?branchName=master)](https://dev.azure.com/kissstudio/DotNetDetour/_build/latest?definitionId=3?branchName=master)
 ## DotNetDetour
 DotNetDetour是一个用于.net方法hook的类库
 ##特点
 * 支持32bit和64bit的.net程序
-* 支持.net framework 2.0以上的所有版本
 * 支持静态方法，实例方法、属性方法、泛型方法的hook
 * 支持.net基础类库方法的hook
 * 无任何性能影响
 
 ##快速示例
-1.安装：Install-Package DotNetDetour
+1.安装：Install-Package kissstudio.DotNetDetour, 
+注意，DotNetDetour是原作者的版本，kissstudio.DotNetDetour 是我修改的版本，方法匹配兼容性更好，内核未做变动
+
+2.参考以下例子实现IMethodHook接口，使用特性标记要Hook的方法
 
-2.新建一个类并继承IMethodMonitor接口
 ```
-public class CustomMonitor : IMethodMonitor //自定义一个类并继承IMethodMonitor接口
-{
-    [Monitor("TargetNamespace","TargetClass")] //目标方法的名称空间，类名
-    public string Get() //方法签名要与目标方法一致
+public class ComputerDetour : IMethodHook
     {
-        return "B" + Ori();
+        #region 静态方法HOOK
+        [RelocatedMethodAttribute(typeof(Computer), "GetCpu")]
+        public static string _impl_GetCpu()
+        {
+            return "Not " + GetCpu();
+        }
+
+        [ShadowMethod(typeof(Computer), "GetCpu")]
+        public static string GetCpu()
+        {
+            return null;
+        }
+        #endregion
+
+        #region 实例方法
+        [RelocatedMethodAttribute(typeof(Computer), "GetRAMSize")]
+        public string _impl_GetRAMSize()
+        {
+            return "Not " + GetRAMSize();
+        }
+
+        [ShadowMethod(typeof(Computer), "GetRAMSize")]
+        public string GetRAMSize()
+        {
+            return null;
+        }
+        #endregion
+
+
+        #region 实例属性
+        public string _impl_Os
+        {
+            [RelocatedMethodAttribute(typeof(Computer), "get_Os")]
+            get
+            {
+                return "Not " + Os;
+            }
+        }
+
+        public string Os
+        {
+
+            [ShadowMethod(typeof(Computer), "get_Os")]
+            get
+            {
+                return null;
+            }
+        }
+        #endregion
+
+        #region 泛型方法
+        [RelocatedMethodAttribute(typeof(ComputerOf<string>), "ComputerIo")]
+        public string _impl_ComputerIo(string name)
+        {
+            var human = ComputerIo(name);
+            human = "Not " + human;
+            return human;
+        }
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        [ShadowMethod(typeof(ComputerOf<string>), "ComputerIo")]
+        public string ComputerIo(string owner)
+        {
+            return null;
+        }
+        #endregion
     }
 
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    [Original] //原函数标记
-    public string Ori() //方法签名要与目标方法一致
+    public class NetFrameworkDetour : IMethodHook
     {
-        return null; //这里写什么无所谓，能编译过即可
+        [RelocatedMethod(typeof(System.IO.File), "ReadAllText")]
+        public static string _impl_ReadAllText(string file)
+        {
+            try
+            {
+                return ReadAllText(file) + "NetFrameworkDetour";
+            }
+            catch (Exception ex)
+            {
+                Debugger.Break();
+                throw;
+            }
+        }
+
+        [ShadowMethod(typeof(System.IO.File), "ReadAllText")]
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static string ReadAllText(string file)
+        {
+            return null;
+        }
     }
-}
-```
-3.定义目标函数，例如：
 ```
-public string Get()
-{
-    return "A"
-}
-```
-4.安装监视器
-```
-Console.WrtieLine(Get());
-Monitor.Install()
-Console.WrtieLine(Get());
+如例子所示，在自行实现的方法里（由RelocatedMethod标记），仍然可以通过影子方法（代表原始方法的占位符，由ShadowMethod标记）来实现对原始目标方法的调用
+
+3.调用框架代码来初始化实现方法调用的转发
 ```
-第一次调用Get输出的值是"A",第二次是"BA"
+ClrMethodHook.Install();
 
+```
+4.当执行到目标方法时，该调用将被转发到你自己的实现；
 
+### 关于测试项目内存访问异常
+vs的测试功能会启动一个执行引擎，其默认选项是复用执行引擎。
+修改汇编指令会对其造成影响，这个影响不能从汇编字节对比（IsDetourInstalled方法）获取到。
+因此从菜单关闭该选项Test->Test Settings ->Keep Test Execution Engine Running ，
+经我测试，目前没有发现问题了。
diff --git a/Test/MonitorTest.cs b/Test/MonitorTest.cs
index f598ec3..b0d91cd 100644
--- a/Test/MonitorTest.cs
+++ b/Test/MonitorTest.cs
@@ -6,41 +6,41 @@
 namespace Test
 {
     [TestClass]
-    public class MonitorTest
+    public class ThunkMethodTest
     {
         [TestMethod]
         public void StaticMethod()
         {
-            Monitor.Install();
-            Assert.AreEqual("BA", A.StaticMethod());
+            ClrMethodHook.Install();
+            Assert.AreEqual("Not Intel Core I7", Computer.GetCpu());
         }
 
         [TestMethod]
         public void InstanceMethod()
         {
-            Monitor.Install();
-            Assert.AreEqual("BA", new A().InstanceMethod());
+            ClrMethodHook.Install(AppDomain.CurrentDomain.BaseDirectory);
+            Assert.AreEqual("Not 512M", new Computer().GetRAMSize());
         }
 
         [TestMethod]
         public void PropertyMethod()
         {
-            Monitor.Install();
-            Assert.AreEqual("BA", new A().Property);
+            ClrMethodHook.Install(AppDomain.CurrentDomain.BaseDirectory);
+            Assert.AreEqual("Not Windows 10", new Computer().Os);
         }
 
         [TestMethod]
         public void SystemMethod()
         {
-            Monitor.Install();
-            Assert.AreEqual("BA", File.ReadAllText("../../test"));
+            ClrMethodHook.Install();
+            Assert.AreEqual("My_name_is_NetFrameworkDetour", File.ReadAllText("test"));
         }
 
         [TestMethod]
         public void GenericMethod()
         {
-            Monitor.Install();
-            Assert.AreEqual("BA", new A1<string>().GenericMethod("A"));
+            ClrMethodHook.Install(AppDomain.CurrentDomain.BaseDirectory);
+            Assert.AreEqual("Not Jack", new ComputerOf<string>().ComputerIo("Jack"));
         }
     }
 }
diff --git a/Test/Samples.cs b/Test/Samples.cs
index cd09fee..12589be 100644
--- a/Test/Samples.cs
+++ b/Test/Samples.cs
@@ -1,5 +1,7 @@
-using System;
+using DotNetDetour;
+using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -7,36 +9,127 @@
 
 namespace Test
 {
-    public class A
+    public class Computer
     {
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        public static string StaticMethod()
+
+        public static string GetCpu()
         {
-            return "A";
+            return "Intel Core I7";
         }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        public string InstanceMethod()
+        public string GetRAMSize()
+        {
+            return "512M";
+        }
+
+        internal string Os
+        {
+            get
+            {
+                return "Windows 10";
+            }
+        }
+    }
+
+
+    public class ComputerOf<T>
+    {
+        public T ComputerIo(T owner)
+        {
+            return owner;
+        }
+    }
+
+    public class ComputerDetour : IMethodHook
+    {
+        #region 静态方法HOOK
+        [RelocatedMethodAttribute(typeof(Computer), "GetCpu")]
+        public static string _impl_GetCpu()
+        {
+            return "Not " + GetCpu();
+        }
+
+        [ShadowMethod(typeof(Computer), "GetCpu")]
+        public static string GetCpu()
+        {
+            return null;
+        }
+        #endregion
+
+        #region 实例方法
+        [RelocatedMethodAttribute(typeof(Computer), "GetRAMSize")]
+        public string _impl_GetRAMSize()
         {
-            return "A";
+            return "Not " + GetRAMSize();
         }
 
-        public string Property
+        [ShadowMethod(typeof(Computer), "GetRAMSize")]
+        public string GetRAMSize()
         {
-            [MethodImpl(MethodImplOptions.NoInlining)]
+            return null;
+        }
+        #endregion
+
+
+        #region 实例属性
+        public string _impl_Os
+        {
+            [RelocatedMethodAttribute(typeof(Computer), "get_Os")]
             get
             {
-                return "A";
+                return "Not " + Os;
             }
         }
+
+        public string Os
+        {
+
+            [ShadowMethod(typeof(Computer), "get_Os")]
+            get
+            {
+                return null;
+            }
+        }
+        #endregion
+
+        #region 泛型方法
+        [RelocatedMethodAttribute(typeof(ComputerOf<string>), "ComputerIo")]
+        public string _impl_ComputerIo(string name)
+        {
+            var human = ComputerIo(name);
+            human = "Not " + human;
+            return human;
+        }
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        [ShadowMethod(typeof(ComputerOf<string>), "ComputerIo")]
+        public string ComputerIo(string owner)
+        {
+            return null;
+        }
+        #endregion
     }
 
-    public class A1<T>
+    public class NetFrameworkDetour : IMethodHook
     {
+        [RelocatedMethod(typeof(System.IO.File), "ReadAllText")]
+        public static string _impl_ReadAllText(string file)
+        {
+            try
+            {
+                return ReadAllText(file) + "NetFrameworkDetour";
+            }
+            catch (Exception ex)
+            {
+                Debugger.Break();
+                throw;
+            }
+        }
+
+        [ShadowMethod(typeof(System.IO.File), "ReadAllText")]
         [MethodImpl(MethodImplOptions.NoInlining)]
-        public T GenericMethod(T t)
+        public static string ReadAllText(string file)
         {
-            return t;
+            return null;
         }
     }
 }
diff --git a/Test/Test.csproj b/Test/Test.csproj
index b23c3ac..c2f1026 100644
--- a/Test/Test.csproj
+++ b/Test/Test.csproj
@@ -8,7 +8,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Test</RootNamespace>
     <AssemblyName>Test</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
@@ -53,6 +53,12 @@
     <ErrorReport>prompt</ErrorReport>
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
+  <PropertyGroup>
+    <AutoGenerateBindingRedirects>false</AutoGenerateBindingRedirects>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
   </ItemGroup>
@@ -69,14 +75,9 @@
     </Otherwise>
   </Choose>
   <ItemGroup>
-    <Compile Include="Monitors\GenericMethodMonitor.cs" />
-    <Compile Include="Monitors\SystemMethodMonitor.cs" />
-    <Compile Include="Monitors\InstanceMethodMonitor.cs" />
-    <Compile Include="Monitors\PropertyMonitor.cs" />
     <Compile Include="MonitorTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Samples.cs" />
-    <Compile Include="Monitors\StaticMethodMonitor.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\DotNetDetour\DotNetDetour.csproj">
@@ -84,6 +85,11 @@
       <Name>DotNetDetour</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="test">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
   <Choose>
     <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
       <ItemGroup>
diff --git a/Test/test b/Test/test
index 8c7e5a6..c74eddb 100644
--- a/Test/test
+++ b/Test/test
@@ -1 +1 @@
-A
\ No newline at end of file
+My_name_is_
\ No newline at end of file
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
new file mode 100644
index 0000000..b78f4c6
--- /dev/null
+++ b/azure-pipelines.yml
@@ -0,0 +1,48 @@
+# .NET Desktop
+# Build and run tests for .NET Desktop or Windows classic desktop solutions.
+# Add steps that publish symbols, save build artifacts, and more:
+# https://docs.microsoft.com/azure/devops/pipelines/apps/windows/dot-net
+
+trigger:
+- master
+
+pool:
+  vmImage: 'VS2017-Win2016'
+
+variables:
+  solution: '**/*.sln'
+  buildPlatform: 'Any CPU'
+  buildConfiguration: 'Release'
+  Major: '1'
+  Minor: '0'
+  Patch: '1'
+
+steps:
+- task: NuGetToolInstaller@0
+
+- task: NuGetCommand@2
+  inputs:
+    restoreSolution: '$(solution)'
+
+- task: VSBuild@1
+  inputs:
+    solution: '$(solution)'
+    platform: '$(buildPlatform)'
+    configuration: '$(buildConfiguration)'
+
+- task: NuGetCommand@2
+  inputs:
+    command: pack
+    packagesToPack: '**/DotNetDetour.csproj'
+    versioningScheme: byPrereleaseNumber
+    majorVersion: '$(Major)'
+    minorVersion: '$(Minor)'
+    patchVersion: '$(Patch)'   
+
+- task: NuGetCommand@2
+  inputs:
+    command: push
+    nuGetFeedType: external
+    publishFeedCredentials: 'nuget'
+    versioningScheme: byEnvVar
+    versionEnvVar: Version