C# Tips:调用Win32 API如何处理指针类型的参数

259 篇文章 4 订阅
0、前言
从VB到C#,被人诟病比较多的就是交互性比较差,又集中表现在调用Win32 API上。如果说C/C++调用API只是调用函数这类轻松的活,在C#下却成了阻挡入门者的技术活。之所以产生这么大区别在于数据类型的差异,就是因为C#这类采用了“安全”的类型,我们避免了内存释放和内存访问错误的一些困扰,但是不得不面对调用API时的繁琐。有得必有失,关键看你选择了什么。
在调用API时,对于值类型的数据,不存在什么转换问题,只要搞清楚到底是Byte、Int16、Int32 还是Int64就可以了,比较麻烦的地方是指针,因为C#中没有办法显性的使用指针,有时需要借助unsafe code达到这个目的。如果都“unsafe”了,那还用C#干吗,本文的目的就是总结一下,怎样用“safe”的方式解决Win32 API中指针类型参数的问题。
1、 基本原则
在我们在调用API时,如果发现参数中有指针类型的时候,不要简单的用IntPtr去替换,或者直接就是用*来定义。虽然C#中能够使用指针,但是这样做就违背了C#设计时的初衷,此外DotNET Framework平台下使用unsafe代码多少会影响应用程序的效率。
当我们拿到一个API,阅读API的说明时,一定要关注以下几点:
l 每一个参数的数据类型是什么?如果是指针,指针指向的是一个什么数据结构,基本数据类型、字符串、结构还就是一块内存。不同的类型在C#下处理的模式是不同的。
l 指针所指向的数据结构是谁创建,该由谁释放?这也非常重要,它两层含义:一个是我们怎么定义接口,并且准备调用参数;另一个就是资源释放的问题,某些调用这申请,被调用这释放的资源,需要约定的方法申请或释放资源,反之亦然。
只要花点时间分析一下,就会发现即便是在复杂的结构,不用“unsafe code”也能够完成调用,只不过有时候过程有点繁琐,不如C/C++调用API那么畅快淋漓。但是我想说的是,如果选择了C#,那么就是C#的思想去解决问题,这样才能够发挥出C#所有的潜力。
2、实例分析
了解了基本原则,下面就逐一分析一下怎样雅致并且“安全”地解决不同类型指针的调用问题。
2.1、         字符串
字符串应该是我们接触到最多的情况,一般在API定义中被描述为“LPSTR/LPTSTR/LPCTSTR/LPWSTR”之类,我们在申明API接口的时候,如果是传入类型的参数,直接用String类型申明即可,例如:
        /**/ ///<summary>
       
///原型是:HMODULE LoadLibrary(LPCTSTR lpFileName);
       
///</summary>
       
///<param name="lpFileName">DLL 文件名</param>
       
///<returns>函数库模块的句柄</returns>

        [DllImport( " kernel32.dll " )]
       
public static extern IntPtr LoadLibrary( string lpFileName);
但是如果是传出类型的字符串参数,简单的这么写就不行了。我的理解是String变成LPSTR,是DotNET Framework的交互接口帮我们做了一次转换,创建了一个字符数组,将我们提供的String复制了一次,再传递给API,并非简单的指针传递,所以当我们要求在我们设定的一个地址区域去写数据时,就不能够直接申明为String,而应该是Byte或者Char数组,可以参考下面的例子:
函数声明:
        /**/ ///<summary>
       
/// int GetClassName(HWND hWnd, LPTSTR lpClassName, int nMaxCount);
       
///</summary>

        [DllImport( " user32 " ,CharSet = CharSet.Ansi)]
       
public static extern Int32 GetClassName(IntPtr hwnd, Byte[] lpClassName, Int32 nMaxCount);
         调用事例:
         String sClassName = null ;
         Byte[] abClassName
= null ;
         Int32 dwRet
= 0 ;

         abClassName
= new Byte[ 100 ];
         dwRet
= GetClassName( this .Handle, abClassName, 100 );
         sClassName
= System.Text.ASCIIEncoding.ASCII.GetString(abClassName, 0 ,dwRet);
         MessageBox.Show(sClassName);
