解决方案 »
- “GridView1”激发了未处理的事件“PageIndexChanging”
- 如何实现对数曲线的拟合
- C# 在notifyIcon如何实现左击菜单
- 请教一个socket异常
- 哪个类有类似于VC中的CFilefind的功能?我要浏览一个文件夹中的所有的文件。
- 请问谁有从mysql里把一个数据库的所有表里面的繁体转成简体的程序
- 关于换行的问题?
- uploadfile上传文件大小比原文件大?
- Excel 的连接问题。
- 自己写的一个网站如何发布????
- picturebox 图片按坐标加载显示
- C#中FolderBrowserDialog fbd = new FolderBrowserDialog();下如何解决新建文件夹重命名并保存文件的问题!急!
[/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的方法,则内存不会变大,但是,满足不了我的需求。
请大神不吝赐教!
谢谢您的回复。但是,具体应该怎么释放呢?其实,我也并没有频繁的加载,我是只加载一次,然后,多次调用里面的函数,这样是否也会产生需要释放的东西?然后,如果要释放,应该怎么释放??程序中,我是这样子调用函数的 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
你可以用C语言写一个专门负责调用不同DLL方法的DLL
假设就叫你的MyFun.DLL吧,里面有一个 MyFunInvoke(参数。)函数
这个函数要负责解析上层传传入的参数,正确的对参数进行压栈,出栈,并调用正确的函数等。然后你可以在c#声明MyFun.DLL中的MyFunInvoke(参数。)函数。
所有的程序都使用C#中的方法,而不是即时的生成的相关的调用DLL。这样做好处是:
你不会不断的动态生成DLL,造成内存不断增长。当然整个过程的难处在于
MyFun.dll中的函数与C#中的函数参数如何进行设计,这里你可能需要实现PInvoke中一个自定义的数据封送处理器。来确保参数如何正确传递与返回。当然,如果有更简单的方法,请记得@我。
malloc free
new delete
CoTaskMemAlloc CoTaskMemFree
内存分配、释放必须成对使用,否则也会造成内存泄露!net互操作默认是方式是CoTaskMemAlloc,其垃圾回收自动调用的是CoTaskMemFree,也就是说,如果非托管代码采用COM方式分配内存,可以不用显示释放内存,net帮你搞定!而其他两种,net不支持的方式,必须还是由非托管方来释放!也就是:你要做C++和C#两边都封装一个相应的释放函数!
不知lz找到解决办法没有?
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;
}
}