[System.String.Intern] is the closest thing, although an atom is different from a string.

static extern bool CloseHandle(IntPtr hObject);

Public Shared Function CloseHandle(ByVal hObject As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean

Declare Auto Function CloseHandle Lib "kernel32.dll" (ByVal hObject As IntPtr) As Boolean

Declare Function CloseHandle Lib "kernel32" Alias "CloseHandle" (ByVal hObject As Integer) As Integer

static def CloseHandle(hObject as IntPtr) as bool:

For .NET 2.0, consider using Microsoft.Win32.SafeHandles.SafeFileHandle instead. It can be used where IntPtr is used. If you use a SafeFileHandle, do not call CloseHandle as the CLR will close it for you (even if it's already closed).

      static extern unsafe bool CloseHandle(

CloseHandle(hMapFile)

    // so we want to use LayoutKind.Explicit to mimic it as closely

        CTRL_CLOSE_EVENT,

- Save the current buffer information so you can restore it when close it your buffer

  are.Close();

CloseHandle(myEventHandle);

NOTE: This class needs some changes. The CloseHandle call will destroy the event when the last handle is closed. This makes it hard for one application to "lock" the event while making another wait on it since this class is always closing the handle. An alternative that I found to work is to have the CreateEvent call in the constructor and implement IDisposable by moving the CloseHandle call to the Dispose method.

    static extern bool CloseHandle(IntPtr hObject);

        CloseHandle( _Handle );

        CloseHandle( _Handle );

        CloseHandle( _Handle );

        CloseHandle( _Handle );

        Win32API.CloseHandle(_hMMF);

        _fs.Close();

    internal static extern bool CloseHandle(IntPtr hFile);

        Win32API.CloseHandle(_hMMF);

        _fs.Close();

    internal static extern bool CloseHandle(IntPtr hFile);

            mutex.Close();

    ///         then call Close();

    private static extern bool CloseHandle(IntPtr handle);

        throw new ObjectDisposedException("NamedPipeStream", "The stream has already been closed");

        throw new ObjectDisposedException("NamedPipeStream", "The stream has already been closed");

    public override void Close()

        CloseHandle(_handle);

        throw new ObjectDisposedException("NamedPipeStream", "The stream has already been closed");

        sw.Close();

    private static extern bool CloseHandle([In] IntPtr hObject);

        CloseHandle(handleToSnapshot);

     FsctlOpBatchAckClosePending = (EFileDevice.FileSystem << 16) | (4 << 2) | EMethod.Buffered | (0 << 14),

     FsctlWriteUsnCloseRecord = (EFileDevice.FileSystem << 16) | (59 << 2) | EMethod.Neither | (0 << 14),

   Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Integer) As Integer

       CloseHandle(hdrive)

    DUPLICATE_CLOSE_SOURCE = (0x00000001),// Closes the source handle. This occurs regardless of any error status returned.

[System.String.IsInterned] is the closest thing, although an atom is different from a string.

static extern bool FindCloseChangeNotification(IntPtr hChangeHandle);

static extern bool FindCloseChangeNotification(IntPtr hChangeHandle);

    FindClose(hFile);

    FindClose(hFile);

    static extern bool FindVolumeClose(IntPtr hFindVolume);

        return FindVolumeClose(handle);

FindVolumeClose

   static extern bool CloseHandle(IntPtr hHandle);

            CloseHandle(ptrProcess);

        CloseHandle(handle);

        CloseHandle(handle);

    private static extern bool CloseHandle(

        if (ptr !=IntPtr.Zero && ptr.ToInt32() != INVALID_HANDLE_VALUE) CloseHandle(ptr);

const uint HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x00000002;

Console.WriteLine(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE);

    static extern bool CloseHandle(IntPtr hObject);

     static extern bool CloseHandle(IntPtr hObject);

     CloseHandle(hThread);

        CTRL_CLOSE_EVENT,

        ToolHelp.CloseHandle(heaplist_h);  

public static extern bool CloseHandle(IntPtr Object);

  CloseHandle (Job);

There is no need to call CloseProcess or to use a SafeHandle if you get the handle using GetCurrentProcess as it returns a pseudohandle.

    KillOnJobClose = 0x00002000,

  are.Close();

                CloseHandle(hHandle); //fair to leak if can't close

                CloseHandle(hHandle); //fair to leak if can't close

See also CloseHandle,

If you use the IntPtr version, use a try/finally block to ensure you call CloseHandle

        ) // using block ensures finalizer closes handle

    static extern bool CloseHandle(IntPtr hObject);

        CloseHandle(handle);

    CTRL_CLOSE_EVENT,  

   CTRL_CLOSE_EVENT

    DeleteOnClose = 0x04000000,

    ' Close The Stream

    oFile_Stream.Close()

     PROTECT_FROM_CLOSE = 2

        static extern bool CloseHandle(IntPtr hObject);

            CloseHandle(handle);

           CloseHandle(threadHandle);

           CloseHandle(threadHandle); // Don't forget close thread handle

  static extern bool CloseHandle(IntPtr hObject);

    CloseHandle(hfile);

             NativeMethods.CloseHandle(tokenHandle);

      internal static extern Boolean CloseHandle(IntPtr hObject);

    Private Function CloseHandle(ByVal hHandle As IntPtr) As Boolean

            CloseHandle(hToken)

    static extern bool CloseEventLog(IntPtr hEventLog);

           CloseEventLog(logHandle);

        // Make sure to close open handles

        CloseServiceHandle(svcHandle);

        CloseServiceHandle(scHandle);

        // Make sure to close open handles

        CloseServiceHandle(svcHandle);

        CloseServiceHandle(scHandle);

        // Ensure any open handle is closed.

            NativeMethods.CloseEventLog(hEventLog);

static extern bool CloseEventLog(IntPtr hEventLog);

Declare Function CloseEventLog Lib "advapi32.dll" (TODO) As TODO

public static extern bool CloseServiceHandle( IntPtr hSCObject );

    Private Shared Function CloseServiceHandle(ByVal serviceHandle As IntPtr) As Boolean

    Declare Function CloseServiceHandle Lib "advapi32.dll" (ByVal hSCObject As IntPtr) As Boolean

Handles returned from CreateService must be closed using this function, rather than the standard CloseHandle

         Interop.CloseServiceHandle (serviceHandle);

         Interop.CloseServiceHandle (serviceControlManagerHandle);

     internal static extern bool CloseServiceHandle (IntPtr hSCObject);

    Public Function CloseHandle(ByVal handle As IntPtr) As Boolean

    CloseHandle(processInfo.process)

    CloseHandle(processInfo.thread)

        public static extern bool CloseHandle(IntPtr handle);

            CloseHandle(processInfo.process);

            CloseHandle(processInfo.thread);

    CloseServiceHandle(serviceHandle)

    CloseHandle(scHandle)

        #region CloseServiceHandle

        static extern bool CloseServiceHandle( IntPtr hSCObject );

                    CloseServiceHandle( schSCManager );

                    // if you don't close this handle, Services control panel

                    CloseServiceHandle( schService );

             CloseServiceHandle( hService );

     CloseServiceHandle( handle );

           CloseServiceHandle(handle);

        fileStream.Close();

        CloseHandle(lngTokenHandle)

    bool bForceAppsClosed,

     <MarshalAs(UnmanagedType.Bool)> ByVal bForceAppsClosed As Boolean, _

    bool bForceAppsClosed,

     <MarshalAs(UnmanagedType.Bool)> ByVal bForceAppsClosed As Boolean, _