作为一名C#开发者，你是否遇到过这样的困扰：项目需求频繁变更，每次新增功能都要重新编译整个系统？ 客户要求灵活定制功能，但传统的单体架构让你束手无策？

今天我们就来解决这个痛点！通过MEF（Managed Extensibility Framework）插件化架构，让你的应用像积木一样灵活组装，新功能即插即用，无需重启系统。本文将通过一个完整的工业数据采集应用，带你掌握插件化开发的核心技巧。

🤔 为什么需要插件化架构？

传统开发的三大痛点

1. 紧耦合问题

c#
// ❌ 传统方式：硬编码依赖
public class DataProcessor
{
    public void Process(string data)
    {
        // 直接依赖具体实现
        var textProcessor = new TextProcessor();
        var numberProcessor = new NumberProcessor();
        // 新增处理器需要修改这里
    }
}

2. 扩展性差

• 每次新增功能都要修改主程序
• 部署时必须重启整个系统
• 无法根据客户需求灵活组装功能

3. 维护成本高

• 功能模块相互影响
• 测试复杂度随功能增加而指数增长
• 代码复用性差

插件化架构的优势

✅ 松耦合：主程序与插件通过接口通信

✅ 热插拔：运行时动态加载/卸载插件

✅ 高扩展：新功能独立开发，无需修改主程序

✅ 易维护：插件独立测试，故障隔离

🚀 MEF核心概念速通

三大核心机制

1. Export（导出）- 插件声明自己

c#
[Export(typeof(IPlugin))]  // 我是一个插件
[ExportMetadata("Name", "数据验证器")]  // 我的元数据
public class DataValidatorPlugin : IPlugin
{
    // 插件实现
}

2. Import（导入）- 主程序发现插件

c#
[ImportMany(typeof(IPlugin))]
private IEnumerable<Lazy<IPlugin>>? _plugins;  // 自动注入所有插件

3. Composition（组合）- 自动装配

c#
var container = new CompositionContainer(catalog);
container.ComposeParts(this);  // 魔法发生的地方

💡 记住这个黄金法则：Export声明能力，Import表达需求，Composition自动匹配！

🛠️ 实战项目：工业数据采集系统

让我们通过一个真实的工业场景来掌握MEF。这个系统需要支持多种数据处理插件：文本处理、数值计算、数据验证、实时采集等。

📁 项目结构设计

🎯 Step 1: 定义插件契约

核心接口设计

c#
using System.ComponentModel.Composition;

namespace AppIndustrialPlugin.Core.Contracts
{
    /// <summary>
    /// 插件基础接口
    /// </summary>
    public interface IPlugin
    {
        /// <summary>
        /// 插件名称
        /// </summary>
        string Name { get; }

        /// <summary>
        /// 插件版本
        /// </summary>
        string Version { get; }

        /// <summary>
        /// 插件描述
        /// </summary>
        string Description { get; }

        /// <summary>
        /// 插件作者
        /// </summary>
        string Author { get; }

        /// <summary>
        /// 初始化插件
        /// </summary>
        void Initialize();

        /// <summary>
        /// 执行插件主要功能
        /// </summary>
        /// <param name="input">输入数据</param>
        /// <returns>处理结果</returns>
        object Execute(object input);
    }
}

统一返回模型

c#
namespace AppIndustrialPlugin.Core.Models
{
    /// <summary>
    /// 处理结果
    /// </summary>
    public class ProcessResult
    {
        public bool Success { get; set; }
        public string Message { get; set; } = string.Empty;
        public object? Data { get; set; }
        public DateTime ProcessTime { get; set; } = DateTime.Now;
        public TimeSpan Duration { get; set; }

        public static ProcessResult CreateSuccess(object? data = null, string message = "")
        {
            return new ProcessResult
            {
                Success = true,
                Data = data,
                Message = message
            };
        }

        public static ProcessResult CreateError(string message)
        {
            return new ProcessResult
            {
                Success = false,
                Message = message
            };
        }
    }
}

🎯 Step 2: 实现核心插件

文本处理插件

