怎样在C#中调用DLL中的函数,最好有代码和详细说明

如题。。... 如题。。 展开
 我来答
匿名用户
2013-07-31
展开全部
首先,应该在C#语言源程序中声明外部方法,其基本形式是:[DLLImport(“DLL文件”)]修饰符 extern 返回变量类型 方法名称 (参数列表)其中:DLL文件:包含定义外部方法的库文件。修饰符: 访问修饰符,除了abstract以外在声明方法时可以使用的修饰符。返回变量类型:在DLL文件中你需调用方法的返回变量类型。方法名称:在DLL文件中你需调用方法的名称。参数列表:在DLL文件中你需调用方法的列表。注意:需要在程序声明中使用System.Runtime.InteropServices命名空间。 DllImport只能放置在方法声明上。DLL文件必须位于程序当前目录或系统定义的查询路径中(即:系统环境变量中Path所设置的路径)。返回变量类型、方法名称、参数列表一定要与DLL文件中的定义相一致。若要使用其它函数名,可以使用EntryPoint属性设置,如:[DllImport("user32.dll", EntryPoint="MessageBoxA")]static extern int MsgBox(int hWnd, string msg, string caption, int type);其它可选的 DllImportAttribute 属性:CharSet 指示用在入口点中的字符集,如:CharSet=CharSet.Ansi;SetLastError 指示方法是否保留 Win32"上一错误",如:SetLastError=true;ExactSpelling 指示 EntryPoint 是否必须与指示的入口点的拼写完全匹配,如:ExactSpelling=false;PreserveSig指示方法的签名应当被保留还是被转换, 如:PreserveSig=true;CallingConvention指示入口点的调用约定, 如:CallingConvention=CallingConvention.Winapi;此外,关于“数据封送处理”及“封送数字和逻辑标量”请参阅其它一些文章[2]。C#例子:1. 启动VS.NET,新建一个项目,项目名称为“Tzb”,模板为“Windows 应用程序”。2. 在“工具箱”的“ Windows 窗体”项中双击“Button”项,向“Form1”窗体中添加一个按钮。3. 改变按钮的属性:Name为 “B1”,Text为 “用DllImport调用DLL弹出提示框”,并将按钮B1调整到适当大小,移到适当位置。4. 在类视图中双击“Form1”,打开“Form1.cs”代码视图,在“namespace Tzb”上面输入“using System.Runtime.InteropServices;”,以导入该命名空间。5. 在“Form1.cs[设计]”视图中双击按钮B1,在“B1_Click”方法上面使用关键字 static 和 extern 声明方法“MsgBox”,将 DllImport 属性附加到该方法,这里我们要使用的是“user32.dll”中的“MessageBoxA”函数,具体代码如下:
[DllImport("user32.dll", EntryPoint="MessageBoxA")]static extern int MsgBox(int hWnd, string msg, string caption, int type);
然后在“B1_Click”方法体内添加如下代码,以调用方法“MsgBox”:
MsgBox(0," 这就是用 DllImport 调用 DLL 弹出的提示框哦! "," 挑战杯 ",0x30);6. 按“F5”运行该程序,并点击按钮B1,便弹出如下提示框:(二) 动态装载、调用DLL中的非托管函数在上面已经说明了如何用DllImport调用DLL中的非托管函数,但是这个是全局的函数,假若DLL中的非托管函数有一个静态变量S,每次调用这个函数的时候,静态变量S就自动加1。结果,当需要重新计数时,就不能得出想要的结果。下面将用例子说明:1. DLL的创建1) 启动Visual C++ 6.0;2) 新建一个“Win32 Dynamic-Link Library”工程,工程名称为“Count”;3) 在“Dll kind”选择界面中选择“A simple dll project”;4) 打开Count.cpp,添加如下代码:
// 导出函数,使用“ _stdcall ” 标准调用extern "C" _declspec(dllexport)int _stdcall count(int init);int _stdcall count(int init){//count 函数,使用参数 init 初始化静态的整形变量 S ,并使 S 自加 1 后返回该值static int S=init;S++;return S;}
5) 按“F7”进行编译,得到Count.dll(在工程目录下的Debug文件夹中)。2. 用DllImport调用DLL中的count函数1) 打开项目“Tzb”,向“Form1”窗体中添加一个按钮。2) 改变按钮的属性:Name为 “B2”,Text为 “用DllImport调用DLL中count函数”,并将按钮B1调整到适当大小,移到适当位置。3) 打开“Form1.cs”代码视图,使用关键字 static 和 extern 声明方法“count”,并使其具有来自 Count.dll 的导出函数count的实现,代码如下:
[DllImport("Count.dll")]static extern int count(int init);
4) 在“Form1.cs[设计]”视图中双击按钮B2,在“B2_Click”方法体内添加如下代码:
MessageBox.Show(" 用 DllImport 调用 DLL 中的 count 函数, n 传入的实参为 0 ,得到的结果是: "+count(0).ToString()," 挑战杯 ");MessageBox.Show(" 用 DllImport 调用 DLL 中的 count 函数, n 传入的实参为 10 ,得到的结果是: "+count(10).ToString()+"n 结果可不是想要的 11 哦!!! "," 挑战杯 ");MessageBox.Show(" 所得结果表明: n 用 DllImport 调用 DLL 中的非托管 n 函数是全局的、静态的函数!!! "," 挑战杯 ");5) 把Count.dll复制到项目“Tzb”的binDebug文件夹中,按“F5”运行该程序,并点击按钮B2,便弹出如下三个提示框:
第1个提示框显示的是调用“count(0)”的结果,第2个提示框显示的是调用“count(10)”的结果,由所得结果可以证明“用DllImport调用DLL中的非托管函数是全局的、静态的函数”。所以,有时候并不能达到我们目的,因此我们需要使用下面所介绍的方法:C#动态调用DLL中的函数。 3. C#动态调用DLL中的函数因为C#中使用DllImport是不能像动态load/unload assembly那样,所以只能借助API函数了。在kernel32.dll中,与动态库调用有关的函数包括[3]:①LoadLibrary(或MFC 的AfxLoadLibrary),装载动态库。②GetProcAddress,获取要引入的函数,将符号名或标识号转换为DLL内部地址。③FreeLibrary(或MFC的AfxFreeLibrary),释放动态链接库。它们的原型分别是:HMODULE LoadLibrary(LPCTSTR lpFileName);FARPROC GetProcAddress(HMODULE hModule, LPCWSTR lpProcName);BOOL FreeLibrary(HMODULE hModule);现在,我们可以用IntPtr hModule=LoadLibrary(“Count.dll”);来获得Dll的句柄,用IntPtr farProc=GetProcAddress(hModule,”_count@4”);来获得函数的入口地址。但是,知道函数的入口地址后,怎样调用这个函数呢?因为在C#中是没有函数指针的,没有像C++那样的函数指针调用方式来调用函数,所以我们得借助其它方法。经过研究,发现我们可以通过结合使用System.Reflection.Emit及System.Reflection.Assembly里的类和函数达到我们的目的。为了以后使用方便及实现代码的复用,我们可以编写一个类。1) dld类的编写:1. 打开项目“Tzb”,打开类视图,右击“Tzb”,选择“添加”-->“类”,类名设置为“dld”,即dynamic loading dll 的每个单词的开头字母。2. 添加所需的命名空间及声明参数传递方式枚举
using System.Runtime.InteropServices; // 用 DllImport 需用此 命名空间using System.Reflection; // 使用 Assembly 类需用此 命名空间using System.Reflection.Emit; // 使用 ILGenerator 需用此 命名空间
在“public class dld”上面添加如下代码声明参数传递方式枚举:
/// <summary>/// 参数传递方式枚举 ,ByValue 表示值传递 ,ByRef 表示址传递/// </summary>public enum ModePass{ByValue = 0x0001,ByRef = 0x0002}3. 声明LoadLibrary、GetProcAddress、FreeLibrary及私有变量hModule和farProc:
/// <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;4. 添加LoadDll方法,并为了调用时方便,重载了这个方法:
/// <summary>/// 装载 Dll/// </summary>/// <param name="lpFileName">DLL 文件名 </param>public void LoadDll(string lpFileName){hModule=LoadLibrary(lpFileName);if(hModule==IntPtr.Zero)throw(new Exception(" 没有找到 :"+lpFileName+"." ));} 若已有已装载Dll的句柄,可以使用LoadDll方法的第二个版本:
public void LoadDll(IntPtr HMODULE){if(HMODULE==IntPtr.Zero)throw(new Exception(" 所传入的函数库模块的句柄 HMODULE 为空 ." ));hModule=HMODULE;}5. 添加LoadFun方法,并为了调用时方便,也重载了这个方法,方法的具体代码及注释如下:
/// <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+" 这个函数的入口点 "));}6. 添加UnLoadDll及Invoke方法,Invoke方法也进行了重载:
/// <summary>/// 卸载 Dll/// </summary>public void UnLoadDll(){FreeLibrary(hModule);hModule=IntPtr.Zero;farProc=IntPtr.Zero;}
匿名用户
2013-07-31
展开全部
Type.InvokeMember()的方法来调用。Type.InvokeMember()在调用的时候需要接受一个Object类型的数组来传递接口的参数信息。

