Welcome to the Lounge

Kornfeld Eliyahu Peter wrote:

I found MEF very easy to utilize...

Marc Clifton wrote:

MEF

Marc Clifton wrote:

Maybe I'm missing something?

John Simmons / outlaw programmer wrote:

You can't really do either of those things with MEF

Dave Kreskowiak wrote:

I then went and found The Simple Plugins Framework[^] out on SourceForge (yeah, I know...) and found it did just about everything I needed out of the box, including ShadowCopy support and automatic AppDomain load and unload.

Dave Kreskowiak wrote:

The Simple Plugins Framework[^]

using SimplePlugins;
using SimplePlugins.Exceptions;

this.PluginLoader = new PluginLoader();

this.PluginLoader.AssemblyResolutionPaths.Add(Application.StartupPath);

this.PluginLoader.ShadowCopyEnabled = true;

//This event fires when PluginLoaderBase.Probe is complete.
this.PluginLoader.ProbeComplete += new PluginLoaderBase.ProbeCompleteEventHandler(PluginLoader_ProbeComplete);

//This event fires before PluginLoaderBase.Load creates the AppDomain object which will be used to load the plugin from the plugin assembly.
this.PluginLoader.PluginLoading += new PluginLoaderBase.PluginLoadingEventHandler(PluginLoader_PluginLoading);

//This event fires when PluginLoaderBase.Load completes loading the plugin from the plugin assembly.
this.PluginLoader.PluginLoaded += new PluginLoaderBase.PluginLoadedEventHandler(PluginLoader_PluginLoaded);

//This event fires when PluginLoaderBase.Load completes the execution and unloading of the loaded plugin
this.PluginLoader.PluginUnloaded += new PluginLoaderBase.PluginUnloadedEventHandler(PluginLoader_PluginUnloaded);

PluginInfoList pluginInfoList = this.PluginLoader.Probe("C:\plugins", SearchOption.AllDirectories);
for (int i = 0; i < pluginInfoList.Count; i++)
    lbPlugins.Items.Add(pluginInfoList[i]);

//Get the PluginInfo object selected by the user for execution.
PluginInfo template = (PluginInfo)lbPlugins.SelectedItem;
try
{
    //Create a PluginParameters object and add any parameters to be passed to the plugin
    PluginParameters args = new PluginParameters();
    args.Add("Param1", "The quick brown fox jumped over the lazy dog");
    args.Add("Param2", 100);
    args.Add("Param3", 7.321);

    //Tell the plugin loader to load and execute the plugin
    this.PluginLoader.Load(template.FileName, args);
}
catch (PluginException ex)
{
    Console.WriteException(ex);
}

void PluginLoader_PluginUnloaded(object sender, PluginLoaderBase.PluginUnloadedEventArgs e)
{
    //Check if the plugin was unloaded due to an exception
    //The PluginException class wraps any unhandled exception in a serializable wrapper.
    //The PluginException class also exposes all InnerExceptions of the actual exception through PluginException.InnerException as well
    //This makes sure that unhandled non-serializable exceptions do not cause unexpected AppDomain leaks in the main application.
    if (e.Results.UnhandledException != null)
        Console.WriteException("The plugin '" + e.Info.ToString() + "' was unloaded due to unhandled exception: " + e.Results.UnhandledException.ToString());
    else if (e.Results.ExecutionDenied)
    {
        //Plugins can be denied execution by the PluginLoader object according to the specified value in PluginBase.ExecutionMode property.
        //This checks which execution modes prevented the plugin from being executed.
        if (e.Info.ExecutionMode == PluginBase.ExecutionModes.AsynchronousExclusive || e.Info.ExecutionMode == PluginBase.ExecutionModes.SynchronousExclusive)
            Console.WriteInfo("The plugin '" + e.Info.ToString() + "' was unloaded since it is intended to be executed exclusively. Please make sure no other plugin is executing and try again.");
        else if (e.Info.ExecutionMode == PluginBase.ExecutionModes.AsynchronousSingleton || e.Info.ExecutionMode == PluginBase.ExecutionModes.SynchronousSingleton)
            Console.WriteInfo("The plugin '" + e.Info.ToString() + "' was unloaded since only one instance of it is intended to be executed at a time. Please make sure no other instance of the same plugin is executing and try again.");
        else
            Console.WriteInfo("The plugin '" + e.Info.ToString() + "' was unloaded.");
    }
    else
    {
        //Each plugin may return results in the form of a PluginParameters object exposed by the PluginLoaderBase.PluginUnloadedEventArgs.Results property
        //This object can be checked for values returned by the plugin like so,
        if (e.Results.Contains("ReturnValue"))
            Console.WriteInfo("The plugin '" + e.Info.ToString() + "' was unloaded successfully with the return value: " + Convert.ToString(e.Results.Get("ReturnValue")));
        else
            Console.WriteInfo("The plugin '" + e.Info.ToString() + "' was unloaded successfully");
    }
}

