C#实现动态调用Windows DLL

调用方法： 

object obj = WinDllInvoke("Kernel32.dll", "Beep",

             new object[] { ,  }, typeof(void));

函数代码：

[System.Runtime.InteropServices.DllImport("kernel32")]

private static extern IntPtr LoadLibrary(string lpLibFileName);

[System.Runtime.InteropServices.DllImport("kernel32")]

private static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);

[System.Runtime.InteropServices.DllImport("kernel32")]

private static extern IntPtr FreeLibrary(IntPtr hLibModule);

/// <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 = ; 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 = ; 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 == )

        {

            IL.Emit(OpCodes.Ldc_I4, procAddres.ToInt32());

        }

        else if (IntPtr.Size == )

        {

            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); //释放资源

    }

}