这样说行了么? 不行? 招唤分隔线, 一个调用COM组件DLL的列子
----------------------------------------------------------------------------------------------------

type ComObjType;
object ComObj;
string ReturnValue;

//创建COM对象的引用
ComObjType = Type.GetTypeFromProgID("SomeComServer.SomeComObject");
ComObj = Activator.CreateInstance(ComObjType);

//为InvokeMethod 的调用构建参数数组,并初始化每个参数元素
object[] ParamArray = new object[3];
ParamArray [0] = "InParam" ;
ParamArray[1] = 5 ;
ParamArray[2] = "" ;
//构建ParameterModifier数组(注意上面所说的ParameterModifier数组里面只有一个元素)
//这里有三个参数。所以在创建ParameterModifier对象的时候要在其构造函数里面指出参数的个数
//用参数的索引属性来指出哪些参数是一个返回的参数
//对于那些是[in]或ByRef的参数可以不用指定
ParameterModifier[] ParamMods = new ParameterModifier [1];
ParamMods[0] = new ParameterModifier (3); // 初始化为接口参数的个数
ParamMods[0][1] = true; // 设置第二个参数为返回参数
ParamMods[0][2] = true; // 设置第三个参数为返回参数
//调用含有ParameterModifier数组的重载函数
ReturnValue = (string) ComObjType.InvokeMember("ReturnSomeValues", // 接口函数名
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
ComObj, // 调用的COM组件
ParamArray, // 参数数组
ParamMods, // 指定返回参数的ParameterModifier数组
null,
null) ;

