Plugin Framework IPlugin

Plugin Framework IPlugin#

Title: Plugin Framework IPlugin

URL Source: https://newlifex.com/core/plugin

Markdown Content:
The plugin architecture is commonly used in business development, especially for plugins in the form of external DLLs. We have encapsulated the common code for plugin management.

Source code: https://github.com/NewLifeX/X/blob/master/NewLife.Core/Model/IPlugin.cs

Quick Start#

StarAgent supports loading plugins to achieve extended functionality. Below is the code for loading and initializing plugins in StarAgent.

// Plugin Manager
var pm = _PluginManager = new PluginManager
{
    Identity = "StarAgent",
    Provider = this,

    Log = XTrace.Log,
};
_container.AddSingleton(pm);

// Start Plugin
WriteLog("Starting plugin [{0}]", pm.Identity);
pm.Load();
pm.Init();
foreach (var item in pm.Plugins)
{
    if (item is IAgentPlugin plugin)
    {
        try
        {
            plugin.Start();
        }
        catch (Exception ex)
        {
            XTrace.WriteException(ex);
        }
    }
}

The management class PluginManager is responsible for loading plugins and supports scanning external DLLs. Next, Init notifies the plugin to perform initialization work. Finally, you can execute your business operations, which in the case of StarAgent is Start.

A plugin is essentially an implementation of the IPlugin interface or has the PluginAttribute attribute, as follows:

/// <summary>StarAgent Plugin</summary>
public interface IAgentPlugin : IPlugin
{
    /// <summary>Start working</summary>
    public void Start();

    /// <summary>Stop working</summary>
    /// <param name="reason"></param>
    public void Stop(String reason);
}

/// <summary>Base class for StarAgent Plugin</summary>
[Plugin("StarAgent")]
public abstract class AgentPlugin : DisposeBase, IAgentPlugin
{
    /// <summary>Service provider</summary>
    public IServiceProvider? Provider { get; set; }

    /// <summary>Initialize plugin</summary>
    /// <param name="identity"></param>
    /// <param name="provider"></param>
    /// <returns></returns>
    /// <exception cref="NotImplementedException"></exception>
    public virtual Boolean Init(String? identity, IServiceProvider provider)
    {
        if (identity != "StarAgent") return false;

        Provider = provider;

        return true;
    }

    /// <summary>Start working</summary>
    public virtual void Start() { }

    /// <summary>Stop working</summary>
    /// <param name="reason"></param>
    public virtual void Stop(String reason) { }
}

Core Principles#

General plugin implementation is usually an interface or an attribute.

/// <summary>General Plugin Interface</summary>
/// <remarks>
/// To facilitate the construction of a simple general plugin system, the following is stipulated:
/// 1. The host responsible for loading plugins will instantiate the plugin after loading it; at this time, some actions can be performed in the plugin constructor, but business processing should not start, as the host's preparation work may not be complete.
/// 2. Once the host is fully prepared, it will sequentially call the plugin's Init method and pass in the host identifier; the plugin distinguishes whether it is its target host through the identifier. The plugin's Init should be completed as soon as possible.
/// 3. If the plugin implements the <see cref="IDisposable"/> interface, the host will clean up resources at the end.
/// </remarks>
public interface IPlugin
{
    /// <summary>Initialize</summary>
    /// <param name="identity">Plugin host identifier</param>
    /// <param name="provider">Service provider</param>
    /// <returns>Returns whether initialization was successful. If the current host is not the expected host, it returns false here.</returns>
    Boolean Init(String? identity, IServiceProvider provider);
}

/// <summary>Plugin attribute. Used to determine whether a certain plugin implementation class supports a certain host</summary>
/// <remarks>Instantiation</remarks>
/// <param name="identity"></param>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class PluginAttribute(String identity) : Attribute
{
    /// <summary>Plugin host identifier</summary>
    public String Identity { get; set; } = identity;
}

The plugin interface is very simple, with only one Init. Since there may be multiple sets of plugin systems, it is necessary to specify Identity to distinguish different types of plugins.

The service provider IServiceProvider is also very important, facilitating the plugin to obtain various service implementations internally.

As you can see, our IPlugin interface only has the Init initialization and does not have a destruction interface. Generally, we use IDisposable to indicate plugin destruction, so IPlugin does not need to define similar methods again.

To manage plugins, the management class PluginManager is introduced.

Identity. Specifies the current plugin identifier, only loading plugins with that identifier. For example, StarAgent in the introductory code above.
Provider. The service provider of the host, plugins generally need to interact with other objects, and this is the link.
Plugins. Plugin collection, which holds the loaded plugins.
LoadPlugins. Scans for plugins, quickly obtaining the plugin collection.
Load. Loads plugins, scans and modifies the Plugins collection.
Init. Initializes plugins, sequentially calling the Init interface of the plugins.