c#
using AppIndustrialPlugin.Core.Contracts;
using AppIndustrialPlugin.Core.Models;
using System.ComponentModel.Composition;
using System.Runtime.InteropServices.JavaScript;

namespace AppIndustrialPlugin.Samples
{
    [Export(typeof(IPlugin))]
    [Export(typeof(IDataProcessor))]
    [ExportMetadata("Name", "文本处理器")]
    [ExportMetadata("Category", "文本工具")]
    [ExportMetadata("Version", "1.0.0")]
    [ExportMetadata("Priority", 100)]
    public class TextProcessorPlugin : IDataProcessor
    {
        public string Name => "文本处理器";
        public string Version => "1.0.0";
        public string Description => "提供文本转换、统计等功能";
        public string Author => "开发团队";

        public Type[] SupportedDataTypes => new[] { typeof(string) };

        public void Initialize()
        {
            // 初始化插件资源
        }

        public object Execute(object input)
        {
            var result = ProcessData(input);
            return result.Data ?? result.Message;
        }

        public ProcessResult ProcessData(object data)
        {
            if (!ValidateInput(data))
            {
                return ProcessResult.CreateError("输入数据无效，请提供文本字符串");
            }

            var text = data.ToString() ?? string.Empty;

            var result = new
            {
                原始文本 = text,
                字符数 = text.Length,
                单词数 = text.Split(new char[] { ' ', '\t', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries).Length,
                行数 = text.Split('\n').Length,
                大写转换 = text.ToUpper(),
                小写转换 = text.ToLower(),
                反转文本 = new string(text.Reverse().ToArray()),
                去除空格 = text.Replace(" ", ""),
                哈希值 = text.GetHashCode().ToString("X8")
            };

            return ProcessResult.CreateSuccess(result, "文本处理完成");
        }

        public bool ValidateInput(object data)
        {
            return data is string && !string.IsNullOrEmpty(data.ToString());
        }
    }
}

工业数据采集插件

c#
using System.ComponentModel.Composition;
using System.Text;
using System.Text.Json;
using AppIndustrialPlugin.Core.Contracts;
using AppIndustrialPlugin.Core.Models;

namespace AppIndustrialPlugin.Samples
{
    [Export(typeof(IPlugin))]
    [Export(typeof(IDataProcessor))]
    [ExportMetadata("Name", "工业数据采集器")]
    [ExportMetadata("Category", "数据采集")]
    [ExportMetadata("Version", "1.0.0")]
    [ExportMetadata("Priority", 95)]
    public class IndustrialDataCollectorPlugin : IDataProcessor
    {
        public string Name => "工业数据采集器";
        public string Version => "1.0.0";
        public string Description => "模拟工业现场传感器数据实时采集，支持温度、压力、流量、电流等参数";
        public string Author => "工业自动化团队";

        public Type[] SupportedDataTypes => new[] { typeof(string), typeof(int) };

        private readonly Random _random = new Random();
        private readonly Timer? _timer;
        private readonly List<SensorData> _collectedData = new();
        private readonly object _dataLock = new object();
        private bool _isCollecting = false;
        private DateTime _startTime;
        private int _sampleCount = 0;

        // 传感器配置
        private readonly Dictionary<string, SensorConfig> _sensorConfigs = new()
        {
            ["温度传感器_1"] = new SensorConfig("°C", 20.0, 100.0, 2.0, 45.5),
            ["温度传感器_2"] = new SensorConfig("°C", 15.0, 85.0, 1.5, 38.2),
            ["压力传感器_1"] = new SensorConfig("MPa", 0.1, 10.0, 0.5, 2.8),
            ["压力传感器_2"] = new SensorConfig("MPa", 0.0, 5.0, 0.3, 1.6),
            ["流量传感器"] = new SensorConfig("m³/h", 0.0, 500.0, 15.0, 125.8),
            ["液位传感器"] = new SensorConfig("m", 0.0, 20.0, 0.8, 8.5),
            ["电流传感器"] = new SensorConfig("A", 0.0, 50.0, 2.5, 12.3),
            ["转速传感器"] = new SensorConfig("rpm", 0.0, 3000.0, 50.0, 1450.0),
            ["振动传感器"] = new SensorConfig("mm/s", 0.0, 20.0, 1.2, 3.2),
            ["湿度传感器"] = new SensorConfig("%RH", 0.0, 100.0, 3.0, 65.5)
        };