//显示参数的值
Console.WriteLine ("Param1 = {0}", ParamArray[0]) ;
Console.WriteLine ("Param2 = {0}", ParamArray[1]) ;
Console.WriteLine ("Param3 = {0}", ParamArray[2]) ;
Console.WriteLine ("Return Value = {0}", ReturnValue ) ;
注意,为了给InvokeMethod()传递正确的ParameterModifier数组,你必须在接受返回的参数数组中初始化参数的数据类型。在上面的例子中,第二个参数是整形[5],第三个参数是文本['']。
已赞过 已踩过<
你对这个回答的评价是?
评论 收起
匿名用户
2013-07-31
展开全部
[C#动态调用C++编写的DLL函数]
by jingzhongrong 2008-05-08 动态加载DLL需要使用Windows API函数:LoadLibrary、GetProcAddress以及FreeLibrary。我们可以使用DllImport在C#中使用这三个函数。

[DllImport("Kernel32")]
public static extern int GetProcAddress(int handle, String funcname);

[DllImport("Kernel32")]
public static extern int LoadLibrary(String funcname);

[DllImport("Kernel32")]
public static extern int FreeLibrary(int handle);

当我们在C++中动态调用Dll中的函数时,我们一般的方法是:
假设DLL中有一个导出函数,函数原型如下:
BOOL __stdcall foo(Object &object, LPVOID lpReserved);

1、首先定义相应的函数指针:
typedef BOOL (__stdcall *PFOO)(Object &object, LPVOID lpReserved);

2、调用LoadLibrary加载dll:
HINSTANCE hInst = ::LoadLibraryW(dllFileName);

3、调用GetProcAddress函数获取要调用函数的地址:
PFOO foo = (PFOO)GetProcAddress(hInst,"foo");
if(foo == NULL)
{
FreeLibrary(hInst);
return false;
}

4、调用foo函数:
BOOL bRet = foo(object,(LPVOID)NULL);

5、使用完后应释放DLL:
FreeLibrary(hInst);

那么在C#中应该怎么做呢?方法基本上一样,我们使用委托来代替C++的函数指针,通过.NET Framework 2.0新增的函数GetDelegateForFunctionPointer来得到一个委托的实例:

下面封装了一个类,通过该类我们就可以在C#中动态调用Dll中的函数了:

public class DLLWrapper
{
///<summary>
/// API LoadLibrary
///</summary>
[DllImport("Kernel32")]
public static extern int LoadLibrary(String funcname);

///<summary>
/// API GetProcAddress
///</summary>
[DllImport("Kernel32")]
public static extern int GetProcAddress(int handle, String funcname);

///<summary>
/// API FreeLibrary
///</summary>
[DllImport("Kernel32")]
public static extern int FreeLibrary(int handle);

///<summary>
///通过非托管函数名转换为对应的委托, by jingzhongrong
///</summary>
///<param name="dllModule">通过LoadLibrary获得的DLL句柄</param>
///<param name="functionName">非托管函数名</param>
///<param name="t">对应的委托类型</param>
///<returns>委托实例,可强制转换为适当的委托类型</returns>
public static Delegate GetFunctionAddress(int dllModule, string functionName, Type t)
{
int address = GetProcAddress(dllModule, functionName);
if (address == 0)
return null;
else
return Marshal.GetDelegateForFunctionPointer(new IntPtr(address), t);
}

///<summary>
///将表示函数地址的IntPtr实例转换成对应的委托, by jingzhongrong
///</summary>
public static Delegate GetDelegateFromIntPtr(IntPtr address, Type t)
{
if (address == IntPtr.Zero)
return null;
else
return Marshal.GetDelegateForFunctionPointer(address, t);
}

///<summary>
///将表示函数地址的int转换成对应的委托,by jingzhongrong
///</summary>
public static Delegate GetDelegateFromIntPtr(int address, Type t)
{
if (address == 0)
return null;
else
return Marshal.GetDelegateForFunctionPointer(new IntPtr(address), t);
}
}

通过这个类,我们这样调用DLL:

1、声明相应的委托(正确声明很重要,否则不能调用成功,后面有详细介绍)。

2、加载DLL:
int hModule = DLLWrapper.LoadLibrary(dllFilePath);
if (hModule == 0)
return false;

3、获取相应的委托实例:
FOO foo = (FOO)DLLWrapper.GetFunctionAddress(hModule, "foo", typeof(FOO));
if (foo == null)
{
DLLWrapper.FreeLibrary(hModule);
return false;
}

4、调用函数:
foo(...);

5、.NET并不能自动释放动态加载的DLL,因此我们在使用完DLL后应该自己释放DLL:
DLLWrapper.FreeLibrary(hModule);

下面我们将就委托应如何声明进行相应的讨论,在实际操作过程中,我发现使用DllImport方法和动态调用方法两者在C#中对DLL中函数原型的声明是有些区别的,下面我介绍动态调用中委托的声明:

1、首先应该注意的是,C++中的类型和C#中类型的对应关系,比如C++中的long应该对应C#中的Int32而不是long,否则将导致调用结果出错。

2、结构的声明使用StructLayout对结构的相应布局进行设置,具体的请查看MSDN:

使用LayoutKind指定结构中成员的布局顺序,一般可以使用Sequential:
[StructLayout(LayoutKind.Sequential)]
struct StructVersionInfo
{
public int MajorVersion;
public int MinorVersion;
}
另外,如果单独使用内部类型没有另外使用到字符串、结构、类,可以将结构在C#中声明为class:
[StructLayout(LayoutKind.Sequential)]
class StructVersionInfo
{
public int MajorVersion;
public int MinorVersion;
}

对应C++中的声明:
typedef struct _VERSION_INFO
{
int MajorVersion;
int MinorVersion;
} VERSION_INFO, *PVERSION_INFO;

如果结构中使用到了字符串,最好应指定相应的字符集:
[StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)]