还需要注意一点的就是Ansi还是Unicode的字符集了,申明的是什么就用什么转换。
2.2、         句柄—Handle
句柄严格意义上来说不能归在指针这一类,句柄是本宏定义掩盖了的一种数据结构,不过行为上和指针有些类似。最常见的有窗口句柄、Socket句柄还有内核对象的句柄等。总之H开头的一些定义基本都是句柄。
对于句柄来说我们通常无法直接访问句柄所代表的那个数据结构,只要记录句柄值就可以了,而且我们并不关心句柄这个值的内容,只要他有效就行了,所以句柄最容易处理。一般Win32下,句柄就是一个32位的整型,所以用Int32/UInt32或者IntPtr申明即可。还是上面那个例子,HMODULE就是一个句柄。
2.3、         基本类型的指针
两种情况下会出现基本类型的指针:一种是基本类型的地址,表示返回类型的参数;一种是表示传递一个基本类型的数组,这两种情况需要分别对待。
返回类型,C#中有专门的修饰符ref,表示参数传递按地址传送。缺省情况下参数都是按值传递的,如果希望按照地址传递,只要在参数前添加ref的修饰符即可。例如:
        /**/ ///<summary>
       
///原形:BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
       
///</summary>

        [DllImport( " kernel32.dll " )]
       
public extern static Int32 ReadFile(IntPtr hFile, Byte[] buffer,Int32 nNumberOfBytesToRead, ref Int32 lpNumberOfBytesRead, ref OVERLAPPED lpOverlapped);
对于C/C++中数组参数,就是一块连续内存的首地址。在C#中的数组默认都是从Array派生的类,虽然结构复杂了,但是内存布局应该是相同的,所以只要把参数定义为基本类型的数组就可以了。例如:
        /**/ ///<summary>
       
/// BOOL GetCharWidth(HDC hdc,UINT iFirstChar,UINT iLastChar,LPINT lpBuffer);
       
///</summary>

        [DllImport( " gdi32 " )]
       
public static extern Int32 GetCharWidth(HDC hdc, Int32 wFirstChar, Int32 wLastChar, int32[] lpBuffer);
2.4、         结构
说到结构,先要解释一下C#中数据类型的分类。C#中的数据类型一般有两种,一种是值类型,就是Byte、Int32之流,出于反射的需要,值类型都是从ValueType派生而得;一种是引用类型,从Object派生出来的类都是引用类型。所谓值类型,就是赋值和传递了传的是数据本身,引用类型传递的是数据所对应实例的引用,C#中结构(以struct定义的)是值类型的,类(以class定义的)是引用类型的。
实际调用API时,API参数如果是一个自定义结构指针的话,通常把数据结构定义为struct,在申明时函数接口时用ref修饰。例如Guid就是DotNET类库中内建的一个结构,具体用法如下:
        /// <summary>
       
/// 原形:HRESULT WINAPI GetDeviceID(LPCGUID pGuidSrc, LPGUID pGuidDest);
       
/// </summary>
       
/// <param name="pGuidSrc"></param>
       
/// <param name="pGuidDest"></param>
       
/// <returns></returns>
        [DllImport( " Dsound.dll " )]
       
private static extern Int32 GetDeviceID( ref Guid pGuidSrc, ref Guid pGuidDest);
如果自定义结构的话,结构在内存中占据的字节数务必要匹配,当结构中包含数组的时候需要用MarshalAsAttribute属性进行修饰,设定数组长度。具体可以参考下面的例子:
        /**/ ///<summary>
       
///原形:
       
/// typedef struct tagPAINTSTRUCT {
       
///     HDC hdc;
       
///     BOOL fErase;
       
///     RECT rcPaint;
       
///     BOOL fRestore;
       
///     BOOL fIncUpdate;
       
///     BYTE rgbReserved[32];
       
/// } PAINTSTRUCT;
       
///</summary>

        public struct PAINTSTRUCT
       
... {
           
public IntPtr hdc;
           
public Boolean fErase;
           
public RECT rcPaint;
           
public Boolean fRestore;
           
public Boolean fIncUpdate;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst
= 32)]public Byte[] rgbReserved;
        }


       
/**/ ///<summary>
       
///原形:HDC BeginPaint( HWND hwnd, LPPAINTSTRUCT lpPaint);
       
///</summary>

        [DllImport( " user32 " )]
       