        public void Initialize()
        {
            // 初始化传感器
        }

        public object Execute(object input)
        {
            var result = ProcessData(input);
            return result.Data ?? result.Message;
        }

        public ProcessResult ProcessData(object data)
        {
            if (!ValidateInput(data))
            {
                return ProcessResult.CreateError("输入无效。请输入采集持续时间（秒），如：10");
            }

            var input = data.ToString()?.Trim() ?? "";

            // 解析采集参数
            if (!TryParseCollectionParams(input, out int duration, out int interval))
            {
                return ShowUsageHelp();
            }

            // 执行数据采集
            return ExecuteDataCollection(duration, interval);
        }

        private bool TryParseCollectionParams(string input, out int duration, out int interval)
        {
            duration = 10; // 默认10秒
            interval = 1000; // 默认1秒间隔

            if (string.IsNullOrEmpty(input))
                return true;

            var parts = input.Split(',', ' ', ';').Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();

            if (parts.Length >= 1 && int.TryParse(parts[0], out duration))
            {
                if (duration <= 0 || duration > 300) // 最大5分钟
                {
                    duration = 10;
                    return false;
                }
            }
            else if (parts.Length >= 1)
            {
                return false;
            }

            if (parts.Length >= 2 && int.TryParse(parts[1], out var customInterval))
            {
                interval = Math.Max(100, Math.Min(5000, customInterval)); // 100ms到5s之间
            }

            return true;
        }

        private ProcessResult ShowUsageHelp()
        {
            var help = new StringBuilder();
            help.AppendLine("🏭 === 工业数据采集器使用说明 ===");
            help.AppendLine();
            help.AppendLine("📝 输入格式:");
            help.AppendLine("  • 空白 - 使用默认设置（10秒，1秒间隔）");
            help.AppendLine("  • 数字 - 指定采集持续时间（秒）");
            help.AppendLine("  • 数字1,数字2 - 指定持续时间和采集间隔（毫秒）");
            help.AppendLine();
            help.AppendLine("📊 可用传感器:");
            foreach (var sensor in _sensorConfigs)
            {
                help.AppendLine($"  • {sensor.Key} ({sensor.Value.Unit})");
            }
            help.AppendLine();
            help.AppendLine("⚙️ 参数限制:");
            help.AppendLine("  • 持续时间: 1-300 秒");
            help.AppendLine("  • 采集间隔: 100-5000 毫秒");
            help.AppendLine();
            help.AppendLine("💡 示例:");
            help.AppendLine("  • 10     - 采集10秒，每秒一次");
            help.AppendLine("  • 30,500 - 采集30秒，每500毫秒一次");

            return ProcessResult.CreateError(help.ToString());
        }

