Easier way to handle unloading dlls?

It is my understanding that Unity will not unload a .dll once 'Preview' has been run, if you use [DllImport]. Following the linked post's suggestions I instead used Kernel.dll to load and unload my dll manually. That part works fine.

The issue is that my code needs to be compatible with Android as well so I can't very well link Kernel.dll to do manual loading and unloading. Once I deploy my app I know I can just use [DllImport] and things will work as expected but I need to retain the manual loading and unloading so that Unity's editor doesn't lock my .dll forcing me to close Unity when I need to recompile my C++ DLL.

The following code is the best way I could think of to handle DLL loading on different systems while still allowing me to dynamically load and unload my DLL. Is there an easier way?:

 using System;
 using System.Collections;
 using System.Runtime.InteropServices;

 using UnityEngine;
 public class Plugin {
 
 // Unity editor doesn't unload dlls after 'preview'
 #if UNITY_EDITOR
     static class NativeMethods
     {
         [DllImport("kernel32.dll")]
         public static extern IntPtr LoadLibrary(string dllToLoad);
     
         [DllImport("kernel32.dll")]
         public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
     
         [DllImport("kernel32.dll")]
         public static extern bool FreeLibrary(IntPtr hModule);
     }
     
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     private delegate IntPtr Delegate_New();
     
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     private delegate int Delegate_GetSize(IntPtr plugin);
                                               
     // Make sure that delegate instances are identical to the actual method being called
     Delegate_New plugin_new;
     Delegate_GetSize plugin_getsize;

     IntPtr? plugin_dll = null;
 
     void InitializeHooks(){
         plugin_dll = NativeMethods.LoadLibrary(@"..\Release\Plugin.DLL");
         
         IntPtr pAddressOfFunctionToCall = NativeMethods.GetProcAddress(plugin_dll.Value, "plugin_new");
         plugin_new = (Delegate_New)Marshal.GetDelegateForFunctionPointer(pAddressOfFunctionToCall,typeof(Delegate_New));
         
         pAddressOfFunctionToCall = NativeMethods.GetProcAddress(plugin_dll.Value, "plugin_getsize");
         plugin_getsize = (Delegate_GetSize)Marshal.GetDelegateForFunctionPointer(pAddressOfFunctionToCall,typeof(Delegate_GetSize));

         plugin_handle_ = plugin_new();
     }
     void CloseHooks(){
         if(plugin_dll == null){
             return;
         }
         bool result = NativeMethods.FreeLibrary(plugin_dll.Value);
         Console.WriteLine(result);
         
         plugin_dll = null;
     }
 #elif UNITY_ANDROID
     [DllImport("unityplugin")]
     public static IntPtr plugin_new();
 
     [DllImport("unityplugin")]
     public static int plugin_getsize(IntPtr plugin);
 
     void InitializeHooks(){plugin_handle_ = plugin_new();}
     void CloseHooks(){}
 #else
     [DllImport("unityplugin.dll")]
     public static IntPtr plugin_new();
 
     [DllImport("unityplugin.dll")]
     public static int plugin_getsize(IntPtr plugin);
 
     void InitializeHooks(){plugin_handle_ = plugin_new();}
     void CloseHooks(){}
 #endif
 IntPtr plugin_handle_;
 
 public Plugin(){
     Close();
 }
 
 /// <summary>
 /// Close this instance.
 /// </summary>
 public void Close(){
 
     CloseHooks();
 }
 
 /// <summary>
 /// Initialize this instance.
 /// </summary>
 public void Initialize(){
     InitializeHooks();    
 }

 /// <summary>
 /// Get size from dll.  Right now it'll be 42
 /// </summary>
 public int Size { 
     get {
         return plugin_getsize(plugin_handle_);
     }
 }
 }