Dynamic Loading Made Simple

• Download dynamicloading_src - 686 B
• http://www.derek-bartram.co.uk/CIRIP/CIRIP_demo.zip

Introduction

Dynamic Loading is the process of loading code and using it at run time rather than at compile time. Why use it? Simple, dynamic loading makes the process of modifying a program and adding extra functionality later on easier (especially by third-party vendors). Furthermore it makes larger projects far more managable since each section of code functionality is seperate from each other. Many applications use this technique for implementation of plugins, e.g. Visual Studio and CIRIP (see demo link).

The included source shows how to load classes from dll files (dynamical link libraries) at runtime based upon a particular interface.

The Code

public static List<object> LoadAssemblies(String path, String interfaceName, bool recursive)
{
    List<object> output = new List<object>();

    String[] files = new String[0];
    if (recursive)
    {
        files = Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories);
    }
    else
    {
        files = Directory.GetFiles(path, "*.dll", SearchOption.TopDirectoryOnly);
    }

    foreach (String filename in files)
    {
        Console.WriteLine("Loading " + filename);
        try
        {
            Assembly assembly = Assembly.LoadFrom(filename);

            foreach (Type t in assembly.GetTypes())
            {
                if (t.IsClass && !t.IsAbstract && t.GetInterface(interfaceName) != null)
                {
                    output.Add(Activator.CreateInstance(t));
                }
            }
        }
        catch (Exception err)
        {
            Console.WriteLine("Loading fail:" + err.ToString());
        }
        finally
        {
            Console.WriteLine("Loading complete");
        }
    }

    return output;
}

The LoadAssemblies method loads in a single instance of each class implementing interfaceName in dll files found at the path (or in deeper folders if recursive = true is specified).

Using the Code

To use the code the following steps must be taken;

1. Create an application where dynamic loading support is required
2. Create a new class library (dll) with a copy of the interface all plugins will support
3. Create an explit link from the application to the interface library
4. Create new class libraries (dlls) containing classes which implement the interface
5. Add the included code into the application
6. During the load in period of the application call LoadAssemblies; using the path to the dlls & the fully qualified name of the interface (e.g. DNBSoft.InterfaceA).
7. Foreach of the returned objects (cast to the interface once returned as the List<object>) call the relevant methods to link the plugin to the application.

Points of Interest

Did you learn anything interesting/fun/annoying while writing the code? Did you do anything particularly clever or wild or zany? No and no, however plugin support is VERY useful, and once you get the hang of it you'll use it alot.

It's the way forward!!!

History

Version 1.0.0.0 - The one and only release