[In] UIntPtr hkProgid,

     [Out] out UIntPtr phkeyOut);

     UIntPtr.Zero, IntPtr.Zero);

     UIntPtr dwData1,

     UIntPtr dwData2);

static extern bool DdeSetUserHandle(IntPtr hConv, uint id, UIntPtr hUser);

     UIntPtr Length = GlobalSize(ClipboardDataPointer);

   UIntPtr dwExtraInfo);

Private Shared Sub keybd_event(bVk As Byte, bScan As Byte, dwFlags As UInteger, dwExtraInfo As UIntPtr)

    static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);

        // I had some Compile errors until I Casted the final 0 to UIntPtr like this...

        keybd_event((byte)key, 0x45, KEYEVENTF_EXTENDEDKEY, (UIntPtr)0);

        keybd_event((byte)key, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, (UIntPtr)0);

   UIntPtr dwExtraInfo);

public static extern bool PostThreadMessage(uint threadId, uint msg, UIntPtr wParam, IntPtr lParam);

   UIntPtr wParam, IntPtr lParam);

    UIntPtr wParam,

    out UIntPtr lpdwResult);

static extern bool SendMessageCallback(IntPtr hWnd, uint Msg, UIntPtr wParam,

    IntPtr lParam, SendMessageDelegate lpCallBack, UIntPtr dwData);

delegate void SendMessageDelegate(IntPtr hWnd, uint uMsg, UIntPtr dwData, IntPtr lResult);

    UIntPtr wParam,

    out UIntPtr lpdwResult);

static extern bool SendNotifyMessage(IntPtr hWnd, uint Msg, UIntPtr wParam,

     ByVal wParam As UIntPtr, _

One usage of UIntPtr is to represent the platform-specific size_t type. e.g.

public static extern IntPtr MemCopy(byte[] dest, byte[] src, UIntPtr count);

    UIntPtr count = new UIntPtr(2u);

static extern int memcmp(byte[] b1, byte[] b2, UIntPtr count);

   private static extern int memcmp(byte[] b1, byte[] b2, UIntPtr count);

      return memcmp(b1, b2, new UIntPtr((uint)b1.Length)) == 0;

public static extern IntPtr memcpy(IntPtr dest, IntPtr src, UIntPtr count);

        memcpy(dstData.Scan0, srcData.Scan0, new UIntPtr((uint)height * (uint)srcData.Stride));

static extern IntPtr memmove(IntPtr dest, IntPtr src, UIntPtr count);

  out UIntPtr   SecurityDescriptorSize

    UIntPtr hKey);

Declare Function RegCloseKey Lib "advapi32.dll" (ByVal hKey As UIntPtr) As Integer

    UIntPtr hKey,

Declare Function RegDeleteKeyEx Lib "advapi32.dll" (hKey As UIntPtr, lpSubKey As String, samDesired As UInteger, Reserved As UInteger) As Integer

    UIntPtr hKey,

     UIntPtr hKey,

extern private static int RegEnumKeyEx(UIntPtr hkey,

    UIntPtr hKey,

    out UIntPtr hkResult);

- Changed IntPtr to UIntPtr: When invoking with IntPtr for the handles, you will run into an Overflow. UIntPtr is the right choice if you wish this to work correctly on 32 and 64 bit platforms.

public static UIntPtr HKEY_LOCAL_MACHINE = new UIntPtr(0x80000002u);

public static UIntPtr HKEY_CURRENT_USER  = new UIntPtr(0x80000001u);

private static string ReadRegKey(UIntPtr rootKey, string keyPath, string valueName)

    UIntPtr hKey,

    out UIntPtr hkResult);

- Changed IntPtr to UIntPtr: When invoking with IntPtr for the handles, you will run into an Overflow. UIntPtr is the right choice if you wish this to work correctly on 32 and 64 bit platforms.

public static UIntPtr HKEY_LOCAL_MACHINE = new UIntPtr(0x80000002u);

public static UIntPtr HKEY_CURRENT_USER  = new UIntPtr(0x80000001u);

private static string ReadRegKey(UIntPtr rootKey, string keyPath, string valueName)

    UIntPtr hKey,

    UIntPtr hKey,

private static string ReadRegKey(UIntPtr rootKey, string keyPath, string valueName)

    public static UIntPtr HKEY_LOCAL_MACHINE = new UIntPtr(0x80000002u);

        UIntPtr hKey = UIntPtr.Zero;

        if (hKey != UIntPtr.Zero)

    UIntPtr hKey,

    UIntPtr hKey,

