Question

What are the best practices to create a site, with ability to develop plugins for it?

Like you want to create a blog module, and you want users or co-developers to add plugins to extend this module functionality.

Update: Thanks for the ultra speed answers, but I think this is over kill for me. Isn’t there a simpler solution, like I have seen blogengine plugin creation system is you just have to decorate the class plugin with [Extension].

I am kind of mid core developer, so I was thinking of base class, inheritance, interfaces, what do you think ?

Answer 1

Edit

I completely rewrote my answer based on your question edit.

Let me show you just how easy it is to implement a plugin architecture with just the minimal steps.

Step 1: Define an interface that your plugins will implement.

namespace PluginInterface {     public interface IPlugin     {         string Name { get; }         string Run(string input);     } } 

Step 2: Create a plugin that implements IPlugin.

namespace PluginX {     using PluginInterface;      public class Plugin : IPlugin     {         public string Name         {             get { return 'Plugin X'; }         }          public string Run(string input)         {             return input;         }     } } 

Step 3: Run the plugin.

namespace PluginTest {     using System;     using System.IO;     using System.Runtime.Remoting;     using PluginInterface;      class Program     {         static void Main( string[] args )         {             string pluginFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, 'PluginX.dll');             ObjectHandle handle = Activator.CreateInstanceFrom(pluginFile, 'PluginX.Plugin');              IPlugin plugin = handle.Unwrap() as IPlugin;              string pluginName = plugin.Name;             string pluginResult = plugin.Run('test string');                    }     } } 

Keep in mind, this is just the basic, most straightforward example of a plugin architechure. You can also do things such as

• create a plugin host to run your plugin inside of it’s own AppDomain
• choose either interfaces, abstract classes, or attributes to decorate your plugins with
• use reflection, interfaces, IL-emitted thunks or delegates to get the late binding job done

if your design so dictates.