部分常用的声明对应关系(在结构中):
C++:字符串数组
wchar_t Comments[120];
C#:
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 120)]
public string Comments;

C++:结构成员
VERSION_INFO ver;
C#
publicStructVersionInfo ver;

C++:函数指针声明
PFOO pFoo; //具体声明见文章前面部分
C#:
publicIntPtr pFoo; //也可以为 public int pFoo;
//不同的声明方法可以使用上面DLLWrapper类的相应函数获取对应的委托实例

如果在结构中使用到了union,那么可以使用FieldOffset指定具体位置。

3、委托的声明:

当C++编写的DLL函数需要通过指针传出将一个结构:如以下声明:
void getVersionInfo(VERSION_INFO *ver);
对于在C#中声明为class的结构(当VERSION_INFO声明为class)
delegate voidgetVersionInfo(VERSION_INFO ver);
如果结构声明为struct,那么应该使用如下声明:
delegate voidgetVersionInfo(refVERSION_INFO ver);
注意:应该使用ref关键字。

如果DLL函数需要传入一个字符串,比如这样:
BOOL __stdcall jingzhongrong1(const wchar_t* lpFileName, int* FileNum);
那么使用委托来调用函数的时候应该在C#中如下声明委托:
delegate bool jingzhongrong1(
[MarshalAs(UnmanagedType.LPWStr)]String FileName,
ref int FileNum);
注意:应该使用[MarshalAs(UnmanagedType.LPWStr)]和String进行声明。