        private ProcessResult ExecuteDataCollection(int duration, int interval)
        {
            lock (_dataLock)
            {
                _collectedData.Clear();
                _sampleCount = 0;
            }

            _startTime = DateTime.Now;
            var endTime = _startTime.AddSeconds(duration);

            var result = new StringBuilder();
            result.AppendLine($"🏭 === 工业数据采集开始 ===");
            result.AppendLine($"📅 开始时间: {_startTime:yyyy-MM-dd HH:mm:ss}");
            result.AppendLine($"⏱️  采集时长: {duration} 秒");
            result.AppendLine($"🔄 采集间隔: {interval} 毫秒");
            result.AppendLine($"📊 传感器数量: {_sensorConfigs.Count} 个");
            result.AppendLine();

            // 模拟实时采集
            var samples = new List<Dictionary<string, SensorReading>>();
            var currentTime = _startTime;

            while (currentTime <= endTime)
            {
                var sampleData = CollectSensorData(currentTime);
                samples.Add(sampleData);

                // 显示实时数据（每5次采集显示一次，避免输出过多）
                if (samples.Count % Math.Max(1, 5000 / interval) == 0 || currentTime >= endTime)
                {
                    result.AppendLine($"⏰ [{currentTime:HH:mm:ss}] 第 {samples.Count} 次采集:");
                    foreach (var sensor in sampleData.Take(3)) // 只显示前3个传感器的实时值
                    {
                        var reading = sensor.Value;
                        var status = GetSensorStatus(reading.Value, sensor.Key);
                        result.AppendLine($"  {sensor.Key}: {reading.Value:F2} {reading.Unit} {status}");
                    }
                    if (sampleData.Count > 3)
                    {
                        result.AppendLine($"  ... 其余 {sampleData.Count - 3} 个传感器数据");
                    }
                    result.AppendLine();
                }

                currentTime = currentTime.AddMilliseconds(interval);

                // 模拟采集延时
                if (interval >= 100)
                    Thread.Sleep(Math.Min(50, interval / 10));
            }

            // 生成统计报告
            var statistics = GenerateStatistics(samples);
            result.Append(statistics);

            lock (_dataLock)
            {
                _collectedData.AddRange(samples.SelectMany(s =>
                    s.Select(kvp => new SensorData
                    {
                        SensorName = kvp.Key,
                        Reading = kvp.Value,
                        Timestamp = kvp.Value.Timestamp
                    })));
            }

            return ProcessResult.CreateSuccess(result.ToString(),
                $"采集完成，共获取 {samples.Count} 次采样数据");
        }

        private Dictionary<string, SensorReading> CollectSensorData(DateTime timestamp)
        {
            var sampleData = new Dictionary<string, SensorReading>();

            foreach (var config in _sensorConfigs)
            {
                var reading = GenerateSensorReading(config.Value, timestamp);
                sampleData[config.Key] = reading;
            }

            return sampleData;
        }

        private SensorReading GenerateSensorReading(SensorConfig config, DateTime timestamp)
        {
            // 模拟传感器波动：基准值 ± 随机波动
            var variation = (_random.NextDouble() - 0.5) * 2 * config.Variation;
            var rawValue = config.BaseValue + variation;

            // 添加一些周期性变化（模拟工业过程的周期性）
            var timeOffset = (timestamp - _startTime).TotalSeconds;
            var periodicVariation = Math.Sin(timeOffset * 0.1) * config.Variation * 0.3;
            rawValue += periodicVariation;

            // 确保值在合理范围内
            var value = Math.Max(config.MinValue, Math.Min(config.MaxValue, rawValue));

            // 模拟偶发的异常读数（5%概率）
            if (_random.NextDouble() < 0.05)
            {
                value += (_random.NextDouble() - 0.5) * config.Variation * 3;
                value = Math.Max(config.MinValue, Math.Min(config.MaxValue, value));
            }

            return new SensorReading
            {
                Value = value,
                Unit = config.Unit,
                Timestamp = timestamp,
                Quality = _random.NextDouble() > 0.02 ? "正常" : "警告" // 98%正常
            };
        }

        private string GetSensorStatus(double value, string sensorName)
        {
            if (!_sensorConfigs.TryGetValue(sensorName, out var config))
                return "";

            var normalMin = config.BaseValue - config.Variation;
            var normalMax = config.BaseValue + config.Variation;

            if (value < normalMin || value > normalMax)
                return "⚠️";

            return "✅";
        }

