C#实现动态调用Windows DLL

部分代码来自于网络；废话不多说，上代码：

调用方法：

object obj = WinDllInvoke("Kernel32.dll", "Beep", new object[] { 750, 300 }, typeof(void));

函数代码：

 1 [System.Runtime.InteropServices.DllImport("kernel32")]
 2         private static extern IntPtr LoadLibrary(string lpLibFileName);
 3 
 4         [System.Runtime.InteropServices.DllImport("kernel32")]
 5         private static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
 6 
 7         [System.Runtime.InteropServices.DllImport("kernel32")]
 8         private static extern IntPtr FreeLibrary(IntPtr hLibModule);
 9 
         /// <summary>
         /// 动态调用Windows DLL
         /// </summary>
         /// <param name="fileName">Dll文件名</param>
         /// <param name="funName">待调用的函数名</param>
         /// <param name="objParams">函数参数</param>
         /// <param name="returnType">返回值</param>
         /// <returns>调用结果</returns>
         private static object WinDllInvoke(string fileName, string funName, object[] objParams, Type returnType)
         {
             IntPtr libHandle = IntPtr.Zero;
 
             try
             {
                 //获取函数地址
                 libHandle = LoadLibrary(fileName);
                 if (libHandle == IntPtr.Zero) return null;
                 IntPtr procAddres = GetProcAddress(libHandle, funName);
                 if (procAddres == IntPtr.Zero) return null;
                 
                 //获取参数类型
                 Type[] paramTypes = new Type[objParams.Length];
                 for (int i = 0; i < objParams.Length; ++i)
                 {
                     paramTypes[i] = objParams[i].GetType();
                 }
 
                 //构建调用方法模型
                 AssemblyName asembyName = new AssemblyName();
                 asembyName.Name = "WinDllInvoke_Assembly";
                 AssemblyBuilder asembyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asembyName, AssemblyBuilderAccess.Run);
                 ModuleBuilder moduleBuilder = asembyBuilder.DefineDynamicModule("WinDllInvoke");
                 MethodBuilder methodBuilder = moduleBuilder.DefineGlobalMethod("InvokeFun", MethodAttributes.Public | MethodAttributes.Static, returnType, paramTypes);
 
                 //获取一个 ILGenerator ，用于发送所需的 IL 
                 ILGenerator IL = methodBuilder.GetILGenerator();
                 for (int j = 0; j < paramTypes.Length; ++j)
                 {
                     //将参数压入堆栈
                     if (paramTypes[j].IsValueType)
                     {
                         IL.Emit(OpCodes.Ldarg, j); //By Value
                     }
                     else
                     {
                         IL.Emit(OpCodes.Ldarga, j); //By Addrsss
                     }
                 }
 
                 // 判断处理器类型
                 if (IntPtr.Size == 4)
                 {
                     IL.Emit(OpCodes.Ldc_I4, procAddres.ToInt32());
                 }
                 else if (IntPtr.Size == 8)
                 {
                     IL.Emit(OpCodes.Ldc_I8, procAddres.ToInt64());
                 }
                 else
                 {
                     throw new PlatformNotSupportedException("不好意思，偶不认得你哦！");
                 }
 
                 IL.EmitCalli(OpCodes.Calli, CallingConvention.StdCall, returnType, paramTypes);
                 IL.Emit(OpCodes.Ret); // 返回值 
                 moduleBuilder.CreateGlobalFunctions();
 
                 // 取得方法信息 
                 MethodInfo methodInfo = moduleBuilder.GetMethod("InvokeFun");
 
                 return methodInfo.Invoke(null, objParams);// 调用方法，并返回其值
             }
             catch { return null; }
             finally
             {
                 if (libHandle != IntPtr.Zero) FreeLibrary(libHandle); //释放资源
             }
         }