如果要在DLL函数中传出一个字符串,比如这样:
void __stdcall jingzhongrong2(
wchar_t* lpFileName, //要传出的字符串
int* Length);
那么我们如下声明委托:
//使用委托从非托管函数的参数中传出的字符串,
//应该这样声明,并在调用前为StringBuilder预备足够的空间
delegate void jingzhongrong2(
[MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpFileName,
ref int Length,
);
在使用函数前,应先为StringBuilder声明足够的空间用于存放字符串:
StringBuilder fileName = new StringBuilder(FileNameLength);
已赞过 已踩过<
你对这个回答的评价是?
评论 收起
匿名用户
2013-07-31
展开全部
我来说一种简单的方式吧 //Add.cs namespace Add { public class Test { public static int Add(int x,int y) { return x+y; } } } 使用编译指令,把Add.cs编译成一个DLL:csc /t:library Add.cs ,那么在下面的主程序中调用Add.DLL中的Add()方法如下: //Main.cs using System; using Add; class MainClass { static void Main() { Console.WriteLine(Add.Test.Add(1,2)); } } 编译器指令为:csc /r:Add.dll Main.cs
已赞过 已踩过<
你对这个回答的评价是?
评论 收起
收起 更多回答(2)
推荐律师服务: 若未解决您的问题,请您详细描述您的问题,通过百度律临进行免费专业咨询

为你推荐:

下载百度知道APP,抢鲜体验
使用百度知道APP,立即抢鲜体验。你的手机镜头里或许有别人想知道的答案。
扫描二维码下载
×

类别

我们会通过消息、邮箱等方式尽快将举报结果通知您。

说明

0/200

提交
取消

辅 助

模 式