public void testdll()
{
int ret = 0;
LoadDll myDLD = new LoadDll();
myDLD.LoadDll2("xxx.dll");
myDLD.LoadFun("InitSDK");
object[] Parameters = new object[] { };
// 实参为0
Type[] ParameterTypes = new Type[] { };
// 实参类型为int
ModePass[] themode = new ModePass[] { };
// 传送方式为值传
Type Type_Return = typeof(int);
// 返回类型为int
ret = (int)myDLD.Invoke(Parameters, ParameterTypes, themode, Type_Return);
//txRet.Text = ret.ToString();
if (ret != 1)
{
//MessageBox.Show("InitSDK failed !");
}
if (ret == 1)
{
//MessageBox.Show("InitSDK Sucessed !");
}
}
public void testdll()
{
int ret = 0;
LoadDll myDLD = new LoadDll();
myDLD.LoadDll2("xxx.dll");
myDLD.LoadFun("InitSDK");
object[] Parameters = new object[] { };
// 实参为0
Type[] ParameterTypes = new Type[] { };
// 实参类型为int
ModePass[] themode = new ModePass[] { };
// 传送方式为值传
Type Type_Return = typeof(int);
// 返回类型为int
ret = (int)myDLD.Invoke(Parameters, ParameterTypes, themode, Type_Return);
//txRet.Text = ret.ToString();
if (ret != 1)
{
//MessageBox.Show("InitSDK failed !");
}
if (ret == 1)
{
//MessageBox.Show("InitSDK Sucessed !");
}
}
//not success
static void TestComplexDllReflection()
{
Console.WriteLine("Complex:Use DllLoadLibrary&Reflection,");
PrintCurrentProcessMemUsage();
UseDllByReflection reflectFun = new UseDllByReflection();
reflectFun.LoadDll("testCppDll.dll");
reflectFun.LoadFun("CreateNameEntityByTypeByReturn");
//NameEntity a = new NameEntity();
int a = 0;
unsafe
{
object[] Parameters = new object[] { a };
Type[] ParameterTypes = new Type[] { typeof(int) };
ModePass[] themode = new ModePass[] { ModePass.ByRef };
Type Type_Return = typeof(IntPtr);
string methodName1 = "CreateNameEntityByTypeByReturn";
object ret = reflectFun.Invoke(methodName1, Parameters, ParameterTypes, themode, Type_Return);
IntPtr retPtr = (IntPtr)ret;
NameEntity retStruct = (NameEntity)Marshal.PtrToStructure(retPtr, typeof(NameEntity));
//在非托管代码中使用CoTaskMemAlloc分配的内存，可以使用Marshal.FreeCoTaskMem方法释放
Marshal.FreeCoTaskMem(retPtr);
Console.WriteLine("非托管函数返回的结构体数据：double = {0:f6}, int = {1}",
retStruct._score, retStruct._highlightLength);
}
reflectFun.UnLoadDll();
reflectFun.LoadDll("testCppDll.dll");
reflectFun.LoadFun("CreateNameEntityByType");
NameEntity nameEntity = new NameEntity();
IntPtr paraPtr = Marshal.AllocHGlobal(Marshal.SizeOf(nameEntity));
Marshal.StructureToPtr(nameEntity, paraPtr, false);
uint b = 0;
unsafe
{
object[] Parameters = new object[] { paraPtr, b };
Type[] ParameterTypes = new Type[] { typeof(IntPtr), typeof(uint) };
ModePass[] themode = new ModePass[] { ModePass.ByRef, ModePass.ByValue };
Type Type_Return = typeof(bool);
string methodName2 = "CreateNameEntityByType";
object ret = reflectFun.Invoke(methodName2, Parameters, ParameterTypes, themode, Type_Return);
NameEntity retStruct = (NameEntity)Marshal.PtrToStructure(paraPtr, typeof(NameEntity));
//在非托管代码中使用CoTaskMemAlloc分配的内存，可以使用Marshal.FreeCoTaskMem方法释放
Marshal.FreeCoTaskMem(paraPtr);
Console.WriteLine("非托管函数返回的结构体数据：double = {0:f6}, int = {1}",
retStruct._score, retStruct._highlightLength);
}
reflectFun.UnLoadDll();
PrintCurrentProcessMemUsage();
Console.WriteLine("Complex: End");
}
private void btoLockingLrc_Click(object sender, EventArgs e)
{
object[] Parameters = new object[] { };
Type[] ParameterTypes = new Type[] { };
ModePass[] themode = new ModePass[] { };
Type Type_Return = typeof(void);
lrc_fun.LoadFun("LockingLRC");
lrc_fun.Invoke(Parameters, ParameterTypes, themode, Type_Return);
}
// <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();
int i;
for (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.StdCall, 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="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();
int i;
for (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.StdCall, Type_Return, TypeArray_ParameterType);
IL.Emit(OpCodes.Ret); // 返回值
MyModuleBuilder.CreateGlobalFunctions();
// 取得方法信息
MethodInfo MyMethodInfo = MyModuleBuilder.GetMethod("MyFun");
return MyMethodInfo.Invoke(null, ObjArray_Parameter);// 调用方法，并返回其值
}
protected override void OnLoad(EventArgs e)
{
lrc_fun = new dld();
lrc_fun.LoadDll("DrawLRC_DLL.dll");
lrc_fun.LoadFun("InitGDI");
object[] Parameters = new object[] { };
Type[] ParameterTypes = new Type[] { };
ModePass[] themode = new ModePass[] { };
Type Type_Return = typeof(void);
lrc_fun.Invoke(Parameters, ParameterTypes, themode, Type_Return);
lrc_fun.LoadFun("CreateLRC");
lrc_fun.Invoke(Parameters, ParameterTypes, themode, Type_Return);
base.OnLoad(e);
}
private void cboLrcColor_SelectedIndexChanged(object sender, EventArgs e)
{
if (!iscboColor)
{
iscboColor = true;
return;
}
String colorstr = cboLrcColor.Text;
if (colorstr.Equals(""))
{
return;
}
int index = 1;
if (colorstr.Equals("蓝色"))
{
index = 1;
}
else if (colorstr.Equals("绿色"))
{
index = 2;
}
else if (colorstr.Equals("红色"))
{
index = 3;
}
else if (colorstr.Equals("白色"))
{
index = 4;
}
else if (colorstr.Equals("黄色"))
{
index = 5;
}
object[] Parameters = new object[] { (int)index };
Type[] ParameterTypes = new Type[] { typeof(int) };
ModePass[] themode = new ModePass[] { ModePass.ByValue };
Type Type_Return = typeof(void);
lrc_fun.LoadFun("SetLRCColor");
lrc_fun.Invoke(Parameters, ParameterTypes, themode, Type_Return);
}
/// <summary>
/// DEC加密方法
/// </summary>
/// <param name="original"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string EncryptDec(string original, string key)
{
string str = string.Empty;
try
{
lock (DecryptDld)
{
if (!DecryptDld.BLoadDll)
{
string dllPath = string.Format(@"{0}dll\UrlParam.dll", AppDomain.CurrentDomain.SetupInformation.ApplicationBase);
DecryptDld.LoadDll(dllPath);
}
DecryptDld.LoadFun("UrlEncoding");
object[] parameters = new object[] { key, original }; // 实参为0
Type[] parameterTypes = new Type[] { typeof(string), typeof(string) }; // 实参类型为int
ModePass[] themode = new ModePass[] { ModePass.ByValue, ModePass.ByValue }; // 传送方式为值传
Type typeReturn = typeof(IntPtr); // 返回类型为int
IntPtr ret = (IntPtr)DecryptDld.Invoke(parameters, parameterTypes, themode, typeReturn);
str = Marshal.PtrToStringAnsi(ret);
//DecryptDLD.UnLoadDll();
Marshal.Release(ret);
}
}
catch (Exception)
{
// LogWriter.Write("PASS", err.Message);
}
return(str);
}
private void timeLrcTime_Tick(object sender, EventArgs e)
{
if (lrcanalysis != null)
{
//lblLrcText.Text=lrcanalysis.getLrcInfo(wmpPlay.currentMedia.
//lblLrcText.Text = "ss:" + wmpPlay.currentMedia.duration.ToString();获取总时间秒
//lblLrcText.Text=wmpPlay.Ctlcontrols.currentPosition.ToString();获取当前进度
long temp = 0;
LrcInfo info = lrcanalysis.getLrcInfo((long)(wmpPlay.Ctlcontrols.currentPosition * 1000), out temp);
if (info != null)
{
lblLrcText.Text = info.Lrcstr;
lbl_trim.Text = (temp / 1000).ToString();
if (!lrc_temp.Equals(info.Lrcstr))
{
lrc_temp = info.Lrcstr;
tmp_i = 0;
//dll动态链接库歌词程序
byte[] tempStr = Encoding.Default.GetBytes(info.Lrcstr);
byte[] tempDef = Encoding.Convert(Encoding.Default, Encoding.Unicode, tempStr);
//String lrcstr = Encoding.Unicode.GetString(tempDef);
lrc_fun.LoadFun("DrawLRC_SHOW_TEXT");
object[] Parameters = new object[] { (byte[])tempDef };
Type[] ParameterTypes = new Type[] { typeof(byte[]) };
ModePass[] themode = new ModePass[] { ModePass.ByValue };
Type Type_Return = typeof(void);
lrc_fun.Invoke(Parameters, ParameterTypes, themode, Type_Return);
lrc_fun.LoadFun("SetDrawLRCTime");
Parameters = new object[] { (long)(temp / 1000) };
ParameterTypes = new Type[] { typeof(long) };
themode = new ModePass[] { ModePass.ByValue };
lrc_fun.Invoke(Parameters, ParameterTypes, themode, Type_Return);
}
}
}
}
public object Invoke(string strFunctionName, object[] ObjArray_Parameter, Type[] TypeArray_ParameterType, ModePass[] ModePassArray_Parameter, Type Type_Return)
{
curFunName = strFunctionName;
m_ObjArray_Parameter = ObjArray_Parameter;
if (m_htFuns[strFunctionName] == null)
{
LoadFun(strFunctionName);
}
else
{
LoadFun(strFunctionName);
MethodInfo minfo = (MethodInfo)m_htFuns[strFunctionName];
return minfo.Invoke(null, ObjArray_Parameter);
}
if (farProc == IntPtr.Zero)
return null;
else
{
return Invoke(farProc, ObjArray_Parameter, TypeArray_ParameterType, ModePassArray_Parameter, Type_Return);
}
}
/// <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>
/// �������趨�ĺ���
/// </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>
/// 获得函数指针
/// </summary>
/// <param name="moduleHandle"> dll句柄 </param>
/// <param name="lpProcName"> 调用函数的名称 </param>
/// <param name="paramTypes"> 函数的传入参数类型列表 </param>
/// <param name="returnType"> 函数的返回值类型 </param>
public IntPtr LoadFun(IntPtr moduleHandle, string lpProcName, string[] paramTypes, string returnType)
{
// 若函数库模块的句柄为空，则抛出异常
if (moduleHandle == IntPtr.Zero)
{
throw (new Exception("Dll is not mounted!"));
}
// 取得函数指针
IntPtr functionHandle = GetProcAddress(moduleHandle, lpProcName);
// 若函数指针，则抛出异常
if (functionHandle == IntPtr.Zero)
{
throw (new Exception(" Do not found the function :" + lpProcName));
}
_modules[moduleHandle].Add(functionHandle);
Type[] ts = new Type[paramTypes == null ? 0 : paramTypes.Length];
ModePass[] paramPassTypes = new ModePass[ts.Length];
for (int i = 0; i < ts.Length; i++)
{
ts[i] = StringToType(paramTypes[i]);
paramPassTypes[i] = ModePass.ByValue;
}
Type tyre = StringToType(returnType);
// 下面是创建 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, tyre, ts);
// 获取一个 ILGenerator ，用于发送所需的 IL
ILGenerator il = myMethodBuilder.GetILGenerator();
for (int i = 0; i < ts.Length; i++)
{// 用循环将参数依次压入堆栈
switch (paramPassTypes[i])
{
case ModePass.ByValue:
il.Emit(OpCodes.Ldarg, i);
break;
case ModePass.ByRef:
il.Emit(OpCodes.Ldarga, i);
break;
default:
throw (new Exception(" parameter[" + (i + 1) + "]'s format is not valid! ."));
}
}
if (IntPtr.Size == 4)
{// 判断处理器类型
il.Emit(OpCodes.Ldc_I4, functionHandle.ToInt32());
}
else if (IntPtr.Size == 8)
{
il.Emit(OpCodes.Ldc_I8, functionHandle.ToInt64());
}
else
{
throw new PlatformNotSupportedException();
}
il.EmitCalli(OpCodes.Calli, CallingConvention.StdCall, tyre, ts);
il.Emit(OpCodes.Ret); // 返回值
myModuleBuilder.CreateGlobalFunctions();
// 取得方法信息
_methods[functionHandle] = myModuleBuilder.GetMethod("MyFun");
return(functionHandle);
}