private static string ReadRegKey(UIntPtr rootKey, string keyPath, string valueName)

    public static UIntPtr HKEY_LOCAL_MACHINE = new UIntPtr(0x80000002u);

        UIntPtr hKey = UIntPtr.Zero;

        if (hKey != UIntPtr.Zero)

     UIntPtr hKey,

        UIntPtr hKey = UIntPtr.Zero;

        if (hKey != UIntPtr.Zero)

   ref uint NumberOfPages, UIntPtr PageArray);

   IntPtr ExistingCompletionPort, UIntPtr CompletionKey,

   UIntPtr dwSize);

Shared Function FlushInstructionCache(hProcess As IntPtr, lpBaseAddress As IntPtr, dwSize As UIntPtr) As Boolean

   NumberOfPages, UIntPtr UserPfnArray);

      public UIntPtr dwActiveProcessorMask;

Private Function GetProcAddress(ByVal hModule As IntPtr, ByVal procName As String) As UIntPtr

   out UIntPtr lpProcessAffinityMask, out UIntPtr lpSystemAffinityMask);

   <Out> lpProcessAffinityMask As UIntPtr, <Out> lpSystemAffinityMask as UIntPtr) As Boolean

   lpNumberOfBytes, out UIntPtr lpCompletionKey, out IntPtr lpOverlapped,

   UIntPtr dwRegionSize, out IntPtr lpAddresses, ref UIntPtr lpdwCount,

static extern IntPtr GlobalAlloc(uint uFlags, UIntPtr dwBytes);

static extern IntPtr HeapAlloc(IntPtr hHeap, uint dwFlags, UIntPtr dwBytes);

Public Declare Function HeapAlloc Lib "kernel32" (ByVal hHeap As IntPtr, ByVal dwFlags As UInteger, ByVal dwBytes As UIntPtr) As IntPtr

static extern IntPtr HeapCreate(uint flOptions, UIntPtr dwInitialSize,

   UIntPtr dwMaximumSize);

    public UIntPtr MinimumWorkingSetSize;

    public UIntPtr MaximumWorkingSetSize;

    Public MinimumWorkingSetSize As UIntPtr

    Public MaximumWorkingSetSize As UIntPtr

    public UIntPtr ProcessMemoryLimit;

    public UIntPtr JobMemoryLimit;

    public UIntPtr PeakProcessMemoryUsed;

    public UIntPtr PeakJobMemoryUsed;

    Public ProcessMemoryLimit As UIntPtr

    Public JobMemoryLimit As UIntPtr

    Public PeakProcessMemoryUsed As UIntPtr

    Public PeakJobMemoryUsed As UIntPtr

static extern IntPtr LocalAlloc(uint uFlags, UIntPtr uBytes);

    IntPtr memPtr = LocalAlloc(LocalMemoryFlags.LPTR, new UIntPtr((uint)size));

   UIntPtr dwNumberOfBytesToMap, IntPtr lpBaseAddress);

   uint dwNumberOfBytesTransferred, UIntPtr dwCompletionKey,

   UIntPtr dwProcessAffinityMask);

UIntPtr affinityMask = new UIntPtr((uint)1);

static extern bool SetProcessWorkingSetSize(IntPtr hProcess, UIntPtr

   dwMinimumWorkingSetSize, UIntPtr dwMaximumWorkingSetSize);

static extern UIntPtr SetThreadAffinityMask(IntPtr hThread,

   UIntPtr dwThreadAffinityMask);

   IntPtr lpBaseAddress, [Out] byte [] lpBuffer, UIntPtr cbRead,

        UIntPtr ExceptionInformation;

   UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);

dwSize should be IntPtr or UIntPtr because the underlying type is SIZE_T and varies with the platform.

   UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);

    UIntPtr grfAccessPermissions;

    UIntPtr grfAccessMode;

    UIntPtr grfInheritance;

UIntPtr or IntPtr are needed because they change sizes according to platform. If you need to cast to / from, then must keep the size change in mind.

     internal UIntPtr dwAddress;

     internal UIntPtr th32HeapID;

    public UIntPtr dwExtraInfo;

        Public dwExtraInfo As UIntPtr

    public dwExtraInfo As UIntPtr

        internal UIntPtr dwExtraInfo;

    public UIntPtr dwMenuData;

        internal UIntPtr dwExtraInfo;

    public UIntPtr dwExtraInfo;

    Public dwExtraInfo As UIntPtr

    public UIntPtr Internal;

    public UIntPtr InternalHigh;  

  public UIntPtr UniqueProcessId;