大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。
Jetbrains全系列IDE稳定放心使用
从.NET平台调用Win32 API
Win32 API可以直接控制Microsoft Windows的核心，因为API（Application Programming Interface）本来就是微软留给我们直接控制Windows的接口。
一. 基础知识
Win32 API是C语言（注意，不是C++语言，尽管C语言是C++语言的子集）函数集。
1. Win32 API函数放在哪里？
Win32 API函数是Windows的核心，比如我们看到的窗体、按钮、对话框什么的，都是依靠Win32函数“画”在屏幕上的，由于这些控件（有时也称组件）都用于用户与Windows进行交互，所以控制这些控件的Win32 API函数称为“用户界面”函数（User Interface Win32 API），简称UI函数；还有一些函数，并不用于交互，比如管理当前系统正在运行的进程、硬件系统状态的监视等等……这些函数只有一套，但是可以被所有的Windows程序调用（只要这个程序的权限足够高），简而言之，API是为程序所共享的。为了达到所有程序能共享一套API的目的，Windows采用了“动态链接库”的办法。之所以叫“动态链接库”，是因为这样的函数库的调用方式是“随用随取”而不是像静态链接库那样“用不用都要带上”。
Win32 API函数是放在Windows系统的核心库文件中的，这些库在硬盘里的存储形式是.dll文件。我们常用到的dll文件是user32.dll和kernel32.dll两个文件。
这些dll文件是用C语言写的，源代码经C语言编译器编译之后，会以二进制可执行代码形式存放在这些dll文件中。为了能让程序使用这些函数，微软在发布每个新的操作系统的时候，也会放出这个系统的SDK，目前最新的是Win2003 SP1 SDK，据说Vista的马上就要放出来，而且已经把UI的API从核心库中分离出去以提高系统的稳定性了。SDK里有一些C语言的头文件（.h文件），这些文件里描述了核心dll文件里都有哪些Win32 API函数，在写程序的时候，把这些.h文件用#include”…..”指令包含进你的程序里，你就可以使用这些Win32 API了。
C#语言也使用dll动态链接库，不过这些dll都是.NET版本的，具有“自描述性”，也就是自己肚子里都有哪些函数都已经写在自己的metadata里了，不用再附加一个.h文件来说明。现在，我们已经找到了问题的关键点：如何用.NET平台上的C#语言来调用Win32平台上的dll文件。答案非常简单：使用DllImport特性。
二. 小试
using System;
using System.Runtime.InteropServices;
class Program
{
[DllImport(“User32.dll”)]
public static extern int MessageBox(int h, string m, string c, int type);
static int Main()
{
MessageBox(0, “Hello Win32 API”, “大爷”, 4);
Console.ReadLine();
return 0;
}
}
1. 要使用DllImport这个特性（特性也是一种类），必须使用这一句using System.Runtime.InteropServices;
，导入“运行时->交互服务”。喔~~~~运行时的交互服务不就是“动态链接”吗？感谢Microsoft！
2. 然后我们就可以制造一个DllImport类的实例，并把这个实例绑定在我们要使用的函数上了。“特性类”这种类非常怪——制造类实例的时候不使用MyClass mc = new MyClass();这种形式，而是使用[特性类(参数列表)]这种形式；特性类不能独立存在，一定要用作修饰其它目标上（本例是修饰后面的一个函数），不同的特性可以用来修饰类、函数、变量等等；特性类实例在被编译的时候也不产生可执行代码，而是被放进metadata里以备检索。总之，你记住特性类很怪就是了，想了解更多就查查MSDN，懒得查就先这么记——不懂惯性定律不影响你学骑自行车。[DllImport(“User32.dll”)]是说我们要使用的Win32 API函数在User32.dll这个文件里。问题又来了：我怎么知道那么多API函数都在哪个dll文件里呢？这个你可以在MSDN里查到，位置是Root->Win32 and COM Development->Development Guides->Windows API->Windows API->Windows API Reference->Functions by Category。打开这页，你会看到有很多API的分类，API全在这里了。打开一个分类，比如Dialog Box，在Functions段，你会看到很多具体的函数，其中就有上面用到的MessageBox函数，点击进入。你将打开MessageBox的详细解释和具体用法。在这一页的底部，你可以看到一个小表格，里面有一项“Minimum DLL Version user32.dll”就是说这个函数在user32.dll里。
3. 接下来就是我们的函数了。在C#里调用Win32函数有这么几个要点。第一：名字要与Win32 API的完全一样。第二：函数除了要有相应的DllImport类修饰外，还要声明成public static extern类型的。第三：函数的返回值和参数类型要与Win32 API完全一致！
从MSDN里摘出一张表来，是常用Win32数据类型与.NET平台数据类型的对应表：
Figure 2 Non-Pointer Data Types
Win32 Types
Specification
CLR Type
char, INT8, SBYTE, CHAR
8-bit signed integer
System.SByte
short, short int, INT16, SHORT
16-bit signed integer
System.Int16
int, long, long int, INT32, LONG32, BOOL, INT
32-bit signed integer
System.Int32
__int64, INT64, LONGLONG
64-bit signed integer
System.Int64
unsigned char, UINT8, UCHAR, BYTE
8-bit unsigned integer
System.Byte
unsigned short, UINT16, USHORT, WORD, ATOM, WCHAR, __wchar_t
16-bit unsigned integer
System.UInt16
unsigned, unsigned int, UINT32, ULONG32, DWORD32, ULONG, DWORD, UINT
32-bit unsigned integer
System.UInt32
unsigned __int64, UINT64, DWORDLONG, ULONGLONG
64-bit unsigned integer
System.UInt64
float, FLOAT
Single-precision floating point
System.Single
double, long double, DOUBLE
Double-precision floating point
System.Double
In Win32 this type is an integer with a specially assigned meaning; in contrast, the CLR provides a specific type devoted to this meaning.
有了这些东西，我们就能把一个Win32 API函数转成C#函数了。还拿MessageBox函数为例（看刚才给出的函数表），它的Win32原形如下：
int MessageBox( HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType );
函数名：MessageBox将保持不变。
返回值：int 将保持不变（无论是Win32还是C#，int都是32位整数）
参数表：H开头意味着是Handle，一般情况下Handld都是指针类型，Win32平台的指针类型是用32位来存储的，所以在C#里正好对应一个int整型。不过，既然是指针，就没有什么正负之分，32位都应该用来保存数值——这样一来，用uint（无符号32位整型）来对应Win32的H类型更合理。不过提醒大家一点，int是受C#和.NET CLR双重支持的，而uint只受C#支持而不受.NET CLR支持，所以，本例还是老老实实地使用了int型。
至于LPCTSTR是Long Pointer to Constant String的缩写，说白了就是——字符串。所以，用C#里的string类型就对了。
修饰符：要求有相应的DllImport和public static extern
经过上面一番折腾，Win32的MessageBox函数就包装成C#可以调用的函数了：
[DllImport(“User32.dll”)]
public static extern int MessageBox(int h, string m, string c, int type);
第一个：弹出的MessageBox的父窗口是谁。本例中没有，所以是0，也就是“空指针”。
第二个：MessageBox的内容。本例中是“Hello Win32 API”。
第三个：MessageBox的标题。
第四个：MessageBox上的按钮是什么，如果是0，那就只有一个OK；改成了4，这样就有两个按钮了。
.NET Framework是对Win32 API的良好封装，大部分Win32 API函数都已经封装在了.NET Framework类库的各个类里了。
一个例子
写程序用来控制用户登录，在登录之前，用户不能把鼠标移出登录窗体，因为要控制鼠标，调用Win32 API中与Cursor相关的函数,调用了Win32 API中的ClipCursor()这个函数，效果还不错。
.NET Framework类库，发现System.Windows.Forms.Cursor类的Clip属性就是专门做这个用的。
这个例子的目的就是要告诉大家：1.对类库的了解程序直接决定了你编程的效率和质量——用类库里的组件比我们“从轮子造起”要快得多、安全得多。2.不到万不得已，不要去直接调Win32 API函数——那是不安全的。
private void Form1_DoubleClick(object sender, EventArgs e)
{
Rectangle r = new Rectangle(this.Left, this.Top, this.Width, this.Height);
System.Windows.Forms.Cursor.Clip = r;
}
.NET Framework都为我们封装好了哪些Win32 API，OK，MSDN里有一篇文章，专门列出了这些。文章的名字是《Microsoft Win32 to Microsoft .NET Framework API Map》
========
C#可以直接调用的Win32API
以前整理的Win32 API，可以直接在C#中直接调用，在做WinForm时还是很有帮助的。以前用在一个多窗口界面中，当轮询窗口时，调用API会提高很多效率。
源码包含三个文件Win32API.cs，Enums.cs，Structs.cs分别如下
Win32API.cs
using System;
using System.Drawing;
using System.Runtime.InteropServices;
using Lordal.Window.Form.Lib.General;
using Lordal.Window.Form.Lib.Win32;
namespace Lordeo.Framework
{
/// <summary>
/// Windows API Functions
/// </summary>
public class Win32API
{
#region .ctor()
// No need to construct this object
private Win32API()
{
}
#endregion
#region Constans values
public const string TOOLBARCLASSNAME = “ToolbarWindow32”;
public const string REBARCLASSNAME = “ReBarWindow32”;
public const string PROGRESSBARCLASSNAME = “msctls_progress32”;
public const string SCROLLBAR = “SCROLLBAR”;
#endregion
#region CallBacks
public delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
#endregion
#region Kernel32.dll functions
[DllImport(“kernel32.dll”, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern int GetCurrentThreadId();
#endregion
#region Gdi32.dll functions
[DllImport(“gdi32.dll”)]
static public extern bool StretchBlt(IntPtr hDCDest, int XOriginDest, int YOriginDest, int WidthDest, int HeightDest,
IntPtr hDCSrc, int XOriginScr, int YOriginSrc, int WidthScr, int HeightScr, uint Rop);
[DllImport(“gdi32.dll”)]
static public extern IntPtr CreateCompatibleDC(IntPtr hDC);
[DllImport(“gdi32.dll”)]
static public extern IntPtr CreateCompatibleBitmap(IntPtr hDC, int Width, int Heigth);
[DllImport(“gdi32.dll”)]
static public extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
[DllImport(“gdi32.dll”)]
static public extern bool BitBlt(IntPtr hDCDest, int XOriginDest, int YOriginDest, int WidthDest, int HeightDest,
IntPtr hDCSrc, int XOriginScr, int YOriginSrc, uint Rop);
[DllImport(“gdi32.dll”)]
static public extern IntPtr DeleteDC(IntPtr hDC);
[DllImport(“gdi32.dll”)]
static public extern bool PatBlt(IntPtr hDC, int XLeft, int YLeft, int Width, int Height, uint Rop);
[DllImport(“gdi32.dll”)]
static public extern bool DeleteObject(IntPtr hObject);
[DllImport(“gdi32.dll”)]
static public extern uint GetPixel(IntPtr hDC, int XPos, int YPos);
[DllImport(“gdi32.dll”)]
static public extern int SetMapMode(IntPtr hDC, int fnMapMode);
[DllImport(“gdi32.dll”)]
static public extern int GetObjectType(IntPtr handle);
[DllImport(“gdi32”)]
public static extern IntPtr CreateDIBSection(IntPtr hdc, ref BITMAPINFO_FLAT bmi,
int iUsage, ref int ppvBits, IntPtr hSection, int dwOffset);
[DllImport(“gdi32”)]
public static extern int GetDIBits(IntPtr hDC, IntPtr hbm, int StartScan, int ScanLines, int lpBits, BITMAPINFOHEADER bmi, int usage);
[DllImport(“gdi32”)]
public static extern int GetDIBits(IntPtr hdc, IntPtr hbm, int StartScan, int ScanLines, int lpBits, ref BITMAPINFO_FLAT bmi, int usage);
[DllImport(“gdi32”)]
public static extern IntPtr GetPaletteEntries(IntPtr hpal, int iStartIndex, int nEntries, byte[] lppe);
[DllImport(“gdi32”)]
public static extern IntPtr GetSystemPaletteEntries(IntPtr hdc, int iStartIndex, int nEntries, byte[] lppe);
[DllImport(“gdi32”)]
public static extern uint SetDCBrushColor(IntPtr hdc, uint crColor);
[DllImport(“gdi32”)]
public static extern IntPtr CreateSolidBrush(uint crColor);
[DllImport(“gdi32”)]
public static extern int SetBkMode(IntPtr hDC, BackgroundMode mode);
[DllImport(“gdi32”)]
public static extern int SetViewportOrgEx(IntPtr hdc, int x, int y, int param);
[DllImport(“gdi32”)]
public static extern uint SetTextColor(IntPtr hDC, uint colorRef);
[DllImport(“gdi32”)]
public static extern int SetStretchBltMode(IntPtr hDC, int StrechMode);
#endregion
#region Uxtheme.dll functions
[DllImport(“uxtheme.dll”)]
static public extern int SetWindowTheme(IntPtr hWnd, string AppID, string ClassID);
#endregion
#region User32.dll functions
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr GetDC(IntPtr hWnd);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern IntPtr GetDesktopWindow();
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool ShowWindow(IntPtr hWnd, short State);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool UpdateWindow(IntPtr hWnd);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool SetForegroundWindow(IntPtr hWnd);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int Width, int Height, uint flags);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool OpenClipboard(IntPtr hWndNewOwner);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool CloseClipboard();
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool EmptyClipboard();
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern IntPtr SetClipboardData(uint Format, IntPtr hData);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern bool GetMenuItemRect(IntPtr hWnd, IntPtr hMenu, uint Item, ref RECT rc);
[DllImport(“user32.dll”, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern IntPtr GetParent(IntPtr hWnd);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int SendMessage(IntPtr hWnd, int msg, int wParam, int lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr SendMessage(IntPtr hWnd, int msg, int wParam, IntPtr lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern void SendMessage(IntPtr hWnd, int msg, int wParam, ref RECT lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int SendMessage(IntPtr hWnd, int msg, int wParam, ref POINT lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern void SendMessage(IntPtr hWnd, int msg, int wParam, ref TBBUTTON lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern void SendMessage(IntPtr hWnd, int msg, int wParam, ref TBBUTTONINFO lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int SendMessage(IntPtr hWnd, int msg, int wParam, ref REBARBANDINFO lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern void SendMessage(IntPtr hWnd, int msg, int wParam, ref TVITEM lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern void SendMessage(IntPtr hWnd, int msg, int wParam, ref LVITEM lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern void SendMessage(IntPtr hWnd, int msg, int wParam, ref HDITEM lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern void SendMessage(IntPtr hWnd, int msg, int wParam, ref HD_HITTESTINFO hti);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr PostMessage(IntPtr hWnd, int msg, int wParam, int lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr SetWindowsHookEx(int hookid, HookProc pfnhook, IntPtr hinst, int threadid);
[DllImport(“user32.dll”, CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern bool UnhookWindowsHookEx(IntPtr hhook);
[DllImport(“user32.dll”, CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern IntPtr CallNextHookEx(IntPtr hhook, int code, IntPtr wparam, IntPtr lparam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr SetFocus(IntPtr hWnd);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public extern static int DrawText(IntPtr hdc, string lpString, int nCount, ref RECT lpRect, int uFormat);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public extern static IntPtr SetParent(IntPtr hChild, IntPtr hParent);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public extern static IntPtr GetDlgItem(IntPtr hDlg, int nControlID);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public extern static int GetClientRect(IntPtr hWnd, ref RECT rc);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public extern static int InvalidateRect(IntPtr hWnd, IntPtr rect, int bErase);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool WaitMessage();
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool PeekMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax, uint wFlag);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool GetMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool TranslateMessage(ref MSG msg);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool DispatchMessage(ref MSG msg);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr LoadCursor(IntPtr hInstance, uint cursor);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr SetCursor(IntPtr hCursor);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr GetFocus();
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool ReleaseCapture();
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr BeginPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool EndPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref POINT pptDst, ref SIZE psize, IntPtr hdcSrc, ref POINT pprSrc, Int32 crKey, ref BLENDFUNCTION pblend, Int32 dwFlags);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool ClientToScreen(IntPtr hWnd, ref POINT pt);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool TrackMouseEvent(ref TRACKMOUSEEVENTS tme);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool redraw);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern ushort GetKeyState(int virtKey);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern bool MoveWindow(IntPtr hWnd, int x, int y, int width, int height, bool repaint);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern int GetClassName(IntPtr hWnd, out STRINGBUFFER ClassName, int nMaxCount);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr GetDCEx(IntPtr hWnd, IntPtr hRegion, uint flags);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern IntPtr GetWindowDC(IntPtr hWnd);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern int FillRect(IntPtr hDC, ref RECT rect, IntPtr hBrush);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern int GetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT wp);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern int SetWindowText(IntPtr hWnd, string text);
[DllImport(“User32.dll”, CharSet = CharSet.Auto)]
public static extern int GetWindowText(IntPtr hWnd, out STRINGBUFFER text, int maxCount);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern int SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern IntPtr SetClipboardViewer(IntPtr hWndNewViewer);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern int ChangeClipboardChain(IntPtr hWndRemove, IntPtr hWndNewNext);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern int GetSystemMetrics(int nIndex);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern int SetScrollInfo(IntPtr hwnd, int bar, ref SCROLLINFO si, int fRedraw);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int ShowScrollBar(IntPtr hWnd, int bar, int show);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int EnableScrollBar(IntPtr hWnd, uint flags, uint arrows);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int BringWindowToTop(IntPtr hWnd);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int GetScrollInfo(IntPtr hwnd, int bar, ref SCROLLINFO si);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static public extern int ScrollWindowEx(IntPtr hWnd, int dx, int dy,
ref RECT rcScroll, ref RECT rcClip, IntPtr UpdateRegion, ref RECT rcInvalidated, uint flags);
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
public static extern int IsWindow(IntPtr hWnd);
[DllImport(“user32”, CharSet = CharSet.Auto)]
public static extern int GetKeyboardState(byte[] pbKeyState);
[DllImport(“user32”)]
public static extern int ToAscii(int uVirtKey, //[in] Specifies the virtual-key code to be translated.
int uScanCode, // [in] Specifies the hardware scan code of the key to be translated. The high-order bit of this value is set if the key is up (not pressed).
byte[] lpbKeyState, // [in] Pointer to a 256-byte array that contains the current keyboard state. Each element (byte) in the array contains the state of one key. If the high-order bit of a byte is set, the key is down (pressed). The low bit, if set, indicates that the key is toggled on. In this function, only the toggle bit of the CAPS LOCK key is relevant. The toggle state of the NUM LOCK and SCROLL LOCK keys is ignored.
byte[] lpwTransKey, // [out] Pointer to the buffer that receives the translated character or characters.
int fuState); // [in] Specifies whether a menu is active. This parameter must be 1 if a menu is active, or 0 otherwise.
#endregion
#region Common Controls functions
[DllImport(“comctl32.dll”)]
public static extern bool InitCommonControlsEx(INITCOMMONCONTROLSEX icc);
[DllImport(“comctl32.dll”)]
public static extern bool InitCommonControls();
[DllImport(“comctl32.dll”, EntryPoint = “DllGetVersion”)]
public extern static int GetCommonControlDLLVersion(ref DLLVERSIONINFO dvi);
[DllImport(“comctl32.dll”)]
public static extern IntPtr ImageList_Create(int width, int height, uint flags, int count, int grow);
[DllImport(“comctl32.dll”)]
public static extern bool ImageList_Destroy(IntPtr handle);
[DllImport(“comctl32.dll”)]
public static extern int ImageList_Add(IntPtr imageHandle, IntPtr hBitmap, IntPtr hMask);
[DllImport(“comctl32.dll”)]
public static extern bool ImageList_Remove(IntPtr imageHandle, int index);
[DllImport(“comctl32.dll”)]
public static extern bool ImageList_BeginDrag(IntPtr imageHandle, int imageIndex, int xHotSpot, int yHotSpot);
[DllImport(“comctl32.dll”)]
public static extern bool ImageList_DragEnter(IntPtr hWndLock, int x, int y);
[DllImport(“comctl32.dll”)]
public static extern bool ImageList_DragMove(int x, int y);
[DllImport(“comctl32.dll”)]
public static extern bool ImageList_DragLeave(IntPtr hWndLock);
[DllImport(“comctl32.dll”)]
public static extern void ImageList_EndDrag();
#endregion
#region Win32 Macro-Like helpers
public static int GET_X_LPARAM(int lParam)
{
return (lParam & 0xffff);
}
public static int GET_Y_LPARAM(int lParam)
{
return (lParam >> 16);
}
public static Point GetPointFromLPARAM(int lParam)
{
return new Point(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
}
public static int LOW_ORDER(int param)
{
return (param & 0xffff);
}
public static int HIGH_ORDER(int param)
{
return (param >> 16);
}
#endregion
}
}
========
C# win32 API编程
C# 用户经常提出两个问题：“我为什么要另外编写代码来使用内置于 Windows 中的功能？在框架中为什么没有相应的内容可以为我完成这一任务？”当框架小组构建他们的 .NET 部分时，他们评估了为使 .NET 程序员可以使用 Win32 而需要完成的工作，结果发现 Win32 API 集非常庞大。他们没有足够的资源为所有 Win32 API 编写托管接口、加以测试并编写文档，因此只能优先处理最重要的部分。许多常用操作都有托管接口，但是还有许多完整的 Win32 部分没有托管接口。
平台调用 (P/Invoke) 是完成这一任务的最常用方法。要使用 P/Invoke，您可以编写一个描述如何调用函数的原型，然后运行时将使用此信息进行调用。另一种方法是使用 Managed Extensions to C++ 来包装函数，这部分内容将在以后的专栏中介绍。
要理解如何完成这一任务，最好的办法是通过示例。在某些示例中，我只给出了部分代码；完整的代码可以通过下载获得。
1.简单示例
在第一个示例中，我们将调用 Beep() API 来发出声音。首先，我需要为 Beep() 编写适当的定义。查看 MSDN 中的定义，我发现它具有以下原型：
BOOL Beep(
DWORD dwFreq, // 声音频率
DWORD dwDuration // 声音持续时间
);
要用 C# 来编写这一原型，需要将 Win32 类型转换成相应的 C# 类型。由于 DWORD 是 4 字节的整数，因此我们可以使用 int 或 uint 作为 C# 对应类型。由于 int 是 CLS 兼容类型（可以用于所有 .NET 语言），以此比 uint 更常用，并且在多数情况下，它们之间的区别并不重要。bool 类型与 BOOL 对应。现在我们可以用 C# 编写以下原型：
public static extern bool Beep(int frequency, int duration);
这是相当标准的定义，只不过我们使用了 extern 来指明该函数的实际代码在别处。此原型将告诉运行时如何调用函数；现在我们需要告诉它在何处找到该函数。
我们需要回顾一下 MSDN 中的代码。在参考信息中，我们发现 Beep() 是在 kernel32.lib 中定义的。这意味着运行时代码包含在 kernel32.dll 中。我们在原型中添加 DllImport 属性将这一信息告诉运行时：
[DllImport(“kernel32.dll”)]
这就是我们要做的全部工作。下面是一个完整的示例，它生成的随机声音在二十世纪六十年代的科幻电影中很常见。
using System;
using System.Runtime.InteropServices;
namespace Beep
{
class Class1
{
[DllImport(“kernel32.dll”)]
public static extern bool Beep(int frequency, int duration);
static void Main(string[] args)
{
Random random = new Random();
for (int i = 0; i < 10000; i++)
{
Beep(random.Next(10000), 100);
}
}
}
}
它的声响足以刺激任何听者！由于 DllImport 允许您调用 Win32 中的任何代码，因此就有可能调用恶意代码。所以您必须是完全受信任的用户，运行时才能进行 P/Invoke 调用。
2.枚举和常量
Beep() 可用于发出任意声音，但有时我们希望发出特定类型的声音，因此我们改用 MessageBeep()。MSDN 给出了以下原型：
BOOL MessageBeep(
UINT uType // 声音类型
);
这看起来很简单，但是从注释中可以发现两个有趣的事实。
首先，uType 参数实际上接受一组预先定义的常量。
其次，可能的参数值包括 -1，这意味着尽管它被定义为 uint 类型，但 int 会更加适合。
对于 uType 参数，使用 enum 类型是合乎情理的。MSDN 列出了已命名的常量，但没有就具体值给出任何提示。由于这一点，我们需要查看实际的 API。
如果您安装了 Visual Studio? 和 C++，则 Platform SDK 位于 \Program Files\Microsoft Visual Studio .NET\Vc7\PlatformSDK\Include 下。
为查找这些常量，我在该目录中执行了一个 findstr。
findstr “MB_ICONHAND” *.h
它确定了常量位于 winuser.h 中，然后我使用这些常量来创建我的 enum 和原型：
public enum BeepType
{
SimpleBeep = -1,
IconAsterisk = 0x00000040,
IconExclamation = 0x00000030,
IconHand = 0x00000010,
IconQuestion = 0x00000020,
Ok = 0x00000000,
}
[DllImport(“user32.dll”)]
public static extern bool MessageBeep(BeepType beepType);
现在我可以用下面的语句来调用它： MessageBeep(BeepType.IconQuestion);
处理结构
有时我需要确定我笔记本的电池状况。Win32 为此提供了电源管理函数。
搜索 MSDN 可以找到 GetSystemPowerStatus() 函数。
BOOL GetSystemPowerStatus(
LPSYSTEM_POWER_STATUS lpSystemPowerStatus
);
此函数包含指向某个结构的指针，我们尚未对此进行过处理。要处理结构，我们需要用 C# 定义结构。我们从非托管的定义开始：
typedef struct _SYSTEM_POWER_STATUS {
BYTE ACLineStatus;
BYTE BatteryFlag;
BYTE BatteryLifePercent;
BYTE Reserved1;
DWORD BatteryLifeTime;
DWORD BatteryFullLifeTime;
} SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS;
然后，通过用 C# 类型代替 C 类型来得到 C# 版本。
public struct SystemPowerStatus
{
public byte ACLineStatus;
public byte batteryFlag;
public byte batteryLifePercent;
public byte reserved1;
public int batteryLifeTime;
public int batteryFullLifeTime;
}
private void button1_Click(object sender, EventArgs e)
{
SystemPowerStatus powerStatus = new SystemPowerStatus();
GetSystemPowerStatus(ref powerStatus);
textBox1.Text = “供电状况：” + powerStatus.ACLineStatus.ToString() + “\r\n”+Environment.NewLine+”剩余时间：” + powerStatus.batteryLifeTime.ToString() + “\r\n”+Environment.NewLine+”电力剩余”+powerStatus.batteryLifePercent.ToString()+”%”;
}
这样，就可以方便地编写出 C# 原型：
[DllImport(“kernel32.dll”)]
public static extern bool GetSystemPowerStatus(ref SystemPowerStatus systemPowerStatus);
在此原型中，我们用“ref”指明将传递结构指针而不是结构值。这是处理通过指针传递的结构的一般方法。
此函数运行良好，但是最好将 ACLineStatus 和 batteryFlag 字段定义为 enum：
enum ACLineStatus: byte
{
Offline = 0,
Online = 1,
Unknown = 255,
}
enum BatteryFlag: byte
{
High = 1,
Low = 2,
Critical = 4,
Charging = 8,
NoSystemBattery = 128,
Unknown = 255,
}
C# <wbr>win32 <wbr>API编程
请注意，由于结构的字段是一些字节，因此我们使用 byte 作为该 enum 的基本类型。
3.字符串
虽然只有一种 .NET 字符串类型，但这种字符串类型在非托管应用中却有几项独特之处。可以使用具有内嵌字符数组的字符指针和结构，其中每个数组都需要正确的封送处理。
在 Win32 中还有两种不同的字符串表示：
ANSI
Unicode
最初的 Windows 使用单字节字符，这样可以节省存储空间，但在处理很多语言时都需要复杂的多字节编码。Windows NT? 出现后，它使用双字节的 Unicode 编码。为解决这一差别，Win32 API 采用了非常聪明的做法。它定义了 TCHAR 类型，该类型在 Win9x 平台上是单字节字符，在 WinNT 平台上是双字节 Unicode 字符。对于每个接受字符串或结构（其中包含字符数据）的函数，Win32 API 均定义了该结构的两种版本，用 A 后缀指明 Ansi 编码，用 W 指明 wide 编码（即 Unicode）。如果您将 C++ 程序编译为单字节，会获得 A 变体，如果编译为 Unicode，则获得 W 变体。Win9x 平台包含 Ansi 版本，而 WinNT 平台则包含 W 版本。
由于 P/Invoke 的设计者不想让您为所在的平台操心，因此他们提供了内置的支持来自动使用 A 或 W 版本。如果您调用的函数不存在，互操作层将为您查找并使用 A 或 W 版本。
通过示例能够很好地说明字符串支持的一些精妙之处。
4.简单字符串
下面是一个接受字符串参数的函数的简单示例：
BOOL GetDiskFreeSpace(
LPCTSTR lpRootPathName, // 根路径
LPDWORD lpSectorsPerCluster, // 每个簇的扇区数
LPDWORD lpBytesPerSector, // 每个扇区的字节数
LPDWORD lpNumberOfFreeClusters, // 可用的扇区数
LPDWORD lpTotalNumberOfClusters // 扇区总数
);
根路径定义为 LPCTSTR。这是独立于平台的字符串指针。
由于不存在名为 GetDiskFreeSpace() 的函数，封送拆收器将自动查找“A”或“W”变体，并调用相应的函数。我们使用一个属性来告诉封送拆收器，API 所要求的字符串类型。
以下是该函数的完整定义，就象我开始定义的那样：
[DllImport(“kernel32.dll”)]
static extern bool GetDiskFreeSpace([MarshalAs(UnmanagedType.LPTStr)]
string rootPathName,ref int sectorsPerCluster,ref int bytesPerSector,
ref int numberOfFreeClusters,ref int totalNumberOfClusters);
不幸的是，当我试图运行时，该函数不能执行。问题在于，无论我们在哪个平台上，封送拆收器在默认情况下都试图查找 API 的 Ansi 版本，由于 LPTStr 意味着在 Windows NT 平台上会使用 Unicode 字符串，因此试图用 Unicode 字符串来调用 Ansi 函数就会失败。
有两种方法可以解决这个问题：一种简单的方法是删除 MarshalAs 属性。如果这样做，将始终调用该函数的 A 版本，如果在您所涉及的所有平台上都有这种版本，这是个很好的方法。但是，这会降低代码的执行速度，因为封送拆收器要将 .NET 字符串从 Unicode 转换为多字节，然后调用函数的 A 版本（将字符串转换回 Unicode），最后调用函数的 W 版本。
要避免出现这种情况，您需要告诉封送拆收器，要它在 Win9x 平台上时查找 A 版本，而在 NT 平台上时查找 W 版本。要实现这一目的，可以将 CharSet 设置为 DllImport 属性的一部分：
[DllImport(“kernel32.dll”, CharSet = CharSet.Auto)]
private static extern bool GetDiskFreeSpace(
string rootPathName,
out int sectorsPerCluster,
out int bytesPerSector,
out int numberOfFreeClusters,
out int totalNumberOfClusters);
private void button1_Click(object sender, EventArgs e)
{
string root=@”F:\”;
int sectorsPerCluster, bytesPerSector, numberOfFreeClusters, totalNumberOfClusters;
GetDiskFreeSpace(root, out sectorsPerCluster, out bytesPerSector, out numberOfFreeClusters, out totalNumberOfClusters);
textBox1.Text = root+”\r\n”+”每个簇的扇区数:” + sectorsPerCluster + “\r\n” + “每个扇区的字节数:” + bytesPerSector + “\r\n” + “可用的扇区数:” + numberOfFreeClusters + “\r\n” + “扇区总数:” + totalNumberOfClusters;
}
C# <wbr>win32 <wbr>API编程
对于大多数 Win32 API，都可以对字符串类型设置 CharSet 属性并使用 LPTStr。但是，还有一些不采用 A/W 机制的函数，对于这些函数必须采取不同的方法。
5.字符串缓冲区
.NET 中的字符串类型是不可改变的类型，这意味着它的值将永远保持不变。对于要将字符串值复制到字符串缓冲区的函数，字符串将无效。这样做至少会破坏由封送拆收器在转换字符串时创建的临时缓冲区；严重时会破坏托管堆，而这通常会导致错误的发生。无论哪种情况都不可能获得正确的返回值。
要解决此问题，我们需要使用其他类型。StringBuilder 类型就是被设计为用作缓冲区的，我们将使用它来代替字符串。下面是一个示例：
[DllImport(“kernel32.dll”, CharSet = CharSet.Auto)]
public static extern int GetShortPathName([MarshalAs(UnmanagedType.LPTStr)]string path,
[MarshalAs(UnmanagedType.LPTStr)]StringBuilder shortPath,int shortPathLength);
使用此函数很简单：
StringBuilder shortPath = new StringBuilder(80);
int result = GetShortPathName(@”d:\test.jpg”, shortPath, shortPath.Capacity);
string s = shortPath.ToString();
请注意，StringBuilder 的 Capacity 传递的是缓冲区大小。
6.具有内嵌字符数组的结构
某些函数接受具有内嵌字符数组的结构。例如，GetTimeZoneInformation() 函数接受指向以下结构的针：
typedef struct _TIME_ZONE_INFORMATION {
LONG Bias;
WCHAR StandardName[ 32 ];
SYSTEMTIME StandardDate;
LONG StandardBias;
WCHAR DaylightName[ 32 ];
SYSTEMTIME DaylightDate;
LONG DaylightBias;
} TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION;
在 C# 中使用它需要有两种结构。一种是 SYSTEMTIME，它的设置很简单：
struct SystemTime
{
public short wYear;
public short wMonth;
public short wDayOfWeek;
public short wDay;
public short wHour;
public short wMinute;
public short wSecond;
public short wMilliseconds;
}
这里没有什么特别之处；另一种是 TimeZoneInformation，它的定义要复杂一些：
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
struct TimeZoneInformation
{
public int bias;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string standardName;
SystemTime standardDate;
public int standardBias;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string daylightName;
SystemTime daylightDate;
public int daylightBias;
}
此定义有两个重要的细节。第一个是 MarshalAs 属性：
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
查看 ByValTStr 的文档，我们发现该属性用于内嵌的字符数组；另一个是 SizeConst，它用于设置数组的大小。
我在第一次编写这段代码时，遇到了执行引擎错误。通常这意味着部分互操作覆盖了某些内存，表明结构的大小存在错误。我使用 Marshal.SizeOf() 来获取所使用的封送拆收器的大小，结果是 108 字节。我进一步进行了调查，很快回忆起用于互操作的默认字符类型是 Ansi 或单字节。而函数定义中的字符类型为 WCHAR，是双字节，因此导致了这一问题。
我通过添加 StructLayout 属性进行了更正。结构在默认情况下按顺序布局，这意味着所有字段都将以它们列出的顺序排列。CharSet 的值被设置为 Unicode，以便始终使用正确的字符类型。
经过这样处理后，该函数一切正常。您可能想知道我为什么不在此函数中使用 CharSet.Auto。这是因为，它也没有 A 和 W 变体，而始终使用 Unicode 字符串，因此我采用了上述方法编码。
7.具有回调的函数
当 Win32 函数需要返回多项数据时，通常都是通过回调机制来实现的。开发人员将函数指针传递给函数，然后针对每一项调用开发人员的函数。
在 C# 中没有函数指针，而是使用“委托”，在调用 Win32 函数时使用委托来代替函数指针。
EnumDesktops() 函数就是这类函数的一个示例：
BOOL EnumDesktops(
HWINSTA hwinsta, // 窗口实例的句柄
DESKTOPENUMPROC lpEnumFunc, // 回调函数
LPARAM lParam // 用于回调函数的值
);
HWINSTA 类型由 IntPtr 代替，而 LPARAM 由 int 代替。DESKTOPENUMPROC 所需的工作要多一些。下面是 MSDN 中的定义：
BOOL CALLBACK EnumDesktopProc(
LPTSTR lpszDesktop, // 桌面名称
LPARAM lParam // 用户定义的值
);
我们可以将它转换为以下委托：
delegate bool EnumDesktopProc([MarshalAs(UnmanagedType.LPTStr)] string desktopName,int lParam);
完成该定义后，我们可以为 EnumDesktops() 编写以下定义：
[DllImport(“user32.dll”, CharSet = CharSet.Auto)]
static extern bool EnumDesktops(IntPtr windowStation,EnumDesktopProc callback,int lParam);
这样该函数就可以正常运行了。
在互操作中使用委托时有个很重要的技巧：封送拆收器创建了指向委托的函数指针，该函数指针被传递给非托管函数。但是，封送拆收器无法确定非托管函数要使用函数指针做些什么，因此它假定函数指针只需在调用该函数时有效即可。
结果是如果您调用诸如 SetConsoleCtrlHandler() 这样的函数，其中的函数指针将被保存以便将来使用，您就需要确保在您的代码中引用委托。如果不这样做，函数可能表面上能执行，但在将来的内存回收处理中会删除委托，并且会出现错误。
8.其他高级函数
迄今为止我列出的示例都比较简单，但是还有很多更复杂的 Win32 函数。下面是一个示例：
DWORD SetEntriesInAcl(
ULONG cCountOfExplicitEntries, // 项数
PEXPLICIT_ACCESS pListOfExplicitEntries, // 缓冲区
PACL OldAcl, // 原始 ACL
PACL *NewAcl // 新 ACL
);
前两个参数的处理比较简单：ulong 很简单，并且可以使用 UnmanagedType.LPArray 来封送缓冲区。
但第三和第四个参数有一些问题。问题在于定义 ACL 的方式。ACL 结构仅定义了 ACL 标头，而缓冲区的其余部分由 ACE 组成。ACE 可以具有多种不同类型，并且这些不同类型的 ACE 的长度也不同。
如果您愿意为所有缓冲区分配空间，并且愿意使用不太安全的代码，则可以用 C# 进行处理。但工作量很大，并且程序非常难调试。而使用 C++ 处理此 API 就容易得多。
9.属性的其他选项
DLLImport 和 StructLayout 属性具有一些非常有用的选项，有助于 P/Invoke 的使用。下面列出了所有这些选项：
DLLImport
CallingConvention
您可以用它来告诉封送拆收器，函数使用了哪些调用约定。您可以将它设置为您的函数的调用约定。通常，如果此设置错误，代码将不能执行。但是，如果您的函数是 Cdecl 函数，并且使用 StdCall（默认）来调用该函数，那么函数能够执行，但函数参数不会从堆栈中删除，这会导致堆栈被填满。
CharSet
控制调用 A 变体还是调用 W 变体。
EntryPoint
此属性用于设置封送拆收器在 DLL 中查找的名称。设置此属性后，您可以将 C# 函数重新命名为任何名称。
ExactSpelling
将此属性设置为 true，封送拆收器将关闭 A 和 W 的查找特性。
PreserveSig
COM 互操作使得具有最终输出参数的函数看起来是由它返回的该值。此属性用于关闭这一特性。
SetLastError
确保调用 Win32 API SetLastError()，以便您找出发生的错误。
StructLayout
LayoutKind
结构在默认情况下按顺序布局，并且在多数情况下都适用。如果需要完全控制结构成员所放置的位置，可以使用 LayoutKind.Explicit，然后为每个结构成员添加 FieldOffset 属性。当您需要创建 union 时，通常需要这样做。
CharSet
控制 ByValTStr 成员的默认字符类型。
Pack
设置结构的压缩大小。它控制结构的排列方式。如果 C 结构采用了其他压缩方式，您可能需要设置此属性。
Size
设置结构大小。不常用；但是如果需要在结构末尾分配额外的空间，则可能会用到此属性。
从不同位置加载
您无法指定希望 DLLImport 在运行时从何处查找文件，但是可以利用一个技巧来达到这一目的。
DllImport 调用 LoadLibrary() 来完成它的工作。如果进程中已经加载了特定的 DLL，那么即使指定的加载路径不同，LoadLibrary() 也会成功。
这意味着如果直接调用 LoadLibrary()，您就可以从任何位置加载 DLL，然后 DllImport LoadLibrary() 将使用该 DLL。
由于这种行为，我们可以提前调用 LoadLibrary()，从而将您的调用指向其他 DLL。如果您在编写库，可以通过调用 GetModuleHandle() 来防止出现这种情况，以确保在首次调用 P/Invoke 之前没有加载该库。
P/Invoke 疑难解答
如果您的 P/Invoke 调用失败，通常是因为某些类型的定义不正确。以下是几个常见问题：
1.long != long。在 C++ 中，long 是 4 字节的整数，但在 C# 中，它是 8 字节的整数。
2.字符串类型设置不正确。
========
Win32 API与C#数据结构类型对应关系
1.Win32 API与C#数据结构类型对应关系表
API数据类型
类型描述
C#类型
API数据类型
类型描述
C#类型
WORD
16位无符号整数
ushort
CHAR
字符
char
LONG
32位无符号整数
int
DWORDLONG
64位长整数
long
DWORD
32位无符号整数
uint
HDC
设备描述表句柄
int
HANDLE
句柄,32位整数
int
HGDIOBJ
GDI对象句柄
int
UINT
32位无符号整数
uint
HINSTANCE
实例句柄
int
BOOL
32位布尔型整数
bool
HWM
窗口句柄
int
LPSTR
指向字符的32位指针
string
HPARAM
32位消息参数
int
LPCSTR
指向常字符的32位指针
String
LPARAM
32位消息参数
int
BYTE
字节
byte
WPARAM
32位消息参数
int
2.C# 数据类型
简单类型
描 述
示 例
sbyte
8-bit 有符号整数
sbyte val = 12;
short
16-bit 有符号整数
short val = 12;
int
32-bit有符号整数
int val = 12;
long
64-bit有符号整数
long val1 = 12; long val2 = 34L;
byte
8-bit无符号整数
byte val1 = 12; byte val2 = 34U;
ushort
16-bit 无符号整数
ushort val1 = 12; ushort val2 = 34U;
uint
32-bit 无符号整数
uint val1 = 12; uint val2 = 34U;
ulong
64-bit 无符号整数
ulong val1 = 12; ulong val2 = 34U; ulong val3 = 56L; ulong val4 = 78UL;
float
32-bit单精度浮点数
float val = 1.23F;
double
64-bit双精度浮点数
double val1 = 1.23; double val2 = 4.56D;
bool
布尔类型
bool val1 = true; bool val2 = false;
char
字符类型 ，Unicode编码
char val = ‘h’;
decimal
28个有效数字的128-bit十进制类型
decimal val = 1.23M;
3.Win32 API与C#数据结构类型对应关系
BOOL=System.Int32
BOOLEAN=System.Int32
BYTE=System.UInt16
CHAR=System.Int16
COLORREF=System.UInt32
DWORD=System.UInt32
DWORD32=System.UInt32
DWORD64=System.UInt64
FLOAT=System.Float
HACCEL=System.IntPtr
HANDLE=System.IntPtr
HBITMAP=System.IntPtr
HBRUSH=System.IntPtr
HCONV=System.IntPtr
HCONVLIST=System.IntPtr
HCURSOR=System.IntPtr
HDC=System.IntPtr
HDDEDATA=System.IntPtr
HDESK=System.IntPtr
HDROP=System.IntPtr
HDWP=System.IntPtr
HENHMETAFILE=System.IntPtr
HFILE=System.IntPtr
HFONT=System.IntPtr
HGDIOBJ=System.IntPtr
HGLOBAL=System.IntPtr
HHOOK=System.IntPtr
HICON=System.IntPtr
HIMAGELIST=System.IntPtr
HIMC=System.IntPtr
HINSTANCE=System.IntPtr
HKEY=System.IntPtr
HLOCAL=System.IntPtr
HMENU=System.IntPtr
HMETAFILE=System.IntPtr
HMODULE=System.IntPtr
HMONITOR=System.IntPtr
HPALETTE=System.IntPtr
HPEN=System.IntPtr
HRGN=System.IntPtr
HRSRC=System.IntPtr
HSZ=System.IntPtr
HWINSTA=System.IntPtr
HWND=System.IntPtr
INT=System.Int32
INT32=System.Int32
INT64=System.Int64
LONG=System.Int32
LONG32=System.Int32
LONG64=System.Int64
LONGLONG=System.Int64
LPARAM=System.IntPtr
LPBOOL=System.Int16[]
LPBYTE=System.UInt16[]
LPCOLORREF=System.UInt32[]
LPCSTR=System.String
LPCTSTR=System.String
LPCVOID=System.UInt32
LPCWSTR=System.String
LPDWORD=System.UInt32[]
LPHANDLE=System.UInt32
LPINT=System.Int32[]
LPLONG=System.Int32[]
LPSTR=System.String
LPTSTR=System.String
LPVOID=System.UInt32
LPWORD=System.Int32[]
LPWSTR=System.String
LRESULT=System.IntPtr
PBOOL=System.Int16[]
PBOOLEAN=System.Int16[]
PBYTE=System.UInt16[]
PCHAR=System.Char[]
PCSTR=System.String
PCTSTR=System.String
PCWCH=System.UInt32
PCWSTR=System.UInt32
PDWORD=System.Int32[]
PFLOAT=System.Float[]
PHANDLE=System.UInt32
PHKEY=System.UInt32
PINT=System.Int32[]
PLCID=System.UInt32
PLONG=System.Int32[]
PLUID=System.UInt32
PSHORT=System.Int16[]
PSTR=System.String
PTBYTE=System.Char[]
PTCHAR=System.Char[]
PTSTR=System.String
PUCHAR=System.Char[]
PUINT=System.UInt32[]
PULONG=System.UInt32[]
PUSHORT=System.UInt16[]
PVOID=System.UInt32
PWCHAR=System.Char[]
PWORD=System.Int16[]
PWSTR=System.String
REGSAM=System.UInt32
SC_HANDLE=System.IntPtr
SC_LOCK=System.IntPtr
SHORT=System.Int16
SIZE_T=System.UInt32
SSIZE_=System.UInt32
TBYTE=System.Char
TCHAR=System.Char
UCHAR=System.Byte
UINT=System.UInt32
UINT32=System.UInt32
UINT64=System.UInt64
ULONG=System.UInt32
ULONG32=System.UInt32
ULONG64=System.UInt64
ULONGLONG=System.UInt64
USHORT=System.UInt16
WORD=System.UInt16
WPARAM=System.IntPtr
========
C# SendMessage 操控_Click事件
using System.Runtime.InteropServices;
步骤2：导入Win32 API函数
[DllImport(“user32.dll”, EntryPoint = “SendMessage”)]
private static extern int SendMessage(IntPtr wnh, int msg, IntPtr wP, IntPtr IP);
步骤3：例子
private void toolStripButton2_Click(object sender, EventArgs e)
{
if (textBox1.Text != “”)
{
switch (MessageBox.Show(“即将清除数据，是否保存数据！”, “信息提示”, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning))
{
case DialogResult.Yes:
SendMessage(button1.Handle, 0xf5, (IntPtr)0, (IntPtr)0);
count_Ping_Number = 0;
label7.Text = “0米”;
break;
case DialogResult.No:
textBox1.Text = “”;
count_Ping_Number = 0;
label7.Text = “0米”;
break;
case DialogResult.Cancel:
break;
}
}
}
/
利用进程间通信：SendMessage(button1.Handle, 0xf5, (IntPtr)0, (IntPtr)0); 操作button1的_Click事件。
========
C#进程间通信,传递消息给其它窗口
目前，网上关于C#进程间通信的方法有很多种，但是总结起来它们不外乎从以下两个方面进行考虑:
一、在两个进程之间建立一个共同区域，其中一个进程改变这个区域的内容，而另一个进程则去读取它，反之亦 然。比如，可以让两个进程共享同一块内存，通过改变和读取内存中的内容进行通信；或者，创建一个文件，两个进程同时占用，甚至可以利用注册表或者剪贴板充当这个“共同区域”。
二、利用API函数去找到进程窗口的句柄，然后用API去控制这个窗口。例如，导入“User32.dll”中的FindWindow、FindWindowEx函数查找窗口，并获取窗口句柄，也可直接利用C#中的Process类来启动程序，并获取这个进程的主窗口的句柄，等等。
在编程时，我们往往需要选择一种即方便编写，效率又高的程序。第一种类型相对比较复杂，而且效率不高，相比来讲，第二种类型在不降低程序运行效率的情况下编写更简单。下面我就以一个示例程序来讲解如何使用Process类和API实现两个进程之间的传输数据。
第一步：
（1）打开VS2008，新建一个“windows 应用程序”，主窗口为Form1
（2）在Form1上添加一个标签label1，并为Form1添加KeyDown事件，当Form1接收到KewDown消息时，将接收到的数据显示在label1上。
public Form1()
{
InitializeComponent();
添加KeyDown事件///
KeyDown+=new KeyEventHandler(Form1_KeyDown);
}
/具体实现/
private void Form1_KeyDown(object sender, KeyEventArgs e)
{
this.label1.Text = Convert.ToString(e.KeyValue);
}
（3）编译运行，生成Form1.exe
第二步：
（1）打开VS2008，新建一个“windows 应用程序”，主窗口为Form2，并在Form2上添加三个按钮和一个文本 框，分别为button1,button2,button3,textbox1
（2）在Form2.cs中添加引用：
using System.Diagnostics;
using System.Runtime.InteropServices;
并导入Win32 API函数：
[DllImport(“User32.dll”, EntryPoint = “SendMessage”)]
private static extern int SendMessage(IntPtr wnd,int msg,IntPtr wP,IntPtr lP);
（3）在Form2类中定义以下两个变量
ProcessStartInfo psInfo = new ProcessStartInfo(@”..\..\..\Form1\bin\Debug\Form1.exe”);
Process pro = new Process();
（4）为Form2添加Load事件响应
private void Form1_Load(object sender, EventArgs e)
{
pro.StartInfo = psInfo ;
}
（5）为button1,button2,button3分别添加click事件响应，并添加响应内容：
Button1: pro.Start();
点击该按钮，启动Form1.exe程序
Button2: pro.Kill();
点击该按钮，退出From1.exe程序
Button3:
IntPtr hWnd = pro.MainWindowHandle; //获取Form1.exe主窗口句柄
int data = Convert.ToInt32(this.textBox1.Text); //获取文本框数据
SendMessage(hWnd, 0x0100, (IntPtr)data, (IntPtr)0); //发送WM_KEYDOWN消息
点击该按钮，以文本框数据为参数，向Form1发送WM_KEYDOWN消息
（6）编译运行，生成Form2.exe
第三步：
将Form1文件夹拷贝到与Form2同一目录下，启动Form2.exe：
点击button1按钮，则Form1.exe启动
点击button2按钮，则Form1.exe退出
在Form1.exe程序正在运行的情况下，在Form2窗口的文本框中输入任意数字并点击button3按钮，Form1窗口的label1即显示该数字。
以上只是简单的介绍了利用C#的Process类和Win32 API函数实现进程之间的数据传输，读者可以根据实际情况举一反三，编写功能更加强大的程序。
========
C#中如何调用WIN32 API
api 函数是构筑windws应用程序的基石，每一种windows应用程序开发工具，它提供的底层函数都间接或直接地调用了windows api函数，同时为了实现功能扩展，一般也都提供了调用windowsapi函数的接口， 也就是说具备调用动态连接库的能力。visual c#和其它开发工具一样也能够调用动态链接库的api函数。.net框架本身提供了这样一种服务,允许受管辖的代码调用动态链接库中实现的非受管辖函数, 包括操作系统提供的windows api函数。它能够定位和调用输出函数,根据需要，组织其各个参数(整型、字符串类型、数组、和结构等等)跨越互操作边界。
下面以c#为例简单介绍调用api的基本过程：
动态链接库函数的声明
动态链接库函数使用前必须声明，相对于vb,c#函数声明显得更加罗嗦，前者通过 api viewer粘贴以后，可以直接使用，而后者则需要对参数作些额外的变化工作。
动态链接库函数声明部分一般由下列两部分组成，一是函数名或索引号，二是动态链接库的文件名。
譬如，你想调用user32.dll中的messagebox函数，我们必须指明函数的名字messageboxa或messageboxw， 以及库名字 user32.dll,我们知道win32 api对每一个涉及字符串和字符的函数一般都存在两个版本，单字节字符的ansi版本和双字节字符的unicode版本。
下面是一个调用api函数的例子：
[dllimport(“kernel32.dll”, entrypoint=”movefilew”, setlasterror=true, charset=charset.unicode, exactspelling=true, callingconvention=callingconvention.stdcall)]
public static extern bool movefile(string src, string dst);
其中入口点entrypoint标识函数在动态链接库的入口位置，在一个受管辖的工程中，目标函数的原始名字和序号入口点不仅标识一个跨越互操 作界限的函数。而且，你还可以把这个入口点映射为一个不同的名字，也就是对函数进行重命名。重命名可以给调用函数带来种种便利，通过重命名，一方面我们不 用为函数的大小写伤透脑筋，同时它也可以保证与已有的命名规则保持一致，允许带有不同参数类型的函数共存，更重要的是它简化了对ansi和unicode 版本的调用。charset用于标识函数调用所采用的是unicode或是ansi版本，exactspelling＝false将告诉编译器,让编译器 决定使用 unicode或者是ansi版本。其它的参数请参考msdn在线帮助.
在c#中，你可以在entrypoint域通过名字和序号声明一个动态链接库函数，如果在方法定义中使用的函数名与dll入口点相同，你不需要在entrypoint域显示声明函数。否则，你必须使用下列属性格式指示一个名字和序号。
[dllimport(“dllname”, entrypoint=”functionname”)] [dllimport(“dllname”, entrypoint=”#123″)]
值得注意的是，你必须在数字序号前加“＃”
下面是一个用msgbox替换messagebox名字的例子：
using system.runtime.interopservices; public class win32
{
[dllimport(“user32.dll”, entrypoint=”messagebox”)]
public static extern int msgbox(int hwnd, string text, string caption, uint type);
}
许多受管辖的动态链接库函数期望你能够传递一个复杂的参数类型给函数，譬如一个用户定义的结构类型成员或者受管辖代码定义的一个类成员，这时你必须提供额外的信息格式化这个类型，以保持参数原有的布局和对齐。
c# 提供了一个structlayoutattribute类，通过它你可以定义自己的格式化类型，在受管辖代码中，格式化类型是一个用 structlayoutattribute说明的结构或类成员，通过它能够保证其内部成员预期的布局信息。布局的选项共有三种：
布局选项
描述
layoutkind.automatic
为了提高效率允许运行态对类型成员重新排序。
注意：永远不要使用这个选项来调用不受管辖的动态链接库函数。
layoutkind.explicit
对每个域按照fieldoffset属性对类型成员排序
layoutkind.sequential
对出现在受管辖类型定义地方的不受管辖内存 <http://product.it168.com/list/b/0205_1.shtml>中的类型成员进行排序。
传递结构成员
下面的例子说明如何在受管辖代码中定义一个点和矩形类型，并作为一个参数传递给user32.dll库中的ptinrect函数，
函数的不受管辖原型声明如下：
bool ptinrect(const rect *lprc, point pt);
注意你必须通过引用传递rect结构参数，因为函数需要一个rect的结构指针。
[c#] using system.runtime.interopservices;
[structlayout(layoutkind.sequential)]
public struct point { public int x; public int y; }
[structlayout(layoutkind.explicit]
public struct rect
{
[fieldoffset(0)] public int left;
[fieldoffset(4)] public int top;
[fieldoffset(8)] public int right;
[fieldoffset(12)] public int bottom;
}
class win32api
{
[dllimport(“user32.dll”)]
public static extern bool ptinrect(ref rect r, point p);
}
类似你可以调用getsysteminfo函数获得系统信息：
using system.runtime.interopservices;
[structlayout(layoutkind.sequential)]
public struct system_info
{
public uint dwoemid;
public uint dwpagesize;
public uint lpminimumapplicationaddress;
public uint lpmaximumapplicationaddress;
public uint dwactiveprocessormask;
public uint dwnumberofprocessors;
public uint dwprocessortype;
public uint dwallocationgranularity;
public uint dwprocessorlevel;
public uint dwprocessorrevision;
}
[dllimport(“kernel32”)]
static extern void getsysteminfo(ref system_info psi);
system_info psi = new system_info(); getsysteminfo(ref psi);
类成员的传递
同样只要类具有一个固定的类成员布局，你也可以传递一个类成员给一个不受管辖的动态链接库函数，下面的例子主要说明如何传递一个 sequential顺序定义的mysystemtime类给user32.dll的getsystemtime函数, 函数用c/c++调用规范如下:
void getsystemtime(systemtime* systemtime);
不像传值类型,类总是通过引用传递参数.
[c#]
[structlayout(layoutkind.sequential)]
public class mysystemtime
{
public ushort wyear;
public ushort wmonth;
public ushort wdayofweek;
public ushort wday;
public ushort whour;
public ushort wminute;
public ushort wsecond;
public ushort wmilliseconds;
}
class win32api
{
[dllimport(“user32.dll”)]
public static extern void getsystemtime(mysystemtime st);
}
回调函数的传递:
从受管辖的代码中调用大多数动态链接库函数,你只需创建一个受管辖的函数定义，然后调用它即可,这个过程非常直接。
如果一个动态链接库函数需要一个函数指针作为参数，你还需要做以下几步：
首先，你必须参考有关这个函数的文档，确定这个函数是否需要一个回调；第二，你必须在受管辖代码中创建一个回调函数；最后，你可以把指向这个函数的指针作为一个参数创递给dll函数,.
回调函数及其实现:
回调函数经常用在任务需要重复执行的场合,譬如用于枚举函数,譬如win32 api 中的enumfontfamilies(字体枚举), enumprinters(打印机 <http://print.it168.com/>), enumwindows (窗口枚举)函数. 下面以窗口枚举为例,谈谈如何通过调用 enumwindow 函数遍历系统中存在的所有窗口
分下面几个步骤:
1. 在实现调用前先参考函数的声明
bool enumwindows(wndenumproc lpenumfunc, lparmam iparam)
显然这个函数需要一个回调函数地址作为参数.
2. 创建一个受管辖的回调函数,这个例子声明为代表类型(delegate),也就是我们所说的回调,它带有两个参数hwnd和lparam,第一个参数是一个窗口句柄，第二个参数由应用程序定义，两个参数均为整形。
当这个回调函数返回一个非零值时，标示执行成功，零则暗示失败，这个例子总是返回true值，以便持续枚举。
3. 最后创建以代表对象(delegate)，并把它作为一个参数传递给enumwindows 函数，平台会自动地 把代表转化成函数能够识别的回调格式。
using system;
using system.runtime.interopservices;
public delegate bool callback(int hwnd, int lparam);
public class enumreportapp
{
[dllimport(“user32”)]
public static extern int enumwindows(callback x, int y);
public static void main()
{
callback mycallback = new callback(enumreportapp.report);
enumwindows(mycallback, 0);
}
public static bool report(int hwnd, int lparam)
{
console.write(“窗口句柄为”);
console.writeline(hwnd); return true;
}
}
指针类型参数传递：
在windows api函数调用时，大部分函数采用指针传递参数，对一个结构变量指针，我们除了使用上面的类和结构方法传递参数之外，我们有时还可以采用数组传递参数。
下面这个函数通过调用getusername获得用户名
bool getusername( lptstr lpbuffer, // 用户名缓冲区 lpdword nsize // 存放缓冲区大小的地址指针 );
[dllimport(“advapi32.dll”, entrypoint=”getcomputername”, exactspelling=false, setlasterror=true)]
static extern bool getcomputername ( [marshalas(unmanagedtype.lparray)] byte[] lpbuffer, [marshalas(unmanagedtype.lparray)] int32[] nsize );
这个函数接受两个参数，char * 和int *,因为你必须分配一个字符串缓冲区以接受字符串指针，你可以使用string类代替这个参
========
C#中调用WIN32的API
最近在学习C#中的GDI部分，本来尝试编写一个字幕控件（其实还是用label比较合适），但是发现控件中用GDI将整个控件粉刷貌似不行（应该是我水平不行），所以就去捣鼓了下WIN32的DLL，发现用API还真是件幸福的事（仅在WIN32平台上说）。回到C#，在C#中要在一个窗体（控件也是窗体），只要用
Graphics g=控件名.CreateGraphics();//这样就可以用g来在这个控件上画东西了。
但是如果我想不限范围，在整个屏幕上画，那么.NET就无能为力了。还好，我们有WIN32，我们可以用GetDC或者CreateDC来获得整个屏幕的设备驱动器句柄。用完之后别忘了用ReleaseDC或DeleteDC释放。
以下是C#中GetDC()和ReleaseDC()的声明方法
[System.Runtime.InteropServices.DllImport(“User32.dll”)]
static extern IntPtr GetDC(IntPtr Hwnd); //其在MSDN中原型为HDC GetDC(HWND hWnd),HDC和HWND都是驱动器句柄（长指针），在C#中只能用IntPtr代替了
[System.Runtime.InteropServices.DllImport(“User32.dll”)]
static extern int ReleaseDC( IntPtr hWnd, IntPtr hDC);
然后我们获得整个屏幕的设备驱动器句柄
Hdc = GetDC(IntPtr.Zero); //MSDN中说当传入指针为空时返回整个屏幕的设备驱动器句柄
嘿嘿，接下来我们就可以利用这个设备驱动器句柄来乱画东西了，不过在此之前我们先把这个C#不常见的东西转化为熟悉的Graphics。我们只要用
Graphics g = Graphics.FromHdc(Hdc);//这样就从设备驱动器句柄中获得了.NET只能的Graphics类。
得到了这些东西，剩下的就不用我多说了吧，这些来大家就可以在这个屏幕上爱怎么画就怎么画。不过画完之后记得调用ReleaseDC()来释放这个句柄（如果画完程序就结束那倒无所谓）。
ReleaseDC(IntPtr.Zero, Hdc); //这样这个屏幕的设备驱动器句柄就被释放了。
========
C#调用Win32 API如何处理指针类型的参数
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类型，表示函数的序号，我们可以这样分别定义：
[c-sharp] view plain copy print?
///<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#依靠自身的能力就能解决问题，希望对大家有帮助。
========
C# 使用封装的Win32API
微软.NET框架的类库功能强大，内容丰富，可以处理大部分的编程要求，但在一些场合下，.NET框架类库不提供支持，此时需要借助Win32API来实现了。
一般的小弟不推荐在.NET程序中使用Win32API,因为这样不符合.NET编程的安全框架，而且让程序绑定到特定的操作系统，因为未来你的.NET程序可能不在Win32操作系统下运行。
推荐归推荐，有时候要用还得用，在此说说.NET下使用Win32API，本人现在使用C#,因此在此只说说C#语言来使用Win32API。
在C#使用Win32API很方便，只需要从指定的DLL文件中导入函数声明即可。比如在某个类中写下
[System.Runtime.InteropServices.DllImport(“gdi32.dll”)]
public static extern int GetDeviceCaps(int hDC , int index );
此后程序就像调用静态函数一样调用这个API函数了。这有点类似VB中声明API了。
大家知道，Win32API是平面结构，将一个DLL中的API罗列出来，成百上千的API一字排开，好生壮观，可惜使用不方便，调用它们需要了解各个API入口和出口以及各个API之间的影响，而且一些API比较危险，需要小心调用，若在错误的时间使用错误的参数调用错误的API则可能导致系统资源泄漏，程序突然退出，甚至会伤害操作系统。
而.NET类库则是树状的立体结构，它使用了面向对象的编程结构，从而掩盖了很多细节，我们调用也方便，也很安全。
以前小弟为了调用API就是在到用的时候就声明API，或者作个模块，列出很多API声明供其他地方调用。经验告诉我，这种简单的用法不够好。于是小弟就开始使用C#的语法结构来封装API。
在此使用API函数GetDeviceCaps作例子，这个函数就是获得指定设备上下文的某些信息，参数为设备上下文句柄(hdc)和类型为DeviceCapsConst信息编号。这个设备上下文句柄是个比较重的句柄，严禁浪费，用完只后需要释放掉该句柄，但释放HDC并不简单，需要知道句柄的来源，当使用CreateDC获得的句柄则必须使用DeleteDC来释放。
对于比较重要的资源，比如句柄，文件，数据库连接等等，有个原则就是尽晚获得，尽早释放，因此需要尽量减少持有句柄的时间。
小弟定义了一个类DeviceCapsClass,用于封装GetDeviceCaps,在获得一个句柄时就立即多次调用GetDeviceCaps来获得所有的信息，然后保存到一个缓冲区中，然后立即释放句柄。并定义了方便的访问缓冲数据的接口。这样其他程序只需要实例化一个DeviceCapsClass，调用它的属性就可获得设备上下文信息而无需考虑细节。
其实这种做法.NET框架类库自己就这么搞，大家看看.NET类库的反编译结果，可以看到.NET类库中有很多就是Win32API的封装。相信大家已经这么做了或将来也这样做。
现列出DeviceCapsClass所有代码
[System.Runtime.InteropServices.DllImport(“gdi32.dll”, CharSet=System.Runtime.InteropServices.CharSet.Auto)]
private static extern int GetDeviceCaps(int hDC , int index );
[System.Runtime.InteropServices.DllImport(“User32.dll”, CharSet=System.Runtime.InteropServices.CharSet.Auto)]
private static extern int ReleaseDC(int hWnd, int hDC);
[System.Runtime.InteropServices.DllImport(“gdi32.dll”, CharSet=System.Runtime.InteropServices.CharSet.Auto)]
private static extern int CreateDC( string strDriver , string strDevice , int Output , int InitData );
[System.Runtime.InteropServices.DllImport(“gdi32.dll”, CharSet=System.Runtime.InteropServices.CharSet.Auto)]
private static extern int DeleteDC( int Hdc );
========
相关链接
http://blog.csdn.net/jiangxinyu/article/details/8088992
C#中调用WIN32API函数
http://blog.csdn.net/jiangxinyu/article/details/8098600
C#调用win32API画图函数示例
http://blog.csdn.net/jiangxinyu/article/details/8098291
C# 抽取exe和dll程序图标
========
相关的搜索主题
C#通过WIN32 API实现嵌入程序窗体
C#利用win32 Api 修改本地系统时间、获取硬盘序列号
c#使用win32api实现获取光标位置
C# Win32 API大全(无错版)
C#调用WIN32API系列二列举局网内共享打印机
C# 使用WIN32API获取打印机
详细讲解在C#中如何使用鼠标钩子
分享基于Win32 API的服务操作类
C#封装好的Win32API
========
发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/183081.html原文链接：https://javaforall.cn
【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛
【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...