public static extern IntPtr BeginPaint(IntPtr hwnd, ref PAINTSTRUCT lpPaint);
2.5、         结构数组
结构数组就比较复杂了,就我个人的经验,不同厂商提供的API,实现不同,需要采用的处理方式也不相同的。
一般情况下,参照基本类型数组的调用方式即可,例如:
        /// <summary>
       
/// 原形:
       
/// typedef struct tagACCEL {
       
///      BYTE fVirt;
       
///      WORD key;
       
///      WORD cmd;
       
/// } ACCEL, *LPACCEL;
       
/// </summary>
        public struct ACCEL
        {
           
public Byte fVirt;
           
public UInt16 key;
           
public UInt16 cmd;
        }
       
/// <summary>
       
/// 原形:int CopyAcceleratorTable(HACCEL hAccelSrc,LPACCEL lpAccelDst,int cAccelEntries);
       
/// </summary>
       
/// <returns></returns>
        [DllImport( " user32 " )]
       
public static extern Int32 CopyAcceleratorTable(IntPtr hAccelSrc, ACCEL[] lpAccelDst, Int32 cAccelEntries);
但是也有特殊情况,对些厂商提供的API中,不知是否和内存复制的方式有关,类似的函数,如果采用上面相同的定义方法调用的话,调用正确,但是应该返回的数据没有被改写。这个时候就需要另一种方法来解决了。
众所周知,在逻辑上结构是一段连续的内存,数组也是一段连续内存,我们可以从堆中直接申请一段内存,调用API,然后将返回的数据再转换成结构即可。具体可以参看下面的例子。
结构定义以及API声明:
        [StructLayout(LayoutKind.Sequential, Pack = 8 )]
       
private struct CmBoxInfo
        {
           
public static CmBoxInfo Empty = new CmBoxInfo();

           
public byte MajorVersion;
           
public byte MinorVersion;
           
public ushort BoxMask;
           
public uint SerialNumber;
           
public ushort BoxKeyId;
           
public ushort UserKeyId;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst
= CM_PUBLIC_KEY_LEN)] public byte [] BoxPublicKey;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst
= CM_PUBLIC_KEY_LEN)] public byte [] SerialPublicKey;
           
public uint Reserve;

           
public void Init()
            {
                BoxPublicKey
= new byte [CM_PUBLIC_KEY_LEN];
                Debug.Assert(BoxPublicKey
!= null );
                SerialPublicKey
= new byte [CM_PUBLIC_KEY_LEN];
                Debug.Assert(SerialPublicKey
!= null );
            }
        }
       
/// <summary>
       
/// 原型:int CMAPIENTRY CmGetBoxes(HCMSysEntry hcmse, unsigned long idPort, CMBOXINFO *pcmBoxInfo, unsigned int cbBoxInfo)
       
/// </summary>
        [DllImport( " xyz.dll " )]
       
private static extern Int32 CmGetBoxes(IntPtr hcmse, CmGetBoxesOption idPort,IntPtr pcmBoxInfo, Int32 cbBoxInfo);
调用示例
            IntPtr hcmBoxes = IntPtr.Zero;
            CmAccess cma
= new CmAccess();
            CmBoxInfo[] aBoxList
= null ;
            Int32 dwBoxNum
= 0 , dwLoop = 0 ,dwBoxInfoSize = 0 ;
            IntPtr pBoxInfo
= IntPtr.Zero;

            dwBoxNum
= m_pCmGetBoxes(hcmBoxes, CmGetBoxesOption.AllPorts, IntPtr.Zero, 0 );
           
if (dwBoxNum > 0 )
            {
                aBoxList
= new CmBoxInfo[dwBoxNum];
               
if (aBoxList != null )
                {
                    dwBoxInfoSize
= Marshal.SizeOf(aBoxList[ 0 ]);
                    pBoxInfo
= Marshal.AllocHGlobal(dwBoxInfoSize * dwBoxNum);
                   
if (pBoxInfo != IntPtr.Zero)
                    {
                        dwBoxNum
= m_pCmGetBoxes(hcmBoxes, CmGetBoxesOption.AllPorts, pBoxInfo, dwBoxNum);
                       
for (dwLoop = 0 ; dwLoop < dwBoxNum; dwLoop ++ )
                        {
                            aBoxList[dwLoop]
= (CmBoxInfo)Marshal.PtrToStructure((IntPtr)((UInt32)pBoxInfo + dwBoxInfoSize * dwLoop), CmBoxInfo.Empty.GetType());
                        }
                        Marshal.FreeHGlobal(pBoxInfo);
                        pBoxInfo
= IntPtr.Zero;
                    }
                   
else
                    {
                        aBoxList
= null ;
                    }
                }
            }
       最后提一句,Marshal类非常有用,其中包括了大量内存申请、复制和类型转换的函数,灵活运用的话,基本上可以避免unsafe code。
