c# - プラグイン アーキテクチャによる C# 2.0 マルチスレッド

Question

プラグイン アーキテクチャを使用する C# 2.0 のコンソール アプリケーションが確立されています。現時点では、プログラムは複数のインスタンスを実行できる基本的なマルチスレッドを使用しています。スレッドが作成され、アプリケーションが停止するまで続行されます。

各インスタンスは、独自のさまざまなプラグインをロードして、個別に構成できます。プラグインは基本プラグインから継承されます。このシステムは何年もの間、魔法のように機能しています。プラグインはイベント駆動型であり、すべてさまざまなイベントを読み取って、呼び出されているかどうかを確認し、そうでない場合は戻って、次のプラグインにイベントを読み取らせて、呼び出されて起動されたかどうかを確認します。

このシステムは何年も機能しています。ただし、プラグインが同期ではなく非同期でイベントをリッスンできるように、マルチスレッドの範囲をさらに広げたいと考えています。このセットアップの欠点の 1 つは、プラグインが起動して機能を実行すると、インスタンスがロックアウトされることです。次のイベントが発生すると、前の作業が完了するまで待機する必要があります。その後、次のプロセスを実行できるようになります。

私がやりたいことは、プラグインを実行し、イベントによって開始される次のプロセスに進む前に、プロセスが終了するのを待つ必要がないことです。

私は当分の間 .Net 2.0 で立ち往生しており、そのフレームワークで解決策を見つけなければなりません。数多くの例を見てきましたが、基準を満たすものを見つけることができません。問題の 1 つは、プラグインごとに処理にかかる時間があり、プラグインの完了率を追跡する方法がないことです。プラグインは、完了するとプロセスを開始および終了します。イベントのパラメーターとプラグインによっては、完了するまでにある程度の時間がかかる場合があります。

私の質問は、プラグインがイベントによって実行されるこの状況でマルチスレッドを処理する最良の方法は何でしょうか。http://msdn.microsoft.com/en-us/library/2e08f6yc(v=vs.80).aspxなどのページを見て、イベント駆動型プラグイン アーキテクチャ。

誰かが手がかりを持っているなら、私はそれを感謝します. このようなマルチスレッドの欠如は、このアプリケーションの何年にもわたるアキレス腱でした。

プラグイン ベース: これらには、イベントによってトリガーされるいくつかの関数が含まれています。

using System;
using VhaBot.Communication;

namespace VhaBot
{

/// <summary>
///     Plugin BaseClass, must be inherited by all plugins
/// </summary>
public abstract class PluginBase : MarshalByRefObject
{
    private bool _locked;
    private string _name;
    private string _internalName;
    private int _version;
    private string _author;
    private string[] _contributors;
    private string _description;
    private PluginState _defaultState;
    private string[] _dependencies;
    private Command[] _commands;

