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);

  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)

static extern object ObjectFromLresult(UIntPtr lResult,

Declare Auto Function ObjectFromLresult Lib "oleacc.dll" (ByVal lResult As UIntPtr, <MarshalAs(UnmanagedType.LPStruct)> ByVal refiid As Guid, ByVal wParam As IntPtr) As <MarshalAs(UnmanagedType.Interface)> Object

Shared Function ObjectFromLresult(ByVal lResult As UIntPtr, <MarshalAs(UnmanagedType.LPStruct)> ByVal refiid As Guid, ByVal wParam As IntPtr) As <MarshalAs(UnmanagedType.Interface)> Object

UIntPtr lRes;

if ( SendMessageTimeout(hWnd, nMsg, UIntPtr.Zero, IntPtr.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 hKey, string lpSubKey, uint dwReserved, string lpClass,

public UIntPtr HKEY_CLASSES_ROOT = (UIntPtr)0x80000000;

   UIntPtr hKey, string lpSubKey, uint ulOptions,

static extern int RegQueryValueEx( UIntPtr hkey, String lpValueName, IntPtr lpReserved, ref KeyType lpType, StringBuilder lpData, ref uint lpcbData );

     [In] UIntPtr hkProgid,

     [Out] out UIntPtr phkeyOut);

     UIntPtr.Zero, IntPtr.Zero);

            public UIntPtr     Reserved;

    private static extern MMRESULT midiInGetDevCaps(UIntPtr uDeviceID, ref MIDIINCAPS caps, uint cbMidiInCaps);

public static extern MMRESULT midiOutGetDevCaps(UIntPtr uDeviceID, ref MIDIOUTCAPS lpMidiOutCaps, uint cbMidiOutCaps);

        midiOutGetDevCaps((UIntPtr) x, out caps, (uint)Marshal.SizeOf(typeof(MIDIOUTCAPS)));

static extern bool PlaySound(string pszSound, UIntPtr hmod, uint fdwSound);

   ByVal hModule As UIntPtr, _

    PlaySound (strFileName, UIntPtr.Zero, (uint)(SoundFlags.SND_FILENAME | SoundFlags.SND_ASYNC));

     UIntPtr ip = UIntPtr.Zero;

     Dim ip As UIntPtr = UIntPtr.Zero

    static extern uint timeSetEvent(uint uDelay, uint uResolution, TimerCallback lpTimeProc, UIntPtr dwUser, uint fuEvent);

    delegate void TimerCallback(uint uTimerID, uint uMsg, UIntPtr dwUser, UIntPtr dw1, UIntPtr dw2);

        id = timeSetEvent(ms, 0, thisCB, UIntPtr.Zero, (uint)f);

    void CBFunc(uint uTimerID, uint uMsg, UIntPtr dwUser, UIntPtr dw1, UIntPtr dw2)

Delegate Sub waveInProc(<MarshalAs(UnmanagedType.I4)> ByVal hwi As Integer, ByVal uMsg As WIMMessages, ByVal dwInstance As UIntPtr, ByVal dwParam1 As UIntPtr, ByVal dwParam2 As UIntPtr)

    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.