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 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 UIntPtr FbwfIsFilterEnabled(

static extern UIntPtr FbwfIsFilterEnabled(

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

  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)

     [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.

    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

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