        private string GenerateStatistics(List<Dictionary<string, SensorReading>> samples)
        {
            var stats = new StringBuilder();
            stats.AppendLine("📈 === 采集统计分析 ===");
            stats.AppendLine($"📦 总采样次数: {samples.Count}");
            stats.AppendLine($"⏱️  实际持续时间: {(DateTime.Now - _startTime).TotalSeconds:F1} 秒");
            stats.AppendLine();

            foreach (var sensorName in _sensorConfigs.Keys)
            {
                var readings = samples.Select(s => s[sensorName].Value).ToArray();
                var avgValue = readings.Average();
                var minValue = readings.Min();
                var maxValue = readings.Max();
                var stdDev = Math.Sqrt(readings.Select(x => Math.Pow(x - avgValue, 2)).Average());

                stats.AppendLine($"🔧 {sensorName}:");
                stats.AppendLine($"  平均值: {avgValue:F2} {_sensorConfigs[sensorName].Unit}");
                stats.AppendLine($"  范围: {minValue:F2} ~ {maxValue:F2} {_sensorConfigs[sensorName].Unit}");
                stats.AppendLine($"  标准差: {stdDev:F2}");

                // 异常值统计
                var normalRange = _sensorConfigs[sensorName].Variation;
                var baseValue = _sensorConfigs[sensorName].BaseValue;
                var anomalies = readings.Count(r => Math.Abs(r - baseValue) > normalRange * 2);
                if (anomalies > 0)
                {
                    stats.AppendLine($"  异常读数: {anomalies} 次 ({100.0 * anomalies / readings.Length:F1}%)");
                }
                stats.AppendLine();
            }

            return stats.ToString();
        }

        public bool ValidateInput(object data)
        {
            return data is string || data is int;
        }

        // 数据模型
        private class SensorConfig
        {
            public string Unit { get; }
            public double MinValue { get; }
            public double MaxValue { get; }
            public double Variation { get; }
            public double BaseValue { get; }

            public SensorConfig(string unit, double minValue, double maxValue, double variation, double baseValue)
            {
                Unit = unit;
                MinValue = minValue;
                MaxValue = maxValue;
                Variation = variation;
                BaseValue = baseValue;
            }
        }

        private class SensorReading
        {
            public double Value { get; set; }
            public string Unit { get; set; } = "";
            public DateTime Timestamp { get; set; }
            public string Quality { get; set; } = "正常";
        }

        private class SensorData
        {
            public string SensorName { get; set; } = "";
            public SensorReading Reading { get; set; } = new();
            public DateTime Timestamp { get; set; }
        }
    }
}

🎯 Step 3: 主程序实现

UI主界面关键代码

c#
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.Reflection;
using AppIndustrialPlugin.Core.Contracts;
using AppIndustrialPlugin.Core.Models;

namespace AppIndustrialPlugin.Host
{
    public partial class FrmMain : Form
    {
        private CompositionContainer? _container;

        [ImportMany(typeof(IPlugin))]
        private IEnumerable<Lazy<IPlugin, PluginMetadata>>? _plugins;

        [ImportMany(typeof(IDataProcessor))]
        private IEnumerable<Lazy<IDataProcessor, PluginMetadata>>? _dataProcessors;

        public FrmMain()
        {
            InitializeComponent();
            SetupListView();
        }

        private void FrmMain_Load(object sender, EventArgs e)
        {
            ComposePlugins();
            LoadPluginsToListView();
            UpdateStatus("应用程序已启动，插件加载完成");
        }

        /// <summary>
        /// 设置ListView
        /// </summary>
        private void SetupListView()
        {
            lvPlugins.Columns.Add("插件名称", 150);
            lvPlugins.Columns.Add("版本", 80);
            lvPlugins.Columns.Add("类别", 100);
            lvPlugins.Columns.Add("描述", 200);
            lvPlugins.Columns.Add("作者", 100);
        }

