关于c#动态调用非托管DLL的内存释放问题

2013-12-20 05:04:17 1.6k 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

C#调用非托管C++DLL：直接调用法在实际软件开发过程中，由于公司使用了多种语言开发，在C#中可能需要实现某个功能，而该功能可能用其他语言已经实现了，那么我们可以调用其他语言写好的模块吗？还有就是，由于C#开发好的项目，我们可以利用reflector等反编译工具反编译出其源代码，所以对于一些核心算法，我们不希望被别人知道，因此为了增强代码的安全性，我们需要将一些核心算法用C或C++来编写，然后用C#来调用这些已经写好的接口。在面对以... 阅读详情

本人由于客户的需要，需要在程序的运行过程中，动态加载不同的DLL。这与直接调用非托管DLL不一样。
下面这个帖子中的第三个方法很好的说明了如何动态调用非托管DLL。
http://blog.csdn.net/pansiom/article/details/568096#comments
为了方便使用，我把文中的方法弄成了一个DLDApi类，如下



using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection; // 使用 Assembly 类需用此 命名空间

using System.Reflection.Emit; // 使用 ILGenerator 需用此 命名空间

using System.Runtime.InteropServices; // 用 DllImport 需用此 命名空间

using System.Text;



namespace CTP_ShiningMidas

{

    public class DLDApi

    {



        /// <summary>

        /// 参数传递方式枚举 ,ByValue 表示值传递 ,ByRef 表示址传递

        /// </summary>

        public enum ModePass

        {

            ByValue = 0x0001,

            ByRef = 0x0002

        }



        /// <summary>

        /// 原型是 :HMODULE LoadLibrary(LPCTSTR lpFileName);

        /// </summary>

        /// <param name="lpFileName">DLL 文件名 </param>

        /// <returns> 函数库模块的句柄 </returns>

        [DllImport("kernel32.dll")]

        static extern IntPtr LoadLibrary(string lpFileName);



        /// <summary>

        /// 原型是 : FARPROC GetProcAddress(HMODULE hModule, LPCWSTR lpProcName);

        /// </summary>

        /// <param name="hModule"> 包含需调用函数的函数库模块的句柄 </param>

        /// <param name="lpProcName"> 调用函数的名称 </param>

        /// <returns> 函数指针 </returns>

        [DllImport("kernel32.dll")]

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



        /// <summary>

        /// 原型是 : BOOL FreeLibrary(HMODULE hModule);

        /// </summary>

        /// <param name="hModule"> 需释放的函数库模块的句柄 </param>

        /// <returns> 是否已释放指定的 Dll</returns>

        [DllImport("kernel32", EntryPoint = "FreeLibrary", SetLastError = true)]

        static extern bool FreeLibrary(IntPtr hModule);



        /// <summary>

        /// Loadlibrary 返回的函数库模块的句柄

        /// </summary>

        private IntPtr hModule = IntPtr.Zero;



        /// <summary>

        /// GetProcAddress 返回的函数指针

        /// </summary>

        private IntPtr farProc = IntPtr.Zero;



        /// <summary>

        /// 装载 Dll

        /// </summary>

        /// <param name="lpFileName">DLL 文件名 </param>

        public void LoadDll(string lpFileName)

        {

            hModule = LoadLibrary(lpFileName);

            if (hModule == IntPtr.Zero)

            {

                throw (new Exception(" 没有找到 :" + lpFileName + "."));

            }

        }



        public void LoadDll(IntPtr HMODULE)

        {

            if (HMODULE == IntPtr.Zero)

            { 

                throw (new Exception(" 所传入的函数库模块的句柄 HMODULE 为空 .")); 

            }

            hModule = HMODULE;

        }





        /// <summary>

        /// 获得函数指针

        /// </summary>

        /// <param name="lpProcName"> 调用函数的名称 </param>

        public void LoadFun(string lpProcName)

