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

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.

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

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

    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)

static extern UIntPtr FbwfIsFilterEnabled(

static extern UIntPtr FbwfIsFilterEnabled(

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,

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