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#

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

// 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 the StarDust Agent is Start.

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

/// <summary>StarDust Agent 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 StarDust Agent Plugin</summary>
[Plugin("StarAgent")]
public abstract class AgentPlugin : DisposeBase, IAgentPlugin
{
    /// <summary>Service provider</summary>
    public IServiceProvider? Provider { get; set; }

    /// <summary>Initialize the 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 Principle#

General plugin implementation is usually through interfaces or attributes.

/// <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 begin, as the host's preparation may not yet be complete.
/// 2. Once the host is fully prepared, it will sequentially call the Init method of the plugin and pass in the host identifier, allowing the plugin to distinguish whether it is the intended host. The plugin's Init should complete as quickly 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</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 an Identity to distinguish different types of plugins.

The service provider IServiceProvider is also very important, facilitating the plugin's internal access to various service implementations.

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

To manage plugins, we introduce the management class PluginManager.

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