Using MEF to load DLLs with embedded libraries

Question

I am currently writing an application suite with a plugin system that loads plugins at runtime using the MEF framework.

I have currently setup one of my top level WPF applications to embed it's referenced DLLs as embedded resources and load them at runtime using the method described here.

This works fine and I get my single file WPF application that runs fine.

However, another of my top level console applications uses the MEF framework to load plugins at runtime (the WPF application is fixed and includes the plugins explicitly). My plugins have several dependencies themselves on various libraries and the extensions folder that the console application loads the plugins from is littered with all the various library dlls.

I would like to embed the dependencies of each plugin within itself so that my extensions directory contains only the top level DLL files. The method that I have used above does not cater for this approach as the plugin component cannot find the required dependency as it is only the executing assembly that is being searched for these embedded resources.

My current OnResolveAssembly method looks like this:

public static Assembly OnResolveAssembly(object sender, ResolveEventArgs args)
{
    Assembly executingAssembly = Assembly.GetExecutingAssembly();
    var assemblyName = new AssemblyName(args.Name);

    string path = assemblyName.Name + ".dll";
    if (assemblyName.CultureInfo.Equals(CultureInfo.InvariantCulture) == false)
    {
        path = String.Format(@"{0}\{1}", assemblyName.CultureInfo, path);
    }

    using (Stream stream = executingAssembly.GetManifestResourceStream(path))
    {
        if (stream == null)
            return null;

        var assemblyRawBytes = new byte[stream.Length];
        stream.Read(assemblyRawBytes, 0, assemblyRawBytes.Length);

        return Assembly.Load(assemblyRawBytes);
    }
}

I'm thinking that the best way to proceed would be to add in functionality to keep track of all assemblies loaded in a list and once a new assembly has been loaded in this way, recursively do the same; load any embedded DLLs within those as you go. You can then add these DLLs to the list which will act as a cache.

Is there perhaps a better way to proceed with this?

Answer 1

I have implemented a very similar solution to yours and it works very fine for me. As you can see I keep track of already loaded assemblies in a _references dictionary.

In my case, I do not need to "eagerly" load all embedded dependencies in any recursive way, but rather my embedded assemblies do register themselves with the application host on-demand.

public static class ApplicationHost
{
    private static readonly Dictionary<string, Assembly> _references = new Dictionary<string, Assembly>();

    [STAThread]
    private static void Main()
    {
        AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => _references.ContainsKey(args.Name) ? _references[args.Name] : null;
        RegisterAssemblyAndEmbeddedDependencies();
        // continue application bootstrapping...
    }

    public static void RegisterAssemblyAndEmbeddedDependencies()
    {
        var assembly = Assembly.GetCallingAssembly();
        _references[assembly.FullName] = assembly;
        foreach (var resourceName in assembly.GetManifestResourceNames())
        {
            using (var resourceStream = assembly.GetManifestResourceStream(resourceName))
            {
                var rawAssembly = new byte[resourceStream.Length];
                resourceStream.Read(rawAssembly, 0, rawAssembly.Length);
                var reference = Assembly.Load(rawAssembly);
                _references[reference.FullName] = reference;
            }
        }
    }
}