How to prevent a DLL load until the first call to it?

Question

3.00/5 (2 votes)

See more:

Hi there...

I have a vb.net project referencing a DLL file, let us call it "mylib.DLL". Assume I have a code that works like this:

VB

A=ReadUserInput()
If A=0 Then
   Dim Result=CallMyDLLAndGetResult ' This is a call to a function inside mylib.DLL
   UpdateCalculation
End If

The project obviously referenced mylib.dll, and it works perfectly fine.

Now to the problem:

If I copy the project to another machine, without the dll, and run the code, and A is never zero, the program tries to load "mylib.DLL" even though it does not need it.

The question is: How can I prevent a DLL load until i need to run code inside it? Is there a directive that allows me to do so?

Yours sincerely

Posted 27-Sep-13 6:15am

mkaatr2

Add a Solution

Comments

[no name] 27-Sep-13 12:27pm

Is there some reason that you could not just dynamically load this DLL just prior to your code using it?

mkaatr2 27-Sep-13 12:37pm

If I want to do so, I will have to modify 4 different projects in the solution, and the work could take over a week.

2 solutions

Solution 1

You may use reflection to dynamic load your dll:
Reflection in .NET[^]

Posted 27-Sep-13 6:46am

Jean A Brandelero

Comments

Sergey Alexandrovich Kryukov 27-Sep-13 14:13pm

And?
—SA

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Accepted Answer · 2013-09-27T08:41:00

Formally, it sounds like a nonsense. There is no such concept as "call to a DLL". And, if you have a call to a DLL which is not loaded, this is not, by definition, a call.

However, something close to it may have real practical sense. For simplicity, let's assume that this is not just a DLL, but is a main module of some .NET assembly. If this is a native DLL, this is also possible, but as you did not mention what it is, let me do the assumption which makes the speculations easier. (We can later discuss native DLLs if on your request, if you are interested.)

So, you can have some "plug-in" interface which may or may not be implemented in some assembly, which is not yest loaded. But the interface is known by the implementing assembly and the host assembly (otherwise, how would you work with plug-ins?). Now, you can defer loading of the assembly before the call. To do that, add yet another implementation of the interface, in the host assembly.

Let's say:

C#

public interface IPlugin {
    void UpdateCalculations();
    void SomeOtherMethod();
    //...
}

On the host application:

C#

class PluginWrapper : IPlugin {

    IPlugin PluginImplementation;
    string pluginFile; // how you get it is up to you

    void IPlugin.UpdateCalculations() {
        if (PluginImplementation == null)
            PluginImplementation.LoadAndGetImplementation(pluginFile);
        PluginImplementation.UpdateCalculations();
    } //IPlugin.UpdateCalculations

    void IPlugin.SomeOtherMethod() {
        if (PluginImplementation == null)
            PluginImplementation.LoadAndGetImplementation(pluginFile);
        PluginImplementation.SomeOtherMethod();
    } //IPlugin.SomeOtherMethod

    // implementation of all other IPlugin members...

    IPlugin LoadAndGetImplementation(string pluginFile) {
        System.Reflection.Assembly assembly = System.Reflection.Assembly.LoadFrom(pluginFile);
        // using assembly, get types or use some other way to find implementing type
        // check up that IPlugin is really implemented
        // instantiate the type through reflection
        // cast the obtained instance of the implementing type to IPlugin
        // return the result
    } //LoadAndGetImplementation

    //...

} //class PluginWrapper

Sorry for writing it in C# — I only want to conduct the idea, and you should understand at least some C#, is you use .NET.
Also, I did not give you much detail on reflection operations as I'm not sure you want to work with .NET assemblies. If you clarify on what you want to do and ask me further questions, I'll answer.
If you want to load native (unmanaged) DLLs, you can do something similar, but then host-side "PluginWrapper" would have somewhat different interface than native DLL (which won't really export classes). You just wrap all DLL calls the way convenient for you.

—SA