private void Cleanup()
{
if (IsClosed)
{
return;
}
_isClosed = true;
if (IsInvalid)
{
return;
}
// Save last error from P/Invoke in case the implementation of
// ReleaseHandle trashes it (important because this ReleaseHandle could
// occur implicitly as part of unmarshaling another P/Invoke).
int lastError = PInvokeMarshal.GetLastWin32Error();
ReleaseHandle();
PInvokeMarshal.SetLastWin32Error(lastError);
GC.SuppressFinalize(this);
}
public static unsafe IntPtr AllocCoTaskMem(int cb)
{
return(PInvokeMarshal.AllocCoTaskMem(cb));
}
public static void FreeHGlobal(IntPtr hglobal)
{
PInvokeMarshal.FreeHGlobal(hglobal);
}
public static unsafe IntPtr AllocHGlobal(int cb)
{
return(PInvokeMarshal.AllocHGlobal(cb));
}
public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s)
{
return(PInvokeMarshal.SecureStringToCoTaskMemUnicode(s));
}
internal static void SetLastWin32Error(int errorCode)
{
PInvokeMarshal.SetLastWin32Error(errorCode);
}
public static void FreeBSTR(IntPtr ptr)
{
PInvokeMarshal.FreeBSTR(ptr);
}
public static unsafe String PtrToStringAnsi(IntPtr ptr, int len)
{
return(PInvokeMarshal.PtrToStringAnsi(ptr, len));
}
public static void SaveLastWin32Error()
{
PInvokeMarshal.SaveLastWin32Error();
}
public static IntPtr ReAllocHGlobal(IntPtr pv, IntPtr cb)
{
return(PInvokeMarshal.MemReAlloc(pv, cb));
}
public static IntPtr ReAllocCoTaskMem(IntPtr pv, int cb)
{
return(PInvokeMarshal.CoTaskMemReAlloc(pv, (IntPtr)cb));
}
public static IntPtr AllocHGlobal(IntPtr cb)
{
return(PInvokeMarshal.AllocHGlobal(cb));
}
public static void Copy(byte[] array, int startIndex, IntPtr destination, int length)
{
PInvokeMarshal.CopyToNative(array, startIndex, destination, length);
}
public static IntPtr SecureStringToBSTR(SecureString s)
{
return(PInvokeMarshal.SecureStringToBSTR(s));
}
public static void FreeCoTaskMem(IntPtr ptr)
{
PInvokeMarshal.FreeCoTaskMem(ptr);
}
public static void ClearLastWin32Error()
{
PInvokeMarshal.ClearLastWin32Error();
}
public static void Copy(IntPtr source, byte[] destination, int startIndex, int length)
{
PInvokeMarshal.CopyToManaged(source, destination, startIndex, length);
}
internal static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, Type t)
{
return(PInvokeMarshal.GetDelegateForFunctionPointer(ptr, t.TypeHandle));
}
internal static IntPtr AllocBSTR(int length)
{
return(PInvokeMarshal.AllocBSTR(length));
}
internal static IntPtr GetFunctionPointerForDelegateInternal(Delegate d)
{
return(PInvokeMarshal.GetFunctionPointerForDelegate(d));
}
public static int GetLastWin32Error()
{
return(PInvokeMarshal.GetLastWin32Error());
}
public static unsafe string PtrToStringUni(IntPtr ptr)
{
return(PInvokeMarshal.PtrToStringUni(ptr));
}
public static int GetHRForException(Exception?e)
{
return(PInvokeMarshal.GetHRForException(e));
}
public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s)
{
return(PInvokeMarshal.SecureStringToGlobalAllocUnicode(s));
}
