"Safe" Windows Module API Wrapper

Question

Recently I've been toying around with C# interop and the Vulkan API. Today I discovered the SafeHandle class and decided I'd try to wrap the Windows API calls that I depend upon; please see the code below and let me know if I've made any errors during the implementation process.

Code:

public static class Library
{
 [Flags]
 public enum LoadLibraryType : uint
 {
 NONE = 0x00000000,
 }
 [Flags]
 public enum ModuleHandleType : uint
 {
 NONE = 0x00000000,
 }
 public sealed class LoadLibrarySafeHandle : SafeHandleZeroIsInvalid
 {
 [DllImport("Kernel32.dll", BestFitMapping = false, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true, ThrowOnUnmappableChar = true)]
 private static extern bool FreeLibrary(IntPtr libraryHandle);
 [DllImport("Kernel32.dll", BestFitMapping = false, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true, ThrowOnUnmappableChar = true)]
 private static extern bool GetModuleHandleExW(ModuleHandleType moduleHandleType, [MarshalAs(UnmanagedType.LPWStr)] string libraryName, out IntPtr libraryHandle);
 [DllImport("Kernel32.dll", BestFitMapping = false, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true, ThrowOnUnmappableChar = true)]
 private static extern IntPtr GetProcAddress(IntPtr libraryHandle, [MarshalAs(UnmanagedType.LPStr)] string procedureName);
 [DllImport("Kernel32.dll", BestFitMapping = false, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true, ThrowOnUnmappableChar = true)]
 private static extern IntPtr LoadLibraryExW([MarshalAs(UnmanagedType.LPWStr)] string libraryName, IntPtr fileHandle, LoadLibraryType loadLibraryType);
 public static LoadLibrarySafeHandle New(IntPtr address) => new LoadLibrarySafeHandle(address);
 public static LoadLibrarySafeHandle New(string name, IntPtr fileHandle, LoadLibraryType loadLibraryType) {
 if (GetModuleHandleExW(ModuleHandleType.NONE, name, out IntPtr libraryHandle)) {
 return New(libraryHandle);
 }
 else {
 libraryHandle = LoadLibraryExW(name, fileHandle, loadLibraryType);
 if (IntPtr.Zero == libraryHandle) {
 throw new DllNotFoundException(message: $"unable to find a library named {name}", inner: Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()));
 }
 return New(libraryHandle);
 }
 }
 public static LoadLibrarySafeHandle New(string name) => New(name, IntPtr.Zero, LoadLibraryType.NONE);
 private LoadLibrarySafeHandle(IntPtr address) : base(true) {
 SetHandle(address);
 }
 [PrePrepareMethod]
 [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 protected override bool ReleaseHandle() => FreeLibrary(handle);
 public bool TryGetDelegateForFunctionPointer<TDelegate>(string functionName, out TDelegate functionDelegate) {
 var functionHandle = GetProcAddress(handle, functionName);
 if (IntPtr.Zero == functionHandle) {
 functionDelegate = default;
 return false;
 }
 else {
 functionDelegate = Marshal.GetDelegateForFunctionPointer<TDelegate>(functionHandle);
 }
 return true;
 }
 }
}

Usage:

class Program
{
 private delegate IntPtr vkGetInstanceProcAddr(IntPtr instance, IntPtr pName);
 static void Main(string[] args) {
 var vkDllHandle = Library.LoadLibrarySafeHandle.New("vulkan-1.dll");
 if (vkDllHandle.TryGetDelegateForFunctionPointer(nameof(vkGetInstanceProcAddr), out vkGetInstanceProcAddr vkGetInstanceProcAddrDelegate)) {
 // do something with vkGetInstanceProcAddrDelegate
 }
 }
}

References:

https://stackoverflow.com/questions/17562295/if-i-allocate-some-memory-with-allochglobal-do-i-have-to-free-it-with-freehglob

https://www.codeproject.com/Articles/29534/IDisposable-What-Your-Mother-Never-Told-You-About

Answer 1

Guidelines when dealing with P/Invoke

• move native methods to nested classes (Recommendation CA1060)
• define the libraries to import as constants const string Kernel32Lib = "Kernel32.dll"; -> [DllImport(Kernel32Lib)]

General guidelines

Avoid unnecessary code blocks.

if (IntPtr.Zero == functionHandle) {
 functionDelegate = default;
 return false;
}
else {
 functionDelegate = Marshal.GetDelegateForFunctionPointer<TDelegate>(functionHandle);
}
return true;

rewritten:

if (IntPtr.Zero == functionHandle) {
 functionDelegate = default;
 return false;
}
functionDelegate = Marshal.GetDelegateForFunctionPointer<TDelegate>(functionHandle);
return true;