Лучший способ настроить модульную программу на С#

Ответ 1

Раньше я использовал такие вещи на проектах, но это было давно. Есть, вероятно, рамки, которые делают такие вещи для вас.

Чтобы написать собственную архитектуру плагина, в основном вы хотите определить интерфейс для всех модулей для реализации и поместить это в сборку, совместно используемую как вашей программой, так и модулями:

public interface IModule
{
     //functions/properties/events of a module
} 

Затем ваши разработчики будут кодировать свои модули для этой сборки, предпочтительно с помощью конструктора по умолчанию.

public class SomeModule : IModule {} ///stuff 

В вашей программе (если ваши модули будут скомпилированы в свои собственные сборки) вы загрузите ссылку на сборку, содержащую модуль, найдите типы, реализующие интерфейс модуля, и создайте их:

var moduleAssembly = System.Reflection.Assembly.LoadFrom("assembly file");
var moduleTypes = moduleAssembly.GetTypes().Where(t => 
   t.GetInterfaces().Contains(typeof(IModule)));

var modules = moduleTypes.Select( type =>
            {   
               return  (IModule) Activator.CreateInstance(type);
            });

Если вы хотите скомпилировать код "на лету": вы создаете объект компилятора, рассказываете ему, какие сборки ссылаются (System и тот, который содержит IModule, а также любые другие необходимые ссылки), сообщают ему, чтобы скомпилировать исходный файл в сборку. Из этого вы получаете экспортированные типы, сохраняя те, которые реализуют IModule, и создаете их.

//I made up an IModule in namespace IMod, with string property S
string dynamicCS = @"using System; namespace DYN 
             { public class Mod : IMod.IModule { public string S 
                 { get { return \"Im a module\"; } } } }";

var compiler = new Microsoft.CSharp.CSharpCodeProvider().CreateCompiler();
var options = new System.CodeDom.Compiler.CompilerParameters(
       new string[]{"System.dll", "IMod.dll"});

var dynamicAssembly= compiler.CompileAssemblyFromSource(options, dynamicCS);
//you need to check it for errors here

var dynamicModuleTypes = dynamicAssembly.CompiledAssembly.GetExportedTypes()
    .Where(t => t.GetInterfaces().Contains(typeof(IMod.IModule)));
var dynamicModules = dynModType.Select(t => (IMod.IModule)Activator.CreateInstance(t));

Посмотрите руководства по подключаемым архитектурам и загрузите динамические assmeblies, чтобы лучше понять, как это делать. Это только начало. Как только вы уберете основы, вы можете начать делать действительно классные вещи.

Как для обработки метаданных (модуль X называется YYY и должен обрабатывать события A, B и C): Попытайтесь использовать это в своей системе типов. Вы могли бы создавать разные интерфейсы для различных функций/событий, или вы могли бы поместить все функции на один интерфейс и поместить атрибуты (объявите их в общей сборке) в классы модулей, используя атрибуты для объявления каких событий модуль должен подписаться. В основном вы хотите сделать так просто, насколько это возможно, чтобы люди могли писать модули для вашей системы.

 enum ModuleTypes { ChannelMessage, AnotherEvent, .... }

 [Shared.Handles(ModuleTypes.ChannelMessage)]
 [Shared.Handles(ModuleTypes.AnotherEvent)]
 class SomeModule : IModule { ... }

или

 //this is a finer-grained way of doing it
 class ChannelMessageLogger : IChannelMessage {}
 class PrivateMessageAutoReply : IPrivateMessage {} 

получайте удовольствие!

Ответ 2

Managed Extensibility Framework (MEF) обеспечивает именно то, что вы ищете, за исключением того, что они называют его плагиновой архитектурой. Вы могли бы предоставить общий интерфейс, который могли бы использовать пользователи, а затем MEF мог сканировать каталог для dll и динамически загружать любой экспорт.

Например, ваши авторы плагинов могут создать что-то вроде

[Export(typeof(IModule))]
public class MyModule : IModule
{
   void HandleMessage(ChannelEventArgs e) {}
}

Тогда ваш код может выглядеть примерно так:

void OnChannelMessage(ChannelEventArgs e)
{
  foreach(IModule module in Modules)
  {
     module.HandleMessage(e);
  }
}

[Import]
public IEnumerable<IModule> Modules { get; set; }

Ответ 3

Пожалуйста, посмотрите Microsoft Managed Extensibility Framework (MEF) - он предлагает сделать то, что вы хотите, и предоставляет множество других функций:

Результаты Google для "управляемой инфраструктуры расширяемости"

Ответ 4

В центре .NET 3.5 есть еще одна опция Managed AddIn Framework (MAF). Проверьте следующие ссылки.

Пример и инструменты: http://clraddins.codeplex.com/

Блог MAF: http://blogs.msdn.com/clraddins/

Хорошая статья: http://blogs.microsoft.co.il/blogs/bursteg/archive/2007/08/13/Build-AddIns-with-System-AddIn.aspx

Ответ 5

MEF - Managed Extensibility Framework - это модное слово прямо сейчас - я думаю, что это было бы лучше всего.

Если это не делает трюк, вы также можете посмотреть Prism, у них есть другой подход к реализации модулей.