C# c++ 类型转换

通 常，只要您选择一个其规范与该参数的 Win32 类型相匹配的 CLR 类型，您的代码就能够正常工作。不过也有一些特例。例如，在 Windows API 中定义的 BOOL 类型是一个有符号的 32 位整型。然而，BOOL 用于指示 Boolean 值 true 或 false。虽然您不用将 BOOL 参数作为 System.Int32 值封送，但是如果使用 System.Boolean 类型，就会获得更合适的映射。字符类型的映射类似于 BOOL，因为有一个特定的 CLR 类型 (System.Char) 指出字符的含义。

 

指针参数

许 多 Windows API 函数将指针作为它们的一个或多个参数。指针增加了封送数据的复杂性，因为它们增加了一个间接层。如果没有指针，您可以通过值在线程堆栈中传递数据。有了指 针，则可以通过引用传递数据，方法是将该数据的内存地址推入线程堆栈中。然后，函数通过内存地址间接访问数据。使用托管代码表示此附加间接层的方式有多 种。

在 C# 中，如果将方法参数定义为 ref 或 out，则数据通过引用而不是通过值传递。即使您没有使用 Interop 也是这样，但只是从一个托管方法调用到另一个托管方法。例如，如果通过 ref 传递 System.Int32 参数，则在线程堆栈中传递的是该数据的地址，而不是整数值本身。下面是一个定义为通过引用接收整数值的方法的示例：

void FlipInt32(ref Int32 num){ num = -num; }

这里，FlipInt32 方法获取一个 Int32 值的地址、访问数据、对它求反，然后将求反过的值赋给原始变量。在以下代码中，FlipInt32 方法会将调用程序的变量x 的值从 10 更改为 -10：

Int32 x = 10; FlipInt32(ref x);

在托管代码中可以重用这种能力，将指针传递给非托管代码。例如，FileEncryptionStatus API 函数以 32 位无符号位掩码的形式返回文件加密状态。该 API 按以下所示方式进行记录：