2.6、         函数指针(回调函数)
C#中采用委托(delegate)和函数指针等同的功能,当API函数的参数为回调函数时,我们通常使用委托来替代。与C和C++ 中的函数指针相比,委托实际上是具体一个Delegate派生类的实例,它还包括了对参数和返回值,类型安全的检查。
先看一下下面的例子:
        /// <summary>
       
/// 原形:typedef BOOL (CALLBACK *LPDSENUMCALLBACKA)(LPGUID, LPCSTR, LPCSTR, LPVOID);
       
/// </summary>
        public delegate Boolean LPDSENUMCALLBACK(IntPtr guid, String sDesc, String sDevName, ref Int32 dwFlag);
       
/// <summary>
       
/// 原形:HRESULT WINAPI DirectSoundCaptureEnumerateA(LPDSENUMCALLBACKA pDSEnumCallback, LPVOID pContext);
       
/// </summary>
        [DllImport( " Dsound.dll " )]
       
public static extern Int32 DirectSoundCaptureEnumerate(LPDSENUMCALLBACK pDSEnumCallBack, ref Int32 dwFlag);
具体调用方法如下:
          dwRet = DirectSoundEnumerate( new LPDSENUMCALLBACK(DSoundEnumCallback), ref dwFlag);
       这里需要特别注意的就是委托实际上是一个实例,和普通的类实例一样,是被DotNET Framework垃圾收集机制所管理,有生存周期的。上文例子的定义方式其实函数级别的局部变量,当函数结束时,将被释放,如果回调仍然在继续的话,就会产生诸如非法访问的错误。所以在使用回调函数的时候一定要比较清楚的了解,回调的作用周期是多大,如果回调是全局的,那么定义一个全局的委托变量作为参数。
2.7、         表示多种类型的指针—LPVOID以及其它
指针是C/C++的精髓所在,一个void能够应付所有的问题,我们遇到最多的可能就是LPVOID这样的参数。LPVOID最常用的有两种情况,一种就是表示一个内存块,另一种情况可能是根据其它参数的定义指向不同的数据结构。
第一种情况很好处理,如果是一个内存块,我们可以他当作一个Byte数组就可以了,例如:
        /**/ ///<summary>
       
///原形:BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
       
///</summary>

        [DllImport( " kernel32.dll " )]
       
public extern static Int32 ReadFile(IntPtr hFile, Byte[] buffer,Int32 nNumberOfBytesToRead, ref Int32 lpNumberOfBytesRead, ref OVERLAPPED lpOverlapped);
第二种情况比较复杂,C#中类型转换是有限制的,一个Int32是没法直接转换成为Point的,这个时候之能够根据不同的参数类型定义不同的重载函数了。例如GetProcAddress函数的lpProcName既可以是一个字符串表示函数名,又可以是一个高字为0的Int32类型,表示函数的序号,我们可以这样分别定义:
        /**/ ///<summary>
       
///原型是: FARPROC GetProcAddress(HMODULE hModule,LPCSTR lpProcName);
       
///</summary>

        [DllImport( " kernel32.dll " , EntryPoint = " GetProcAddress " )]
       
private extern static IntPtr GetProcAddress(IntPtr hModule, String sFuncName);
        [DllImport(
" kernel32.dll " , EntryPoint = " GetProcAddress " )]
       
private extern static IntPtr GetProcAddressByIndex(IntPtr hModule, Int32 dwIndex);
在这里总结了调用API时有关指针的一些常见问题,你会发现大多数情况下C#依靠自身的能力就能解决问题,希望对大家有帮助。

相关文章

CSharp Tips:调用Win32 API如何处理指针类型的参数(补)

 

