MEF и создание расширяемого приложения

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace MEFApplication {
    public partial class MainForm : Form {
        //Переменная класса менеджера плагинов
        PluginManager manager = null;
        public MainForm() {
            InitializeComponent();
            //Подключение обработчика загрузки приложения
            this.Load += new EventHandler(MainForm_Load);
            //Подключение обработчиков нажатия кнопок
            btnCalculate.Click += new EventHandler(btnCalculate_Click);
            btnClear.Click += new EventHandler(btnClear_Click);
        }
        //Обработчик кнопки <Очистить!>
        void btnClear_Click(object sender, EventArgs e) {
            //Очистка всех текстовых полей
            this.Controls.OfType<TextBox>().ToList().ForEach(t => t.Clear());
        }
        //Обработчик кнопки <Вычислить!>
        void btnCalculate_Click(object sender, EventArgs e) {
            //Проверка переменной менеджера плагинов на null
            if (manager == null) {
                return;
            }
            string ops = cmbOperations.Text;
            //Проверка входных аргументов
            if (!string.IsNullOrWhiteSpace(ops)) {
                int arg1;
                int arg2;
                if (!int.TryParse(txtFirstNumber.Text, out arg1)) {
                    txtFirstNumber.Clear();
                    MessageBox.Show("Не верный ввод!", "Ошибка");
                    return;
                }
                if (!int.TryParse(txtSecondNumber.Text, out arg2)) {
                    txtSecondNumber.Clear();
                    MessageBox.Show("Не верный ввод!", "Ошибка");
                    return;
                }
                //Вычисление и вывод результата
                int result = manager._operations[ops](arg1, arg2);
                txtResult.Text = result.ToString();
            }
        }
        //Обработчик загрузки приложения
        void MainForm_Load(object sender, EventArgs e) {
            manager = new PluginManager();
            if (manager.Operations!=null && manager.Operations.Length != 0) {
                cmbOperations.Items.AddRange(manager.Operations);
                cmbOperations.Text = cmbOperations.Items[0].ToString();
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
using System.IO;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
 
namespace MEFApplication {
    public class PluginManager {
        //Обобщенная коллекция с параметром типа IOperation
        //После композиции содержит все найденные типы, 
        //реализующие IOperation 
        //и помеченные атрибутом экспорта [Export(typeof(IOperation))]
        //В данном случае применен атрибут ImportManyAttribute,
        //для того чтобы все найденные части были добавлены в композицию
        [ImportMany(typeof(IOperation))]
        IEnumerable<IOperation> Plugins { get; set; }
 
        //Словарь только для чтения, ключ-строка, значение-метод типа Func<int, int, int>
        public readonly Dictionary<string, Func<int, int, int>> _operations = 
            new Dictionary<string, Func<int, int, int>>();
        public string[] Operations { get; private set; }
 
        //Конструктор экземпляра
        public PluginManager() {
            //Основной каталог композиции объектов
            AggregateCatalog catalog = new AggregateCatalog();
            //Добавление подкалогов в основной каталог композиции
            //В данном случае добавляется два подкаталога, которые указывают, 
            //в каком месте могут содержаться типы расширения
            //Путь №1 - основная папка приложения (там же, где находится исполняемый файл)
            //Путь №2 - папка Plugins, находящаяся рядом с исполняемым файлом
            //Путей может быть и больше!
            catalog.Catalogs.Add(new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory));
            catalog.Catalogs.Add(new DirectoryCatalog(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Plugins")));
            //Контейнер композиции
            CompositionContainer container = new CompositionContainer(catalog);
            //Выполнение композиции найденных частей
            container.ComposeParts(this);
            //Заполнение словаря символами операций и операциями
            if (Plugins.Count() != 0) {
                Plugins.ToList().ForEach(p => _operations.Add(p.Operation, (i, j) => p.Operate(i, j)));
                Operations = _operations.Keys.ToArray();
            }
        }
    }
    //Общедоступный интерфейс   
    public interface IOperation {
        //Свойство для чтения, знак операции
        string Operation { get; }
        //Метод, выполняет операцию над двумя типами int и возвращает тип int
        int Operate(int x, int y);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
using MEFApplication;
using System.ComponentModel.Composition;
 
namespace MultPlugin {
    //Атрибут экспорта, обявляет данный тип экспортирует IOperation
    [Export(typeof(IOperation))]
    //Класс, реализующий операцию умножения
    public class MultClass : IOperation {
        public int Operate(int x, int y) {
            return x * y;
        }
 
        public string Operation {
            get { return "*"; }
        }
    }
}

var plugins = from filename in files.AsParallel()
                              let assembly = Assembly.LoadFile(filename)
                              from attribute in assembly.GetCustomAttributes(typeof(AssemblyPluginTypeAttribute), false).AsParallel()
                              let pluginType = (attribute as AssemblyPluginTypeAttribute).PluginType
                              let interfaceType = pluginType.GetInterface(typeof(IPlugin).FullName)
                              where interfaceType != null && !pluginType.IsAbstract
                              let plugin = (IPlugin)Activator.CreateInstance(pluginType)
                              select plugin;

interface IPlugin {
    string TestMethod();
}
 
[Export(typeof(IPlugin))]
public class Test : IPlugin
{
    string lol;
 
    [ImportingConstructor]
    public Test(string str)
    {
        lol = str;
    }
 
    public string TestMethod()
    {
        return lol;
    }
}
 
class Program
{
    [ImportMany(typeof(IPlugin))]
    IEnumerable<IPlugin> Plugins { get; set; }
 
    public Program()
    {
        var catalog = new AggregateCatalog();
        catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));
        //catalog.Catalogs.Add(new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory));
 
        var container = new CompositionContainer(catalog);
        container.ComposeExportedValue("hello");
        container.ComposeParts(this);
    }
 
    static void Main(string[] args)
    {
        var p = new Program();
        foreach (var plugin in p.Plugins)
            Console.WriteLine(plugin.TestMethod());
        Console.ReadLine();
    }
}

this.mContainer.ComposeParts(this);