    /// <summary>
    ///     Friendly display name of plugin
    /// </summary>
    /// <example>
    ///     <code>
    ///  this.Name = "Message of the Day";
    ///   </code>
    /// </example>
    public string Name
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _name = value;
        }
        get { return _name; }
    }

    /// <summary>
    ///     Internal name of the plugin
    /// </summary>
    /// <example>
    ///     <code>
    ///  this.InternalName = "VhMotd";
    ///   </code>
    /// </example>
    public string InternalName
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _internalName = value.ToLower();
        }
        get { return _internalName; }
    }

    /// <summary>
    ///     Pluigin Version
    /// </summary>
    /// <remarks>
    ///     Versions are stored as integers only. Version 1.0.0 would have a value of 100
    /// </remarks>
    /// <example>
    ///     <code>
    /// this.Version = 100;
    ///  </code>
    /// </example>
    public int Version
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _version = value;
        }
        get { return _version; }
    }

    /// <summary>
    ///     Author of the plugin
    /// </summary>
    /// <example>
    ///     <code>
    /// this.Author = "Vhab";
    ///  </code>
    /// </example>
    public string Author
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _author = value;
        }
        get { return _author; }
    }

    /// <summary>
    ///     List of contributors to the development of the plugin.
    /// </summary>
    /// <example>
    ///     <code>
    ///  this.Contributors = new string[] { "Iriche", "Kilmanagh" };
    ///   </code>
    /// </example>
    public string[] Contributors
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _contributors = value;
        }
        get
        {
            if (_contributors != null)
            {
                return _contributors;
            }
            return new string[0];
        }
    }

    /// <summary>
    ///     Description of the plugin
    /// </summary>
    /// <example>
    ///     <code>
    ///  this.Description = "Provides an interface to the user to view who is online and/or on the private channel.";
    ///   </code>
    /// </example>
    public string Description
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _description = value;
        }
        get { return _description; }
    }

    /// <summary>
    ///     The default <see cref="VhaBot.PluginState" /> of the plugin
    /// </summary>
    /// <example>
    ///     <code>
    /// this.DefaultState = PluginState.Installed;
    /// </code>
    /// </example>
    /// <seealso cref="VhaBot.PluginState" />
    public PluginState DefaultState
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _defaultState = value;
        }
        get { return _defaultState; }
    }

    /// <summary>
    ///     List of other plugins that a plugin is dependent on to function
    /// </summary>
    /// <remarks>
    ///     Plugins are referred to using their internal names. See <see cref="VhaBot.PluginBase.InternalName" />
    /// </remarks>
    /// <example>
    ///     <code>
    /// this.Dependencies = new string[] { "vhItems" };
    /// </code>
    /// </example>
    public string[] Dependencies
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _dependencies = value;
        }
        get
        {
            if (_dependencies != null)
            {
                return _dependencies;
            }
            return new string[0];
        }
    }

      public Command[] Commands
    {
        set
        {
            if (_locked)
            {
                throw new Exception();
            }
            _commands = value;
        }
        get
        {
            if (_commands != null)
            {
                return _commands;
            }
            return new Command[0];
        }
    }

    internal void Init()
    {
        _locked = true;
    }

    /// <summary>
    ///     A plugin has loaded in response to <see cref="VhaBot.ShellModules.Plugins.Load" />
    /// </summary>
    /// <param name="bot"></param>
    /// ///
    /// <remarks>Code inside this method will be executed when a plugin is loading</remarks>
    public virtual void OnLoad(BotShell bot)
    {
    }

    /// <summary>
    ///     A plugin has unloaded in response to <see cref="VhaBot.ShellModules.Plugins.Unload" />
    /// </summary>
    /// <param name="bot"></param>
    /// <remarks>Code inside this method will be executed when a plugin is unloading</remarks>
    public virtual void OnUnload(BotShell bot)
    {
    }

    /// <summary>
    ///     A plugin has installed in response to <see cref="VhaBot.ShellModules.Plugins.Install" />
    /// </summary>
    /// <param name="bot"></param>
    public virtual void OnInstall(BotShell bot)
    {
    }

    /// <summary>
    ///     A plugin as been uninstalled in response to <see cref="VhaBot.ShellModules.Plugins.Uninstall" />
    /// </summary>
    /// <param name="bot"></param>
    public virtual void OnUninstall(BotShell bot)
    {
    }

    /// <summary>
    ///     A plugin has been upgraded (Unused)
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="version"></param>
    /// <remarks>This function is not active</remarks>
    public virtual void OnUpgrade(BotShell bot, Int32 version)
    {
    }

    /// <summary>
    ///     Response to a command
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="e"></param>
    public virtual void OnCommand(BotShell bot, CommandArgs e)
    {
    }

    /// <summary>
    ///     Response to an unauthorized command
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="e"></param>
    public virtual void OnUnauthorizedCommand(BotShell bot, CommandArgs e)
    {
    }

    /// <summary>
    ///     Response to a command help query <see cref="VhaBot.ShellModules.Commands.GetHelp." />
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="command"></param>
    /// <returns></returns>
    /// <remarks>Code inside this method will be executed when help is requested</remarks>
    public virtual string OnHelp(BotShell bot, string command)
    {
        return null;
    }

    /// <summary>
    ///     Response to a custom configuration
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="key"></param>
    /// <returns></returns>
    public virtual string OnCustomConfiguration(BotShell bot, string key)
    {
        return null;
    }

    /// <summary>
    ///     Response to a plugin message
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="message"></param>
    public virtual void OnPluginMessage(BotShell bot, PluginMessage message)
    {
    }

    /// <summary>
    ///     Response to a bot message
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="message"></param>
    public virtual void OnBotMessage(BotShell bot, BotMessage message)
    {
    }

    /// <summary>
    ///     Returns display name of bot and current version
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return Name + " v" + Version;
    }

    /// <summary>
    ///     There is no information to document this command
    /// </summary>
    /// <param name="bot"></param>
    /// <param name="args"></param>
    public void FireOnCommand(BotShell bot, CommandArgs args)
    {
        try
        {
            if (args.Authorized)
                OnCommand(bot, args);
            else
                OnUnauthorizedCommand(bot, args);
        }
        catch (Exception ex)
        {
            CommandArgs e = args;
            var window = new RichTextWindow(bot);
            window.AppendTitle("Error Report");

            window.AppendHighlight("Error: ");
            window.AppendNormal(ex.Message);
            window.AppendLinkEnd();
            window.AppendLineBreak();

            window.AppendHighlight("Source: ");
            window.AppendNormal(ex.Source);
            window.AppendLinkEnd();
            window.AppendLineBreak();

            window.AppendHighlight("Target Site: ");
            window.AppendNormal(ex.TargetSite.ToString());
            window.AppendLinkEnd();
            window.AppendLineBreak();

            window.AppendHighlight("Stack Trace:");
            window.AppendLineBreak();
            window.AppendNormal(ex.StackTrace);
            window.AppendLinkEnd();
            window.AppendLineBreak();

            bot.SendReply(e,
                          "There has been an error while executing this command »» " +
                          window.ToString("More Information"));
            BotShell.Output("[Plugin Execution Error] " + ex);
        }
    }
}
}