        { // 若函数库模块的句柄为空，则抛出异常

            if (hModule == IntPtr.Zero)

            {

                throw (new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !"));

            }

           



            // 取得函数指针

            farProc = GetProcAddress(hModule, lpProcName);



            // 若函数指针为空，则抛出异常

            if (farProc == IntPtr.Zero)

            {

                throw (new Exception(" 没有找到 :" + lpProcName + " 这个函数的入口点 "));

            }

        }



        /// <summary>

        /// 获得函数指针

        /// </summary>

        /// <param name="lpFileName"> 包含需调用函数的 DLL 文件名 </param>

        /// <param name="lpProcName"> 调用函数的名称 </param>

        public void LoadFun(string lpFileName, string lpProcName)

        { 

            // 取得函数库模块的句柄

            hModule = LoadLibrary(lpFileName);



            // 若函数库模块的句柄为空，则抛出异常

            if (hModule == IntPtr.Zero)

            {

                throw (new Exception(" 没有找到 :" + lpFileName + "."));

            }



            // 取得函数指针

            farProc = GetProcAddress(hModule, lpProcName);



            // 若函数指针，则抛出异常

            if (farProc == IntPtr.Zero)

            {

                throw (new Exception(" 没有找到 :" + lpProcName + " 这个函数的入口点 "));

            }

        }





        /// <summary>

        /// 卸载 Dll

        /// </summary>

        public void UnLoadDll()

        {

            FreeLibrary(hModule);

            hModule = IntPtr.Zero;

            farProc = IntPtr.Zero;

        }



        /// <summary>

        /// 调用所设定的函数

        /// </summary>

        /// <param name="ObjArray_Parameter"> 实参 </param>

        /// <param name="TypeArray_ParameterType"> 实参类型 </param>

        /// <param name="ModePassArray_Parameter"> 实参传送方式 </param>

        /// <param name="Type_Return"> 返回类型 </param>

        /// <returns> 返回所调用函数的 object</returns>

        public object Invoke(object[] ObjArray_Parameter, Type[] TypeArray_ParameterType, ModePass[] ModePassArray_Parameter, Type Type_Return)

        {

            // 下面 3 个 if 是进行安全检查 , 若不能通过 , 则抛出异常

            if (hModule == IntPtr.Zero)

            {

                throw (new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !"));

            }



            if (farProc == IntPtr.Zero)

            {

                throw (new Exception(" 函数指针为空 , 请确保已进行 LoadFun 操作 !"));

            }



            if (ObjArray_Parameter.Length != ModePassArray_Parameter.Length)

            {

                throw (new Exception(" 参数个数及其传递方式的个数不匹配 ."));

            }



            // 下面是创建 MyAssemblyName 对象并设置其 Name 属性

            AssemblyName MyAssemblyName = new AssemblyName();

            MyAssemblyName.Name = "InvokeFun";



            // 生成单模块配件

            AssemblyBuilder MyAssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(MyAssemblyName, AssemblyBuilderAccess.Run);

            ModuleBuilder MyModuleBuilder = MyAssemblyBuilder.DefineDynamicModule("InvokeDll");



            // 定义要调用的方法 , 方法名为“ MyFun ”，返回类型是“ Type_Return ”参数类型是“ TypeArray_ParameterType ”

            MethodBuilder MyMethodBuilder = MyModuleBuilder.DefineGlobalMethod("MyFun", MethodAttributes.Public | MethodAttributes.Static, Type_Return, TypeArray_ParameterType);



            // 获取一个 ILGenerator ，用于发送所需的 IL

            ILGenerator IL = MyMethodBuilder.GetILGenerator();

            



            for (int i = 0; i < ObjArray_Parameter.Length; i++)

            {

                // 用循环将参数依次压入堆栈

                switch (ModePassArray_Parameter[i])

                {

                    case ModePass.ByValue:

                        IL.Emit(OpCodes.Ldarg, i);

                        break;



                    case ModePass.ByRef:

                        IL.Emit(OpCodes.Ldarga, i);

                        break;



                    default:

                        throw (new Exception(" 第 " + (i + 1).ToString() + " 个参数没有给定正确的传递方式 ."));

                }

            }



            if (IntPtr.Size == 4)

            {

                // 判断处理器类型

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

            }

            else if (IntPtr.Size == 8)

            {

                IL.Emit(OpCodes.Ldc_I8, farProc.ToInt64());

            }

            else

            {

                throw new PlatformNotSupportedException();

            }



            IL.EmitCalli(OpCodes.Calli, CallingConvention.Cdecl, Type_Return, TypeArray_ParameterType);

            IL.Emit(OpCodes.Ret); // 返回值

            MyModuleBuilder.CreateGlobalFunctions();



            // 取得方法信息

            MethodInfo MyMethodInfo = MyModuleBuilder.GetMethod("MyFun");





//             Marshal.FreeHGlobal(MyAssemblyName);

//             Marshal.FreeHGlobal(MyAssemblyBuilder);

//             Marshal.FreeHGlobal(MyModuleBuilder);

//             Marshal.FreeHGlobal(MyMethodBuilder);

//             Marshal.FreeHGlobal(IL);

//             Marshal.FreeHGlobal(MyModuleBuilder);

//             Marshal.FreeHGlobal(MyMethodBuilder);





            return MyMethodInfo.Invoke(null, ObjArray_Parameter);// 调用方法，并返回其值

        }



        /// <summary>

        /// 调用所设定的函数

        /// </summary>

        /// <param name="IntPtr_Function"> 函数指针 </param>

        /// <param name="ObjArray_Parameter"> 实参 </param>

        /// <param name="TypeArray_ParameterType"> 实参类型 </param>

        /// <param name="ModePassArray_Parameter"> 实参传送方式 </param>

        /// <param name="Type_Return"> 返回类型 </param>

        /// <returns> 返回所调用函数的 object</returns>

        public object Invoke(IntPtr IntPtr_Function, object[] ObjArray_Parameter, Type[] TypeArray_ParameterType, ModePass[] ModePassArray_Parameter, Type Type_Return)

        {

            // 下面 2 个 if 是进行安全检查 , 若不能通过 , 则抛出异常

            if (hModule == IntPtr.Zero)

            {

                throw (new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !"));

            }



            if (IntPtr_Function == IntPtr.Zero)

            {

                throw (new Exception(" 函数指针 IntPtr_Function 为空 !"));

            }



            farProc = IntPtr_Function;



            return Invoke(ObjArray_Parameter, TypeArray_ParameterType, ModePassArray_Parameter, Type_Return);

        }



        /// <summary>

        /// 只要求函数名的DLL动态调用

        /// </summary>

        /// <param name="funcName"></param>

        /// <param name="ObjArray_Parameter"></param>

        /// <param name="TypeArray_ParameterType"></param>

        /// <param name="ModePassArray_Parameter"></param>

        /// <param name="Type_Return"></param>

        /// <returns></returns>

        public object Invoke(string funcName, object[] ObjArray_Parameter, Type[] TypeArray_ParameterType, ModePass[] ModePassArray_Parameter, Type Type_Return)

        {

            LoadFun(funcName);

            object ob = Invoke(ObjArray_Parameter, TypeArray_ParameterType, ModePassArray_Parameter, Type_Return);

            return ob;

        }

    }

}

...全文

UG/NX 二次开发(C#) C#调用C++ 非托管dll的实现说白了，就是完全由.NET托管代码实现的DLL，完全依赖于 .NET 平台的 CLR 运行。托管DLL，受.NET CLR管控，支持内存自动回收等的，对于.NET平台是安全DLL。，是指完全或者部分不是用.NET代码实现，不依赖于.NET平台即可运行，例如 COM方式的DLL，不支持自动回收内存，对于.NET平台而言，也是非安全可控的。1、首先解决C++非托管动态链接库的问题，需要VS版本2017以上，因为低版本VS创建的DLL都是32位，调用的时候会报错。第二步：导入Dll方法。阅读详情

yuguangchan

C# 111,128 成员 642,536 内容

+ 关注 + 加入社区

切换为时间正序

Saleayas 2015-10-26

打赏
举报

Marshal::GetDelegateForFunctionPointer 使用这个方法可以直接呼叫本地导出的方法。

huahuaLearn 2015-10-26

打赏
举报

请问楼主最后解决了没？我也是遇到了相同的问题，虽然不是这样的调用方法，但是也是调用的dll，发现内存就会上涨。

caoqinghua 2015-06-03

打赏
举报

可以使用缓存解决.

jsxyhelu 2014-09-11

打赏
举报

帮顶，我也遇到这个问题。

gwx69 2014-06-02

打赏
举报

确实类里面的invoke函数有需要释放的东西，下面是全部代码。 public class GxInterface { private ILGenerator m_IL; private Type m_TypeReturn; private Type[] m_TypeArray_ParameterType; private MethodInfo m_MehtodInfo; /// <summary> /// 参数传递方式枚举 ,ByValue 表示值传递 ,ByRef 表示址传递 /// </summary> public enum ModePass { ByValue = 0x0001, ByRef = 0x0002 } /// <summary> /// 原型是 :HMODULE LoadLibrary(LPCTSTR lpFileName); /// </summary> /// <param name="lpFileName">DLL 文件名 </param> /// <returns> 函数库模块的句柄 </returns> [DllImport("kernel32.dll")] static extern IntPtr LoadLibrary(string lpFileName); /// <summary> /// 原型是 : FARPROC GetProcAddress(HMODULE hModule, LPCWSTR lpProcName); /// </summary> /// <param name="hModule"> 包含需调用函数的函数库模块的句柄 </param> /// <param name="lpProcName"> 调用函数的名称 </param> /// <returns> 函数指针 </returns> [DllImport("kernel32.dll")] static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName); /// <summary> /// 原型是 : BOOL FreeLibrary(HMODULE hModule); /// </summary> /// <param name="hModule"> 需释放的函数库模块的句柄 </param> /// <returns> 是否已释放指定的 Dll</returns> [DllImport("kernel32", EntryPoint = "FreeLibrary", SetLastError = true)] static extern bool FreeLibrary(IntPtr hModule); /// <summary> /// Loadlibrary 返回的函数库模块的句柄 /// </summary> private IntPtr hModule = IntPtr.Zero; /// <summary> /// GetProcAddress 返回的函数指针 /// </summary> public IntPtr farProc = IntPtr.Zero; /// <summary> /// 装载 Dll /// </summary> /// <param name="lpFileName">DLL 文件名 </param> public void LoadDll(string lpFileName) { hModule = LoadLibrary(lpFileName); if (hModule == IntPtr.Zero) { throw (new Exception(" 没有找到 :" + lpFileName + ".")); } } public void LoadDll(IntPtr HMODULE) { if (HMODULE == IntPtr.Zero) { throw (new Exception(" 所传入的函数库模块的句柄 HMODULE 为空 .")); } hModule = HMODULE; } /// <summary> /// 获得函数指针 /// </summary> /// <param name="lpProcName"> 调用函数的名称 </param> public void LoadFun(string lpProcName) { // 若函数库模块的句柄为空，则抛出异常 if (hModule == IntPtr.Zero) { throw (new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !")); } // 取得函数指针 farProc = GetProcAddress(hModule, lpProcName); // 若函数指针为空，则抛出异常 if (farProc == IntPtr.Zero) { throw (new Exception(" 没有找到 :" + lpProcName + " 这个函数的入口点 ")); } } /// <summary> /// 获得函数指针 /// </summary> /// <param name="lpFileName"> 包含需调用函数的 DLL 文件名 </param> /// <param name="lpProcName"> 调用函数的名称 </param> public void LoadFun(string lpFileName, string lpProcName) { // 取得函数库模块的句柄 hModule = LoadLibrary(lpFileName); // 若函数库模块的句柄为空，则抛出异常 if (hModule == IntPtr.Zero) { throw (new Exception(" 没有找到 :" + lpFileName + ".")); } // 取得函数指针 farProc = GetProcAddress(hModule, lpProcName); // 若函数指针，则抛出异常 if (farProc == IntPtr.Zero) { throw (new Exception(" 没有找到 :" + lpProcName + " 这个函数的入口点 ")); } } /// <summary> /// 卸载 Dll /// </summary> public void UnLoadDll() { FreeLibrary(hModule); hModule = IntPtr.Zero; farProc = IntPtr.Zero; } public void UnloadFun() { FreeLibrary(farProc); farProc = IntPtr.Zero; } /// <summary> /// 调用所设定的函数 /// </summary> /// <param name="ObjArray_Parameter"> 实参 </param> /// <param name="TypeArray_ParameterType"> 实参类型 </param> /// <param name="ModePassArray_Parameter"> 实参传送方式 </param> /// <param name="Type_Return"> 返回类型 </param> /// <returns> 返回所调用函数的 object</returns> public object Invoke(object[] ObjArray_Parameter, Type[] TypeArray_ParameterType, ModePass[] ModePassArray_Parameter, Type Type_Return) { // 下面 3 个 if 是进行安全检查 , 若不能通过 , 则抛出异常 if (hModule == IntPtr.Zero) { throw (new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !")); } if (farProc == IntPtr.Zero) { throw (new Exception(" 函数指针为空 , 请确保已进行 LoadFun 操作 !")); } if (ObjArray_Parameter.Length != ModePassArray_Parameter.Length) { throw (new Exception(" 参数个数及其传递方式的个数不匹配 .")); } if (m_IL == null || Type_Return.FullName != m_TypeReturn.FullName || !Equals(TypeArray_ParameterType, m_TypeArray_ParameterType)) { // 下面是创建 MyAssemblyName 对象并设置其 Name 属性 AssemblyName MyAssemblyName = new AssemblyName(); MyAssemblyName.Name = "InvokeFun"; // 生成单模块配件 AssemblyBuilder MyAssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(MyAssemblyName, AssemblyBuilderAccess.Run); ModuleBuilder MyModuleBuilder = MyAssemblyBuilder.DefineDynamicModule("InvokeDll"); // 定义要调用的方法 , 方法名为“ MyFun ”，返回类型是“ Type_Return ”参数类型是“ TypeArray_ParameterType ” MethodBuilder MyMethodBuilder = MyModuleBuilder.DefineGlobalMethod("MyFun", MethodAttributes.Public | MethodAttributes.Static, Type_Return, TypeArray_ParameterType); // 获取一个 ILGenerator ，用于发送所需的 IL m_IL = MyMethodBuilder.GetILGenerator(); m_TypeReturn = Type_Return; m_TypeArray_ParameterType = TypeArray_ParameterType; for (int i = 0; i < ObjArray_Parameter.Length; i++) { // 用循环将参数依次压入堆栈 switch (ModePassArray_Parameter[i]) { case ModePass.ByValue: m_IL.Emit(OpCodes.Ldarg, i); break; case ModePass.ByRef: m_IL.Emit(OpCodes.Ldarga, i); break; default: throw (new Exception(" 第 " + (i + 1).ToString() + " 个参数没有给定正确的传递方式 .")); } } if (IntPtr.Size == 4) { // 判断处理器类型 m_IL.Emit(OpCodes.Ldc_I4, farProc.ToInt32()); } else if (IntPtr.Size == 8) { m_IL.Emit(OpCodes.Ldc_I8, farProc.ToInt64()); } else { throw new PlatformNotSupportedException(); } m_IL.EmitCalli(OpCodes.Calli, CallingConvention.Cdecl, Type_Return, TypeArray_ParameterType); m_IL.Emit(OpCodes.Ret); // 返回值 MyModuleBuilder.CreateGlobalFunctions(); m_MehtodInfo = MyModuleBuilder.GetMethod("MyFun"); } // Marshal.FreeHGlobal(MyAssemblyName); // Marshal.FreeHGlobal(MyAssemblyBuilder); // Marshal.FreeHGlobal(MyModuleBuilder); // Marshal.FreeHGlobal(MyMethodBuilder); // Marshal.FreeHGlobal(IL); // Marshal.FreeHGlobal(MyModuleBuilder); // Marshal.FreeHGlobal(MyMethodBuilder); // 取得方法信息 return m_MehtodInfo.Invoke(null, ObjArray_Parameter);// 调用方法，并返回其值 } private bool Equals(Type[] typeList1, Type[] typeList2) { if (typeList1.Length != typeList2.Length) { return false; } for (var index = 0; index < typeList1.Length; index++) { if (typeList1[index].FullName != typeList2[index].FullName) { return false; } } return true; } }

Jiminull 2014-02-28

打赏
举报

我跟lz遇到了一摸一样的问题。不知lz找到解决办法没有？

晚安苏州 2013-12-27

打赏
举报

非托管代码三种内存分配、释放方式: malloc free new delete CoTaskMemAlloc CoTaskMemFree 内存分配、释放必须成对使用，否则也会造成内存泄露！net互操作默认是方式是CoTaskMemAlloc，其垃圾回收自动调用的是CoTaskMemFree，也就是说，如果非托管代码采用COM方式分配内存，可以不用显示释放内存，net帮你搞定！而其他两种，net不支持的方式，必须还是由非托管方来释放！也就是：你要做C＋＋和C＃两边都封装一个相应的释放函数！

yuguangchan 2013-12-27

打赏
举报

顶一个！！！！！

yuguangchan 2013-12-25

打赏
举报

谢谢你的回复，不过，我在使用上面的DLL的时候，并没有不断的生成DLL对象。我在使用的时候，仅NEW了一个DLL对象，也就是只会调用一次LoadLibrary(lpFileName)。我的内存的增加并不是因为我生成了新的对象，而是因为我不断通过这个对象调用函数。

largeskymengsk 2013-12-22

打赏
举报

大概看了一下，提出我的想法，你可以用C语言写一个专门负责调用不同DLL方法的DLL 假设就叫你的MyFun.DLL吧，里面有一个 MyFunInvoke(参数。。。。)函数这个函数要负责解析上层传传入的参数，正确的对参数进行压栈，出栈，并调用正确的函数等。然后你可以在c#声明MyFun.DLL中的MyFunInvoke(参数。。。。)函数。所有的程序都使用C#中的方法，而不是即时的生成的相关的调用DLL。这样做好处是：你不会不断的动态生成DLL，造成内存不断增长。当然整个过程的难处在于 MyFun.dll中的函数与C#中的函数参数如何进行设计，这里你可能需要实现PInvoke中一个自定义的数据封送处理器。来确保参数如何正确传递与返回。当然，如果有更简单的方法，请记得@我。

yuguangchan 2013-12-21

打赏
举报

引用 2 楼 wddw1986 的回复:

你在不停的编译新代码，当然越用内存越大。又回到老话题了，托管程序集没有卸载概念，自然无法释放。应用程序域有卸载的概念，所以想大量频繁动态编译就要放到一个应用程序域里面，用完之后卸载。

谢谢您的回复。但是，具体应该怎么释放呢？其实，我也并没有频繁的加载，我是只加载一次，然后，多次调用里面的函数，这样是否也会产生需要释放的东西？然后，如果要释放，应该怎么释放？？程序中，我是这样子调用函数的


        private void Dll_FreshDataSet(S_Info dataSet)   //Dll刷入数据
        {
            object[] Parameters = new object[] { dataSet };
            Type[] ParameterTypes = new Type[] { typeof(S_Info) };
            DLDApi.ModePass[] themode = new DLDApi.ModePass[] { DLDApi.ModePass.ByValue };
            Type Type_Return = typeof(void);
 
            dynamicDll.Invoke("FreshDataSet", Parameters, ParameterTypes, themode, Type_Return);
        }

上面的中间变量不是在出去这个域的时候就会自动被释放了吗？然后，如果是类里面的invoke函数有需要释放的东西的话，应该怎么释放呢？？


        /// <summary>
        /// 调用所设定的函数
        /// </summary>
        /// <param name="ObjArray_Parameter"> 实参 </param>
        /// <param name="TypeArray_ParameterType"> 实参类型 </param>
        /// <param name="ModePassArray_Parameter"> 实参传送方式 </param>
        /// <param name="Type_Return"> 返回类型 </param>
        /// <returns> 返回所调用函数的 object</returns>
        public object Invoke(object[] ObjArray_Parameter, Type[] TypeArray_ParameterType, ModePass[] ModePassArray_Parameter, Type Type_Return)
        {
            // 下面 3 个 if 是进行安全检查 , 若不能通过 , 则抛出异常
            if (hModule == IntPtr.Zero)
            {
                throw (new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !"));
            }
 
            if (farProc == IntPtr.Zero)
            {
                throw (new Exception(" 函数指针为空 , 请确保已进行 LoadFun 操作 !"));
            }
 
            if (ObjArray_Parameter.Length != ModePassArray_Parameter.Length)
            {
                throw (new Exception(" 参数个数及其传递方式的个数不匹配 ."));
            }
 
            // 下面是创建 MyAssemblyName 对象并设置其 Name 属性
            AssemblyName MyAssemblyName = new AssemblyName();
            MyAssemblyName.Name = "InvokeFun";
 
            // 生成单模块配件
            AssemblyBuilder MyAssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(MyAssemblyName, AssemblyBuilderAccess.Run);
            ModuleBuilder MyModuleBuilder = MyAssemblyBuilder.DefineDynamicModule("InvokeDll");
 
            // 定义要调用的方法 , 方法名为“ MyFun ”，返回类型是“ Type_Return ”参数类型是“ TypeArray_ParameterType ”
            MethodBuilder MyMethodBuilder = MyModuleBuilder.DefineGlobalMethod("MyFun", MethodAttributes.Public | MethodAttributes.Static, Type_Return, TypeArray_ParameterType);
 
            // 获取一个 ILGenerator ，用于发送所需的 IL
            ILGenerator IL = MyMethodBuilder.GetILGenerator();
             
 
            for (int i = 0; i < ObjArray_Parameter.Length; i++)
            {
                // 用循环将参数依次压入堆栈
                switch (ModePassArray_Parameter[i])
                {
                    case ModePass.ByValue:
                        IL.Emit(OpCodes.Ldarg, i);
                        break;
 
                    case ModePass.ByRef:
                        IL.Emit(OpCodes.Ldarga, i);
                        break;
 
                    default:
                        throw (new Exception(" 第 " + (i + 1).ToString() + " 个参数没有给定正确的传递方式 ."));
                }
            }
 
            if (IntPtr.Size == 4)
            {
                // 判断处理器类型
                IL.Emit(OpCodes.Ldc_I4, farProc.ToInt32());
            }
            else if (IntPtr.Size == 8)
            {
                IL.Emit(OpCodes.Ldc_I8, farProc.ToInt64());
            }
            else
            {
                throw new PlatformNotSupportedException();
            }
 
            IL.EmitCalli(OpCodes.Calli, CallingConvention.Cdecl, Type_Return, TypeArray_ParameterType);
            IL.Emit(OpCodes.Ret); // 返回值
            MyModuleBuilder.CreateGlobalFunctions();
 
            // 取得方法信息
            MethodInfo MyMethodInfo = MyModuleBuilder.GetMethod("MyFun");
 
             return MyMethodInfo.Invoke(null, ObjArray_Parameter);// 调用方法，并返回其值
        }
 
        /// <summary>
        /// 调用所设定的函数
        /// </summary>
        /// <param name="IntPtr_Function"> 函数指针 </param>
        /// <param name="ObjArray_Parameter"> 实参 </param>
        /// <param name="TypeArray_ParameterType"> 实参类型 </param>
        /// <param name="ModePassArray_Parameter"> 实参传送方式 </param>
        /// <param name="Type_Return"> 返回类型 </param>
        /// <returns> 返回所调用函数的 object</returns>
        public object Invoke(IntPtr IntPtr_Function, object[] ObjArray_Parameter, Type[] TypeArray_ParameterType, ModePass[] ModePassArray_Parameter, Type Type_Return)
        {
            // 下面 2 个 if 是进行安全检查 , 若不能通过 , 则抛出异常
            if (hModule == IntPtr.Zero)
            {
                throw (new Exception(" 函数库模块的句柄为空 , 请确保已进行 LoadDll 操作 !"));
            }
 
            if (IntPtr_Function == IntPtr.Zero)
            {
                throw (new Exception(" 函数指针 IntPtr_Function 为空 !"));
            }
 
            farProc = IntPtr_Function;
 
            return Invoke(ObjArray_Parameter, TypeArray_ParameterType, ModePassArray_Parameter, Type_Return);
        }

我尝试了对这个函数里面的变量使用using这种方式，但是，VS说这些变量并不是可以depose的变量，不能使用using。。。

cheng2005 2013-12-20

打赏
举报

你在不停的编译新代码，当然越用内存越大。又回到老话题了，托管程序集没有卸载概念，自然无法释放。应用程序域有卸载的概念，所以想大量频繁动态编译就要放到一个应用程序域里面，用完之后卸载。

yuguangchan 2013-12-20

打赏
举报

[/code] 使用上面这个类，就可以很轻松的加载Dll和使用Dll中的函数，如下：


        private DLDApi dynamicDll = new DLDApi();/// 声明动态DLL对象
        dynamicDll.LoadDll("Dll的地址");    //加载dll

        private void Dll_FreshDataSet(S_Info dataSet)   //Dll刷入数据
        {
            object[] Parameters = new object[] { dataSet };
            Type[] ParameterTypes = new Type[] { typeof(S_Info) };
            DLDApi.ModePass[] themode = new DLDApi.ModePass[] { DLDApi.ModePass.ByValue };
            Type Type_Return = typeof(void);

            dynamicDll.Invoke("FreshDataSet", Parameters, ParameterTypes, themode, Type_Return);
        }

在使用的过程中，我会用上面这个类的方式先加载Dll，然后，通过上面的"只要求函数名的DLL动态调用函数"invoke多次调用DLL中的函数。整个过程都没有问题。执行结果也是正确的。但是，我发现，程序的内存变得越来越大。每次调用完函数之后，程序的内存都会变大一点。由于，我的程序需要调用Dll函数的次数是比较多的，最后，整个程序占用的内存会变到1G多。而如果我不用这种动态调用DLL的方式而采用正常的非托管DLL调用方式的话（本文一开始提到的文章中的(一)调用DLL中的非托管函数一般方法），内存则不会变大，调用也正常。但是，没有办法满足我动态调用DLL的需求。以上就是我所遇到的问题，即如果我用上述的动态调用非托管DLL的方法调用函数，内存会不断变大；而如果我不适用上述动态调用非托管DLL的方法，而是用一般调用DLL的方法，则内存不会变大，但是，满足不了我的需求。请大神不吝赐教！

关于c#动态调用非托管DLL的内存释放问题

相关推荐