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

    [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.FunctionPtr)] [In][Out] UIntPtr[] ddAddresses,

        UIntPtr CommitTotal;

        UIntPtr CommitLimit;

        UIntPtr CommitPeak;

        UIntPtr PhysicalTotal;

        UIntPtr PhysicalAvailable;

        UIntPtr SystemCache;

        UIntPtr KernelTotal;

        UIntPtr KernelPaged;

        UIntPtr KernelNonpaged;

        UIntPtr PageSize;

        public UIntPtr  CommitTotal;

        public UIntPtr CommitLimit;

        public UIntPtr CommitPeak;

        public UIntPtr PhysicalTotal;

        public UIntPtr PhysicalAvailable;

        public UIntPtr SystemCache;

        public UIntPtr KernelTotal;

        public UIntPtr KernelPaged;

        public UIntPtr KernelNonpaged;

        public UIntPtr PageSize;

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

static extern UIntPtr FbwfIsFilterEnabled(

static extern UIntPtr FbwfIsFilterEnabled(

            public UIntPtr     Reserved;

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)

    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;

    private UIntPtr  reserved;

        internal UIntPtr ve_valueptr;

  Dim reserved As UIntPtr

     [In] UIntPtr hkProgid,

     [Out] out UIntPtr phkeyOut);

     UIntPtr.Zero, IntPtr.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,

For pointer-sized entities such as handles, they must be defined such that they will be 32 bits on a 32-bit machine and 64 bits on a 64-bit machine. IntPtr (or UIntPtr) accomplishes this. The use of int will appear to be fine if you only run the code on a 32-bit machine, but will likely cause your application/component to crash as soon as it gets on a 64-bit machine.

   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