2年多前整理了一下调用Win32 API过程中指针类型的参数如何处理,发觉遗漏的重要的一点,就是怎样处理UNION。

C/C++中UNION是这样定义:

“联合”是一种特殊的类,也是一种构造类型的数据结构。在一个“联合”内可以定义多种不同的数据类型,一个被说明为该“联合”类型的变量中,允许装入该“联合”所定义的任何一种数据,这些数据共享同一段内存,已达到节省空间的目的(还有一个节省空间的类型:位域)。这是一个非常特殊的地方,也是联合的特征。另外,同struct一样,联合默认访问权限也是公有的,并且,也具有成员函数。

首先UNION和结构(STRUCT)一样是值类型,两者最大的不同在于内部成员所占用的空间上。在结构中各成员有各自的内存空间, 一个结构变量的总长度是各成员长度之和(空结构除外,同时不考虑边界调整)。而在“联合”中,各成员共享一段内存空间, 一个联合变量的长度等于各成员中最长的长度。所以在使用上和结构是一致的,关键在于定义不同。C#中没有UNION关键字,我们就用struct,外加一点技巧来实现。例如:

[c-sharp] view plain copy print ?
  1. /// <summary> 
  2. /// 原型:typedef struct tagINPUT {  
  3. ///         DWORD type;  
  4. ///         union {MOUSEINPUT mi;  
  5. ///             KEYBDINPUT ki; 
  6. ///             HARDWAREINPUT hi; 
  7. ///             }; 
  8. ///         }INPUT, *PINPUT; 
  9. /// </summary> 
  10. [StructLayout(LayoutKind.Explicit)] 
  11. public struct INPUT 
  12.     [FieldOffset(0)] 
  13.     public UInt32 type; 
  14.     [FieldOffset(4)] 
  15.     public MOUSEINPUT mi; 
  16.     [FieldOffset(4)] 
  17.     public KEYBDINPUT ki; 
  18.     [FieldOffset(4)] 
  19.     public HARDWAREINPUT hi; 

这里“[StructLayout(LayoutKind.Explicit)]”的修饰很重要,就是表明结构内的成员按照设定的位置在内存中排列。上面的例子中mi、ki、hi三个成员都是结构体内便宜的第四个字节开始的,也就暗合了UNION内的成员共享同一段内存(首地址相同)。UNION能够处理了,API的申明就很简单了,和STRUCT完全一致,例如:

[c-sharp] view plain copy print ?
  1. /// <summary> 
  2. /// The SendInput function synthesizes keystrokes, mouse motions, and button clicks. 
  3. /// 原型:UINT SendInput(UINT nInputs,LPINPUT pInputs, int cbSize); 
  4. /// </summary> 
  5. [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] 
  6. private static extern UInt32 SendInput(UInt32 nInputs,ref INPUT pInputs,Int32 cbSize); 

就这么简单,搞定

 

 在解析C#结构体指针前,必须知道C#结构体是如何定义的。在c#中同样定义该结构体。

    C#结构体指针之C#结构体的定义:

 
 
  1. [StructLayout(LayoutKind.Sequential)]
  2. public struct VGAStat
  3. {
  4. public int ChannelNum;//通道数量
  5. [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
  6. public char[] Version;//版本信息
  7. public uint CPUUsage;//CPU占用
  8. public bool WorkStatusOk; //工作状态
  9. [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
  10. public tagCheckArg[] ChannelStatistic;//通道信息
  11. }

    定义完结构体后,就可将接收到的C#结构体指针转换为定义的结构体对象。

 
 
  1. VGAStat entries = (VGAStat)Marshal.PtrToStructure(iptr, typeof(VGAStat));
  2. //iptr为接收到的非托管的结构体指针。

    反之,也可将结构体赋值后封送到非托管内存。

    假如vga为定义后实例化并赋值了的结构体。

 
 
  1. IntPtr intptr = Marshal.AllocHGlobal(Marshal.SizeOf(vga));
  2. Marshal.StructureToPtr(vga, intptr, true);
  3. //在此发送intptr指针给目的方
  4. Marshal.FreeHGlobal(intptr);//释放分配的非托管内存。

    C#结构体指针的定义及使用的相关内容那个就向你介绍到这里,希望对你了解和学习C#结构体指针有所帮助。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值