イベント クラス:

 namespace VhaBot.ShellModules
{
/// <summary>
///     VhaBot Events
/// </summary>
public class Events
{
    public event BotStateChangedHandler BotStateChangedEvent;
    public event ChannelJoinEventHandler ChannelJoinEvent;

    public event UserJoinChannelHandler UserJoinChannelEvent;
    public event UserLeaveChannelHandler UserLeaveChannelEvent;

    public event UserLogonHandler UserLogonEvent;
    public event UserLogoffHandler UserLogoffEvent;

    public event PrivateMessageHandler PrivateMessageEvent;
    public event PrivateChannelMessageHandler PrivateChannelMessageEvent;
    public event ChannelMessageHandler ChannelMessageEvent;

    public event MemberAddedHandler MemberAddedEvent;
    public event MemberRemovedHandler MemberRemovedEvent;
    public event MemberUpdatedHandler MemberUpdatedEvent;

    public event AltAddedHandler AltAddedEvent;
    public event AltRemovedHandler AltRemovedEvent;

    /// <summary>
    ///     A message was sent to the IRC channel in response to a <see      cref="VhaBot.BotShell.SendIrcMessage" /> request
    /// </summary>
    public event IrcMessageHandler IrcMessageEvent;

    public event ConfigurationChangedHandler ConfigurationChangedEvent;


    internal void OnBotStateChanged(BotShell bot, BotStateChangedArgs e)
    {
        if (BotStateChangedEvent != null)
            try
            {
                BotStateChangedEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnChannelJoin(BotShell bot, ChannelJoinEventArgs e)
    {
        if (ChannelJoinEvent != null)
            try
            {
                ChannelJoinEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnUserJoinChannel(BotShell bot, UserJoinChannelArgs e)
    {
        if (UserJoinChannelEvent != null)
            try
            {
                UserJoinChannelEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnUserLeaveChannel(BotShell bot, UserLeaveChannelArgs e)
    {
        if (UserLeaveChannelEvent != null)
            try
            {
                UserLeaveChannelEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnUserLogon(BotShell bot, UserLogonArgs e)
    {
        if (UserLogonEvent != null)
            try
            {
                UserLogonEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnUserLogoff(BotShell bot, UserLogoffArgs e)
    {
        if (UserLogoffEvent != null)
            try
            {
                UserLogoffEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnPrivateMessage(BotShell bot, PrivateMessageArgs e)
    {
        if (PrivateMessageEvent != null)
            try
            {
                PrivateMessageEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnPrivateChannelMessage(BotShell bot, PrivateChannelMessageArgs e)
    {
        if (PrivateChannelMessageEvent != null)
            try
            {
                PrivateChannelMessageEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnChannelMessage(BotShell bot, ChannelMessageArgs e)
    {
        if (ChannelMessageEvent != null)
            try
            {
                ChannelMessageEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnMemberAdded(BotShell bot, MemberAddedArgs e)
    {
        if (MemberAddedEvent != null)
            try
            {
                MemberAddedEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnMemberRemoved(BotShell bot, MemberRemovedArgs e)
    {
        if (MemberRemovedEvent != null)
            try
            {
                MemberRemovedEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnMemberUpdated(BotShell bot, MemberUpdatedArgs e)
    {
        if (MemberUpdatedEvent != null)
            try
            {
                MemberUpdatedEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnAltAdded(BotShell bot, AltAddedArgs e)
    {
        if (AltAddedEvent != null)
            try
            {
                AltAddedEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnAltRemoved(BotShell bot, AltRemovedArgs e)
    {
        if (AltRemovedEvent != null)
            try
            {
                AltRemovedEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnConfigurationChanged(BotShell bot, ConfigurationChangedArgs e)
    {
        if (ConfigurationChangedEvent != null)
            try
            {
                ConfigurationChangedEvent(bot, e);
            }
            catch
            {
            }
    }

    internal void OnIrcMessage(BotShell bot, IrcMessageArgs e)
    {
        if (IrcMessageEvent != null)
        {
            IrcMessageEvent(bot, e);
        }
        try
        {
        }
        catch
        {
        }
        }
    }
}