using SimplePlugins;
using SimplePlugins.Exceptions;

namespace SamplePluggableApp.SamplePlugin
{
    public class Plugin : PluginBase
    {
        public Plugin()
            : base()
        {
        }

        internal string Param1 { get; private set; }
        internal int Param2 { get; private set; }
        internal double Param3 { get; private set; }

        public override string FriendlyName
        {
            //The friendly name of the plugin. This will be used by default in PluginInfo.ToString()
            get { return "Sample Plugin"; }
        }

        public override ExecutionModes ExecutionMode
        {
            get { return ExecutionModes.AsynchronousMultiInstance; } //Tells Loader to allow loading of multiple instances asynchronously in seperate threads
            //ExecutionModes.AsynchronousExclusive - PluginLoaderBase object will execute plugin in a seperate thread only if no other plugins are running
            //ExecutionModes.AsynchronousMultiInstance - PluginLoaderBase object will execute plugin in a seperate thread and will allow multiple instances of the plugin to be executed simultaneously
            //ExecutionModes.AsynchronousSingleton - PluginLoaderBase object will execute plugin in a seperate thread and will allow only one instance of the plugin to be running at a time
            //ExecutionModes.SynchronousExclusive - PluginLoaderBase object will execute plugin in the same thread as the pluggable app only if no other plugins are running
            //ExecutionModes.SynchronousMultiInstance - PluginLoaderBase object will execute plugin in the same thread as the pluggable app and will allow multiple instances of the plugin to be executed simultaneously
            //ExecutionModes.SynchronousSingleton - PluginLoaderBase object will execute plugin in the same thread as the pluggable app and will allow only one instance of the plugin to be running at a time
        }

        public override PluginParameters Main(PluginParameters args)
        {
            //Assigns parameters passed from the pluggable app to public members
            this.Param1 = (string)args.Get("Param1");
            this.Param2 = (int)args.Get("Param2");
            this.Param3 = (double)args.Get("Param3");

            MainView pluginForm = new MainView();
            pluginForm.Show(); //show the main plugin window

            Application.Run(pluginForm); //This starts a new message loop for the plugin window. pluginForm.ShowDialog() may also be used instead.
            //Specifying ExecutionMode as Synchronous* and calling pluginForm.ShowDialog() will show the form in dialog mode and block the Pluggable App.

            args.Add("ReturnValue", "Success"); // Demonstrates how serializeable/primitive types can be passed back to the pluggable app
            //returned values will be available in the pluggable app via PluginLoaderBase.PluginUnloaded event

            return args;
        }

        public override void OnUnloadNotification()
        {
            //This method is called by PluginLoaderBase.NotifyUnload or PluginLoaderBase.NotifyUnloadAll to notify the plugin that it is about to be unloaded.
            //You can write code which will stop plugin process and do cleanup here
            Application.Exit();
        }
    }
}