        /// <summary>
        /// 组合插件
        /// </summary>
        private void ComposePlugins()
        {
            try
            {
                var catalog = new AggregateCatalog();

                // 添加当前程序集目录
                var currentAssemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
                catalog.Catalogs.Add(currentAssemblyCatalog);

                // 添加插件目录
                var pluginPath = Path.Combine(Application.StartupPath, "Plugins");
                if (Directory.Exists(pluginPath))
                {
                    var directoryCatalog = new DirectoryCatalog(pluginPath, "*.dll");
                    catalog.Catalogs.Add(directoryCatalog);
                }

                // 添加示例插件程序集
                try
                {
                    var sampleAssembly = Assembly.LoadFrom(Path.Combine(Application.StartupPath, "AppIndustrialPlugin.Samples.dll"));
                    var sampleCatalog = new AssemblyCatalog(sampleAssembly);
                    catalog.Catalogs.Add(sampleCatalog);
                }
                catch (FileNotFoundException)
                {
                    // 示例插件程序集不存在，忽略
                }

                _container = new CompositionContainer(catalog);
                _container.ComposeParts(this);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"插件组合失败: {ex.Message}", "错误",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 加载插件到ListView
        /// </summary>
        private void LoadPluginsToListView()
        {
            lvPlugins.Items.Clear();

            if (_plugins == null) return;

            foreach (var plugin in _plugins)
            {
                try
                {
                    var pluginInstance = plugin.Value;
                    var metadata = plugin.Metadata;

                    var item = new ListViewItem(pluginInstance.Name);
                    item.SubItems.Add(pluginInstance.Version);
                    item.SubItems.Add(metadata.Category);
                    item.SubItems.Add(pluginInstance.Description);
                    item.SubItems.Add(pluginInstance.Author);
                    item.Tag = plugin;

                    lvPlugins.Items.Add(item);
                }
                catch (Exception ex)
                {
                    AppendResult($"加载插件失败: {ex.Message}", true);
                }
            }

            UpdateStatus($"已加载 {lvPlugins.Items.Count} 个插件");
        }

        /// <summary>
        /// 执行插件
        /// </summary>
        private async void btnExecute_Click(object sender, EventArgs e)
        {
            if (lvPlugins.SelectedItems.Count == 0)
            {
                MessageBox.Show("请先选择一个插件", "提示",
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            var selectedItem = lvPlugins.SelectedItems[0];
            if (selectedItem.Tag is not Lazy<IPlugin, PluginMetadata> lazyPlugin)
                return;

            btnExecute.Enabled = false;
            ShowProgress(true);

            try
            {
                var input = txtInput.Text.Trim();
                var plugin = lazyPlugin.Value;

                AppendResult($"\n=== 执行插件: {plugin.Name} ===");
                AppendResult($"输入数据: {input}");

                var startTime = DateTime.Now;

                // 在后台线程执行插件
                var result = await Task.Run(() =>
                {
                    try
                    {
                        // 如果是数据处理器，使用专门的接口
                        if (plugin is IDataProcessor processor)
                        {
                            return processor.ProcessData(input);
                        }
                        else
                        {
                            var executeResult = plugin.Execute(input);
                            return ProcessResult.CreateSuccess(executeResult, "执行成功");
                        }
                    }
                    catch (Exception ex)
                    {
                        return ProcessResult.CreateError($"执行异常: {ex.Message}");
                    }
                });

                var duration = DateTime.Now - startTime;

                // 显示结果
                if (result.Success)
                {
                    AppendResult($"执行成功 (耗时: {duration.TotalMilliseconds:F2}ms)");
                    if (result.Data != null)
                    {
                        AppendResult($"结果: {result.Data}");
                    }
                    if (!string.IsNullOrEmpty(result.Message))
                    {
                        AppendResult($"消息: {result.Message}");
                    }
                }
                else
                {
                    AppendResult($"执行失败: {result.Message}", true);
                }
            }
            catch (Exception ex)
            {
                AppendResult($"执行插件时发生错误: {ex.Message}", true);
            }
            finally
            {
                btnExecute.Enabled = true;
                ShowProgress(false);
                UpdateStatus("插件执行完成");
            }
        }

        /// <summary>
        /// 加载插件菜单项
        /// </summary>
        private void tsmLoadPlugins_Click(object sender, EventArgs e)
        {
            using var dialog = new FolderBrowserDialog
            {
                Description = "选择插件目录",
                ShowNewFolderButton = false
            };

            if (dialog.ShowDialog() == DialogResult.OK)
            {
                LoadPluginsFromDirectory(dialog.SelectedPath);
            }
        }

        /// <summary>
        /// 从目录加载插件
        /// </summary>
        private void LoadPluginsFromDirectory(string path)
        {
            try
            {
                var catalog = new DirectoryCatalog(path, "*.dll");
                var tempContainer = new CompositionContainer(catalog);

                // 测试是否能够加载
                tempContainer.ComposeParts(this);

                // 重新组合所有插件
                ComposePlugins();
                LoadPluginsToListView();

                UpdateStatus($"已从 {path} 加载插件");
            }
            catch (Exception ex)
            {
                MessageBox.Show($"从目录加载插件失败: {ex.Message}", "错误",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 刷新插件
        /// </summary>
        private void tsmRefresh_Click(object sender, EventArgs e)
        {
            ComposePlugins();
            LoadPluginsToListView();
            AppendResult("\n=== 插件列表已刷新 ===");
        }

        /// <summary>
        /// 退出应用程序
        /// </summary>
        private void tsmExit_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        /// <summary>
        /// 关于对话框
        /// </summary>
        private void tsmAbout_Click(object sender, EventArgs e)
        {
            MessageBox.Show(
                "MEF 插件化应用程序\n\n" +
                "演示 Managed Extensibility Framework 的使用\n" +
                "支持动态加载和执行插件\n\n" +
                "版本: 1.0.0\n" +
                "基于 .NET 8.0",
                "关于",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information);
        }

        /// <summary>
        /// 添加结果输出
        /// </summary>
        private void AppendResult(string message, bool isError = false)
        {
            if (rtbResult.InvokeRequired)
            {
                rtbResult.Invoke(() => AppendResult(message, isError));
                return;
            }

            var timestamp = DateTime.Now.ToString("HH:mm:ss");
            var line = $"[{timestamp}] {message}\n";

            var startPos = rtbResult.TextLength;
            rtbResult.AppendText(line);

            // 设置颜色
            rtbResult.Select(startPos, line.Length);
            rtbResult.SelectionColor = isError ? Color.Red : Color.Lime;
            rtbResult.Select(rtbResult.TextLength, 0);
            rtbResult.ScrollToCaret();
        }

        /// <summary>
        /// 更新状态栏
        /// </summary>
        private void UpdateStatus(string message)
        {
            if (lblStatus.Owner?.InvokeRequired == true)
            {
                lblStatus.Owner.Invoke(() => UpdateStatus(message));
                return;
            }

            lblStatus.Text = message;
        }

        /// <summary>
        /// 显示/隐藏进度条
        /// </summary>
        private void ShowProgress(bool show)
        {
            if (pgbProgress.Owner?.InvokeRequired == true)
            {
                pgbProgress.Owner.Invoke(() => ShowProgress(show));
                return;
            }

            pgbProgress.Visible = show;
            if (show)
            {
                pgbProgress.Style = ProgressBarStyle.Marquee;
                pgbProgress.MarqueeAnimationSpeed = 30;
            }
        }


        protected override void OnClosed(EventArgs e)
        {
            _container?.Dispose();
            base.OnClosed(e);
        }
    }
}

🎨 最佳实践总结

📋 架构设计原则

1. 单一职责：每个插件只做一件事，做好一件事
2. 依赖倒置：主程序依赖接口，不依赖具体实现
3. 开闭原则：对扩展开放，对修改关闭

📋 性能优化技巧

1. 延迟加载：使用Lazy<T>避免不必要的实例化
2. 异步执行：插件执行放在后台线程，保持UI响应
3. 资源管理：及时释放CompositionContainer避免内存泄漏

📋 生产环境建议

1. 异常隔离：插件异常不应影响主程序稳定性
2. 版本管理：通过元数据管理插件版本兼容性
3. 热插拔：支持运行时加载/卸载插件

💪 总结与展望

通过这个完整的工业数据采集系统，我们掌握了MEF插件化架构的核心技术：

🔥 核心要点1：Export/Import/Composition三位一体，让依赖注入变得简单优雅

🔥 核心要点2：接口契约设计是插件化成功的关键，决定了系统的扩展性

🔥 核心要点3：合理的异常处理和资源管理，确保插件系统的稳定性

插件化架构不仅解决了传统开发的痛点，更为我们打开了模块化开发的新思路。在微服务、云原生的时代，这种思想同样适用于分布式系统的设计。

🤝 互动时间

1. 你在项目中遇到过哪些需要插件化解决的场景？
2. 除了MEF，你还了解哪些.NET生态的插件化方案？

如果这篇文章对你有帮助，请转发给更多需要的同行！让我们一起推动C#技术社区的发展💪

---