无法在C＃Project中重新加载C ++ dll

Question

I hope there is someone there that can help me with loading and reloading a C++ dll into a C# project.

I am loading a C++ dll into my project using a file picker and then copying it to a file called Process.dll. I then use this dll to do its thing and then later I need the ability to load a new dll and for it to do its thing.

So it goes like this:

1. User picks a dll
2. dll is copied to Processor.dll
3. make my Processor class which uses dll import to make use of the dll
4. Use the dll and call its various functions etc
5. Go back to 1.

I have 2 classes

1. ProcessTab - C# class that has the GUI and which calls the classes in ProcessPlugin
2. ProcessPlugin - C# class that calls the C++ classes, it uses dllImport etc

The code looks like this:

class ProcessorTab
{
    private void buttonLoadProcDll_Click(object sender, RoutedEventArgs e)
    {
        // Open dll and copy it to "\\Processor.dll"

        processorPlugIn = new ProcessorPlugIn(this);
        return;
    }

    private void DestroyProcessor_Click(object sender, RoutedEventArgs e)
    {
        processorPlugIn.UnloadModule("Processor.dll");
        processorPlugIn = null;
    }
}

class ProcessorPlugIn
{ 
    public const string PluginName = "Processor.dll";

    public LibraryInfo info;
    ErrorCode err;
    private IntPtr pRxClass;
    private IntPtr pTxClass;

    [DllImport("kernel32", SetLastError = true)]
    static extern bool FreeLibrary(IntPtr hModule);

    [System.Runtime.InteropServices.DllImportAttribute(PluginName, CallingConvention = CallingConvention.Cdecl)]
    public static extern ErrorCode VE_ProcessorPluginLib_Rx_API_Constructor(ref IntPtr pRx);

    [System.Runtime.InteropServices.DllImportAttribute(PluginName, CallingConvention = CallingConvention.Cdecl)]
    public static extern ErrorCode VE_ProcessorPluginLib_Rx_API_Destructor(ref IntPtr pRx);

    [System.Runtime.InteropServices.DllImportAttribute(PluginName, CallingConvention = CallingConvention.Cdecl)]
    public static extern ErrorCode VE_ProcessorPluginLib_Tx_API_Constructor(ref IntPtr pTx);

    [System.Runtime.InteropServices.DllImportAttribute(PluginName, CallingConvention = CallingConvention.Cdecl)]
    public static extern ErrorCode VE_ProcessorPluginLib_Tx_API_Destructor(ref IntPtr pTx);

    public ProcessorPlugIn(MainWindow mWindow)
    {
        pRxClass = new IntPtr();
        pTxClass = new IntPtr();

        if (VE_ProcessorPluginLib_Rx_API_Constructor(ref pRxClass) != ErrorCode.EC_OK) // ERROR HERE: AccessViolationException was unhandled
            MessageBox.Show("Error constructing Rx");

        if (VE_ProcessorPluginLib_Tx_API_Constructor(ref pTxClass) != ErrorCode.EC_OK)
            MessageBox.Show("Error constructing Tx");
    }

    public void UnloadModule(string moduleName)
    {
        if (VE_ProcessorPluginLib_Rx_API_Destructor(ref pRxClass) != ErrorCode.EC_OK)
            MessageBox.Show("Error destropying Rx");

        if (VE_ProcessorPluginLib_Tx_API_Destructor(ref pTxClass) != ErrorCode.EC_OK)
            MessageBox.Show("Error destropying Rx");

        foreach (ProcessModule mod in Process.GetCurrentProcess().Modules)
        {
            if (mod.ModuleName == moduleName)
            {
                FreeLibrary(mod.BaseAddress);
            }
        }
    }     
}

Everything works fine and i call the methods in the C++ dll and get the expected outputs etc, but when I try to destroy it and reload it I get an error AccessViolationException was unhandled as shown in the comments in the code.

Does anyone have any idea how I can solve this?

Many thanks in advance

Answer 1

P/Invoke is not meant to handle this case. It assumes the library never changes and I'm sure it doesn't expect you to call FreeLibrary on modules it imports.

If you want to use dlls dynamically , you'll have to manually do the equivalent of what P/Invoke does under the hood: use LoadLibrary / GetProcAddress :

private static class UnsafeNativeMethods
{
    [DllImport("kernel32", SetLastError=true, CharSet = CharSet.Ansi)]
    static extern IntPtr LoadLibrary([MarshalAs(UnmanagedType.LPStr)]string lpFileName);

    [DllImport("kernel32", CharSet=CharSet.Ansi, ExactSpelling=true, SetLastError=true)]
    static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

    [DllImport("kernel32", SetLastError=true)]
    static extern bool FreeLibrary(IntPtr hModule);
}

You use these like this:

• Define a delegate:

   [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate ErrorCode ProcessorFunction(ref IntPtr pRx); 

• Load the library:

   IntPtr hLib = UnsafeNativeMethods.LoadLibrary("Processor.dll"); 

• Get a delegate:

   IntPtr ctorPtr = UnsafeNativeMethods.GetProcAddress(hLib, "VE_ProcessorPluginLib_Rx_API_Constructor"); ProcessorFunction constructorFn = (ProcessorFunction)Marshal.GetDelegateForFunctionPointer(ctorPtr, typeof(ProcessorFunction)); 

• Call it:

   conctructorFn(ref pRxClass); 

• When you're done, free the library (best in a finally block, SafeHandle or something to ensure this step is done):

   UnsafeNativeMethods.FreeLibrary(hLib); 

• Then repeat all these steps for the second lib.

Obviously I can't test this because I don't have your libs, but it should put you on the right track.
I've left adding the failure checks for brevity but you definitely should add these.