BOOL FileEncryptionStatus( LPCTSTR lpFileName, // file name LPDWORD lpStatus // encryption status );

请 注意，该函数并不使用它的返回值返回状态，而是返回一个 Boolean 值，指示调用是否成功。在成功的情况下，实际的状态值是通过第二个参数返回的。它的工作方式是调用程序向该函数传递指向一个 DWORD 变量的指针，而该 API 函数用状态值填充指向的内存位置。以下代码片段显示了一个调用非托管 FileEncryptionStatus 函数的可能外部方法定义：

[DllImport("Advapi32.dll", CharSet=CharSet.Auto)] static extern Boolean FileEncryptionStatus(String filename, out UInt32 status);

该 定义使用 out 关键字来为 UInt32 状态值指示 by-ref 参数。这里我也可以选择 ref 关键字，实际上在运行时会产生相同的机器码。out 关键字只是一个 by-ref 参数的规范，它向 C# 编译器指示所传递的数据只在被调用的函数外部传递。相反，如果使用 ref 关键字，则编译器会假定数据可以在被调用的函数的内部和外部传递。

托 管代码中 out 和 ref 参数的另一个很好的方面是，地址作为 by-ref 参数传递的变量可以是线程堆栈中的一个本地变量、一个类或结构的元素，也可以是具有合适数据类型的数组中的一个元素引用。调用程序的这种灵活性使得 by-ref 参数成为封送缓冲区指针以及单数值指针的一个很好的起点。只有在我发现 ref 或 out 参数不符合我的需要的情况下，我才会考虑将指针封送为更复杂的 CLR 类型（例如类或数组对象）。

如 果您不熟悉 C 语法或者调用 Windows API 函数，有时很难知道一个方法参数是否需要指针。一个常见的指示符是看参数类型是否是以字母 P 或 LP 开头的，例如 LPDWORD 或 PINT。在这两个例子中，LP 和 P 指示参数是一个指针，而它们指向的数据类型分别为 DWORD 或 INT。然而，在有些情况下，可以直接使用 C 语言语法中的星号 (*) 将 API 函数定义为指针。以下代码片段展示了这方面的示例：

void TakesAPointer(DWORD* pNum);

可以看到，上述函数的唯一一个参数是指向 DWORD 变量的指针。

当 通过 P/Invoke 封送指针时，ref 和 out 只用于托管代码中的值类型。当一个参数的 CLR 类型使用 struct 关键字定义时，可以认为该参数是一个值类型。Out 和 ref 用于封送指向这些数据类型的指针，因为通常值类型变量是对象或数据，而在托管代码中并没有对值类型的引用。相反，当封送引用类型对象时，并不需要 ref 和 out 关键字，因为变量已经是对象的引用了。

 

封送不透明 (Opaque) 指针：一种特殊情况

有时在 Windows API 中，方法传递或返回的指针是不透明的，这意味着该指针值从技术角度讲是一个指针，但代码却不直接使用它。相反，代码将该指针返回给 Windows 以便随后进行重用。

一个非常常见的例子就是句柄的概念。在 Windows 中，内部数据结构（从文件到屏幕上的按钮）在应用程序代码中都表示为句柄。句柄其实就是不透明的指针或有着指针宽度的数值，应用程序用它来表示内部的 OS 构造。

少数情况下，API 函数也将不透明指针定义为 PVOID 或 LPVOID 类型。在 Windows API 的定义中，这些类型意思就是说该指针没有类型。

当 一个不透明指针返回给您的应用程序（或者您的应用程序期望得到一个不透明指针）时，您应该将参数或返回值封送为 CLR 中的一种特殊类型 — System.IntPtr。当您使用 IntPtr 类型时，通常不使用 out 或 ref 参数，因为 IntPtr 意为直接持有指针。不过，如果您将一个指针封送为一个指针，则对 IntPtr 使用 by-ref 参数是合适的。

在 CLR 类型系统中，System.IntPtr 类型有一个特殊的属性。不像系统中的其他基类型，IntPtr 并没有固定的大小。相反，它在运行时的大小是依底层操作系统的正常指针大小而定的。这意味着在 32 位的 Windows 中，IntPtr 变量的宽度是 32 位的，而在 64 位的 Windows 中，实时编译器编译的代码会将 IntPtr 值看作 64 位的值。当在托管代码和非托管代码之间封送不透明指针时，这种自动调节大小的特点十分有用。

请记住，任何返回或接受句柄的 API 函数其实操作的就是不透明指针。您的代码应该将 Windows 中的句柄封送成 System.IntPtr 值。

您 可以在托管代码中将 IntPtr 值强制转换为 32 位或 64 位的整数值，或将后者强制转换为前者。然而，当使用 Windows API 函数时，因为指针应是不透明的，所以除了存储和传递给外部方法外，不能将它们另做它用。这种“只限存储和传递”规则的两个特例是当您需要向外部方法传递 null 指针值和需要比较 IntPtr 值与 null 值的情况。为了做到这一点，您不能将零强制转换为 System.IntPtr，而应该在 IntPtr 类型上使用 Int32.Zero 静态公共字段，以便获得用于比较或赋值的 null 值。

封送文本

在 编程时经常要对文本数据进行处理。文本为 interop 制造了一些麻烦，这有两个原因。首先，底层操作系统可能使用 Unicode 来表示字符串，也可能使用 ANSI。在极少数情况下，例如 MultiByteToWideChar API 函数的两个参数在字符集上是不一致的。

第 二个原因是，当需要进行 P/Invoke 时，要处理文本还需要特别了解到 C 和 CLR 处理文本的方式是不同的。在 C 中，字符串实际上只是一个字符值数组，通常以 null 作为结束符。大多数 Windows API 函数是按照以下条件处理字符串的：对于 ANSI，将其作为字符值数组；对于 Unicode，将其作为宽字符值数组。

幸运的是，CLR 被设计得相当灵活，当封送文本时问题得以轻松解决，而不用在意 Windows API 函数期望从您的应用程序得到的是什么。这里是一些需要记住的主要考虑事项：

• 是您的应用程序向 API 函数传递文本数据，还是 API 函数向您的应用程序返回字符串数据？或者二者兼有？

• 您的外部方法应该使用什么托管类型？

• API 函数期望得到的是什么格式的非托管字符串？

我 们首先解答最后一个问题。大多数 Windows API 函数都带有 LPTSTR 或 LPCTSTR 值。（从函数角度看）它们分别是可修改和不可修改的缓冲区，包含以 null 结束的字符数组。“C”代表常数，意味着使用该参数信息不会传递到函数外部。LPTSTR 中的“T”表明该参数可以是 Unicode 或 ANSI，取决于您选择的字符集和底层操作系统的字符集。因为在 Windows API 中大多数字符串参数都是这两种类型之一，所以只要在 DllImportAttribute 中选择 CharSet.Auto，CLR 就按默认的方式工作。

然 而，有些 API 函数或自定义的 DLL 函数采用不同的方式表示字符串。如果您要用到一个这样的函数，就可以采用 MarshalAsAttribute 修饰外部方法的字符串参数，并指明一种不同于默认 LPTSTR 的字符串格式。有关 MarshalAsAttribute 的更多信息，请参阅位于MarshalAsAttribute Class 的 Platform SDK 文档主题。

现 在让我们看一下字符串信息在您的代码和非托管函数之间传递的方向。有两种方式可以知道处理字符串时信息的传递方向。第一个也是最可靠的一个方法就是首先理 解参数的用途。例如，您正调用一个参数，它的名称类似 CreateMutex 并带有一个字符串，则可以想像该字符串信息是从应用程序向 API 函数传递的。同时，如果您调用 GetUserName，则该函数的名称表明字符串信息是从该函数向您的应用程序传递的。

除 了这种比较合理的方法外，第二种查找信息传递方向的方式就是查找 API 参数类型中的字母“C”。例如，GetUserName API 函数的第一个参数被定义为 LPTSTR 类型，它代表一个指向 Unicode 或 ANSI 字符串缓冲区的长指针。但是 CreateMutex 的名称参数被类型化为 LTCTSTR。请注意，这里的类型定义是一样的，但增加一个字母“C”来表明缓冲区为常数，API 函数不能写入。

一旦明确了文本参数是只用作输入还是用作输入/输出，就可以确定使用哪种 CLR 类型作为参数类型。这里有一些规则。如果字符串参数只用作输入，则使用 System.String 类型。在托管代码中，字符串是不变的，适合用于不会被本机 API 函数更改的缓冲区。

如 果字符串参数可以用作输入和/或输出，则使用 System.StringBuilder 类型。StringBuilder 类型是一个很有用的类库类型，它可以帮助您有效地构建字符串，也正好可以将缓冲区传递给本机函数，由本机函数为您填充字符串数据。一旦函数调用返回，您只 需要调用 StringBuilder 对象的 ToString 就可以得到一个 String 对象。

GetShortPathName API 函数能很好地用于显示什么时候使用 String、什么时候使用 StringBuilder，因为它只带有三个参数：一个输入字符串、一个输出字符串和一个指明输出缓冲区的字符长度的参数。

 

下 表列出了在 Win32 API（在 Wtypes.h 中列出）和 C 样式函数中使用的数据类型。许多非托管库包含将这些数据类型作为参数传递并返回值的函数。第三列列出了在托管代码中使用的相应的 .NET Framework 内置值类型或类。某些情况下，您可以用大小相同的类型替换此表中列出的类型

//c++:HANDLE(void   *)          ----    c#:System.IntPtr        
//c++:Byte(unsigned   char)     ----    c#:System.Byte         
//c++:SHORT(short)              ----    c#:System.Int16         
//c++:WORD(unsigned   short)    ----    c#:System.UInt16        
 //c++:INT(int)                 ----    c#:System.Int16        
//c++:INT(int)                  ----    c#:System.Int32         
//c++:UINT(unsigned   int)      ----    c#:System.UInt16        
//c++:UINT(unsigned   int)      ----    c#:System.UInt32        
//c++:LONG(long)                ----    c#:System.Int32         
//c++:ULONG(unsigned   long)    ----    c#:System.UInt32         
//c++:DWORD(unsigned   long)    ----    c#:System.UInt32         
//c++:DECIMAL                   ----    c#:System.Decimal         
//c++:BOOL(long)                ----    c#:System.Boolean         
//c++:CHAR(char)                ----    c#:System.Char         
//c++:LPSTR(char   *)           ----    c#:System.String         
//c++:LPWSTR(wchar_t   *)       ----    c#:System.String         
//c++:LPCSTR(const   char   *)  ----    c#:System.String         
//c++:LPCWSTR(const   wchar_t   *)      ----    c#:System.String         
//c++:PCAHR(char   *)   ----    c#:System.String         
//c++:BSTR              ----    c#:System.String         
//c++:FLOAT(float)      ----    c#:System.Single         
//c++:DOUBLE(double)    ----    c#:System.Double         
//c++:VARIANT           ----    c#:System.Object         
//c++:PBYTE(byte   *)   ----    c#:System.Byte[]         
//c++:BSTR      ----    c#:StringBuilder        
//c++:LPCTSTR   ----    c#:StringBuilder        
//c++:LPCTSTR   ----    c#:string        
//c++:LPTSTR    ----    c#:[MarshalAs(UnmanagedType.LPTStr)] string         
//c++:LPTSTR 输出变量名    ----    c#:StringBuilder 输出变量名        
//c++:LPCWSTR   ----    c#:IntPtr        
//c++:BOOL      ----    c#:bool           
//c++:HMODULE   ----    c#:IntPtr            
//c++:HINSTANCE ----    c#:IntPtr         
//c++:结构体    ----    c#:public struct 结构体{};         
//c++:结构体 **变量名   ----    c#:out 变量名   
//C#中提前申明一个结构体实例化后的变量名        
//c++:结构体 &变量名    ----    c#:ref 结构体 变量名                 
//c++:WORD      ----    c#:ushort        
//c++:DWORD     ----    c#:uint        
//c++:DWORD     ----    c#:int        
//c++:UCHAR     ----    c#:int        
//c++:UCHAR     ----    c#:byte        
//c++:UCHAR*    ----    c#:string        
//c++:UCHAR*    ----    c#:IntPtr        
//c++:GUID      ----    c#:Guid        
//c++:Handle    ----    c#:IntPtr        
//c++:HWND      ----    c#:IntPtr        
//c++:DWORD     ----    c#:int        
//c++:COLORREF  ----    c#:uint        
//c++:unsigned char     ----    c#:byte        
//c++:unsigned char *   ----    c#:ref byte        
//c++:unsigned char *   ----    c#:[MarshalAs(UnmanagedType.LPArray)] byte[]        
//c++:unsigned char *   ----    c#:[MarshalAs(UnmanagedType.LPArray)] Intptr        
//c++:unsigned char &   ----    c#:ref byte        
//c++:unsigned char 变量名      ----    c#:byte 变量名        
//c++:unsigned short 变量名     ----    c#:ushort 变量名        
//c++:unsigned int 变量名       ----    c#:uint 变量名        
//c++:unsigned long 变量名      ----    c#:ulong 变量名        
//c++:char 变量名       ----    c#:byte 变量名   
//C++中一个字符用一个字节表示,C#中一个字符用两个字节表示        
//c++:char 数组名[数组大小]     ----    c#:MarshalAs(UnmanagedType.ByValTStr, SizeConst = 数组大小)]        
public string 数组名; ushort        
//c++:char *            ----    c#:string       

//传入参数        
//c++:char *            ----    c#:StringBuilder
//传出参数        
//c++:char *变量名      ----    c#:ref string 变量名        

//c++:char *输入变量名  ----    c#:string 输入变量名        
//c++:char *输出变量名  ----    c#:[MarshalAs(UnmanagedType.LPStr)] StringBuilder 输出变量名        
//c++:char **           ----    c#:string        
//c++:char **变量名     ----    c#:ref string 变量名        
//c++:const char *      ----    c#:string        
//c++:char[]            ----    c#:string        
//c++:char 变量名[数组大小]     ----    c#:[MarshalAs(UnmanagedType.ByValTStr,SizeConst=数组大小)] public string 变量名;     

//c++:struct 结构体名 *变量名   ----    c#:ref 结构体名 变量名        

//c++:委托 变量名   ----    c#:委托 变量名        
//c++:int       ----    c#:int        
//c++:int       ----    c#:ref int        
//c++:int &     ----    c#:ref int        
//c++:int *     ----    c#:ref int      
//C#中调用前需定义int 变量名 = 0;        
//c++:*int      ----    c#:IntPtr        
//c++:int32 PIPTR *     ----    c#:int32[]        
//c++:float PIPTR *     ----    c#:float[]                
//c++:double** 数组名          ----    c#:ref double 数组名        
//c++:double*[] 数组名          ----    c#:ref double 数组名        
//c++:long          ----    c#:int        
//c++:ulong         ----    c#:int                
//c++:UINT8 *       ----    c#:ref byte       
//C#中调用前需定义byte 变量名 = new byte();                
//c++:handle    ----    c#:IntPtr        
//c++:hwnd      ----    c#:IntPtr                        
//c++:void *    ----    c#:IntPtr                
//c++:void * user_obj_param    ----    c#:IntPtr user_obj_param        
//c++:void * 对象名称    ----    c#:([MarshalAs(UnmanagedType.AsAny)]Object 对象名称                
//c++:char, INT8, SBYTE, CHAR                               ----    c#:System.SByte          
//c++:short, short int, INT16, SHORT                        ----    c#:System.Int16          
//c++:int, long, long int, INT32, LONG32, BOOL , INT        ----    c#:System.Int32          
//c++:__int64, INT64, LONGLONG                              ----    c#:System.Int64          
//c++:unsigned char, UINT8, UCHAR , BYTE                    ----    c#:System.Byte          
//c++:unsigned short, UINT16, USHORT, WORD, ATOM, WCHAR , __wchar_t             ----    c#:System.UInt16          

//c++:unsigned, unsigned int, UINT32, ULONG32, DWORD32, ULONG, DWORD, UINT      ----    c#:System.UInt32          

//c++:unsigned __int64, UINT64, DWORDLONG, ULONGLONG                            ----    c#:System.UInt64          

//c++:float, FLOAT                                                              ----    c#:System.Single          

//c++:double, long double, DOUBLE                                               ----    c#:System.Double          

//Win32 Types        ----  CLR Type                  
//Struct需要在C#里重新定义一个Struct        
//CallBack回调函数需要封装在一个委托里，delegate static extern int FunCallBack(string str);        
//unsigned char** ppImage替换成IntPtr ppImage        
//int& nWidth替换成ref int nWidth        
//int*, int&, 则都可用 ref int 对应        
//双针指类型参数，可以用 ref IntPtr        
//函数指针使用c++: typedef double (*fun_type1)(double); 对应 c#:public delegate double  fun_type1(double);        
//char* 的操作c++: char*; 对应 c#:StringBuilder;        
//c#中使用指针:在需要使用指针的地方 加 unsafe        

//unsigned   char对应public   byte        
/*         
* typedef void (*CALLBACKFUN1W)(wchar_t*, void* pArg);         
* typedef void (*CALLBACKFUN1A)(char*, void* pArg);         
* bool BIOPRINT_SENSOR_API dllFun1(CALLBACKFUN1 pCallbackFun1, void* pArg);         
* 调用方式为         
* [UnmanagedFunctionPointer(CallingConvention.Cdecl)]         
* public delegate void CallbackFunc1([MarshalAs(UnmanagedType.LPWStr)] StringBuilder strName, IntPtr pArg);         
*          
*          
*/