Question

I’m trying to implement a simple plugin system which will allow people to write the following:

[Plugin("A plugin function")]
public static int PluginFunction(int a, int b)
{
    return a + b;
}

and then drop the DLL containing this function into a folder where it will be scanned by the application and show up as an available function at runtime. This all works fine, so far so good, the PluginAttribute class is what you would expect, just a description string for the function.

However, I’d like to allow the plugin writer to specify default values for the parameters. This is OK for values which are constant at compile time and then deduced via reflection, but I’d like a way to specify defaults for more complex types which will be created at runtime. Has anyone implemented something similar? The primary goal is to make it simple to implement plugin functions – I’m trying to avoid complex scaffolding but accept that my nice simple system is not going to cut it if I want this feature. I’m also happy to have some complexity in the application code which makes the system appear simple to the plugin writer.

Thanks,
Charlie.

---

Update:

I’m going with a combination of what’s been suggested here, the closest is what Peter O. came up with – here’s a version:

[Plugin("A plugin function")]
[Defaults(typeof(AdderDefaults))]
public static int Adder(int a, int b)
{
    return a + b;
}

public static class AdderDefaults
{
    public static int a { get { return 1; } }
    public static int b { get { return 2; } }
}

[Plugin("Another plugin function")]
[Defaults(typeof(TexturizerDefaults))]
public static Bitmap Texturize(Bitmap source, Point offset)
{
    return result;
}

public static class TexturizerDefaults
{
    // no default for source parameter
    public static Point offset { get { return new Point(16, 16); } }
}

This allows parameters to be skipped and specified by name. No compile time checking but that’s OK – checking these at runtime is acceptable.

Answer 1

Maybe you can create an attribute which refers to a type
containing default values for the plugin. Example:

[PluginDefaults(typeof(MyPluginDefaults))]

The class MyPluginDefaults could then look like:

public class MyPluginDefaults {
     int Parameter1 { // First parameter
         get { return 0; } // default value for 'a'
     }
     int Parameter2 { // Second parameter
         get { return 4; } // default value for 'b'
     }
     // Additional parameters would be called Parameter3, Parameter4, and so on.

}