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

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

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

   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(

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

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