简介

静态工具类 MEFUtil，是一个使用MEF（Managed Extensibility Framework）技术加载动态导出部件的工具类。可以方便地用于在运行时加载和管理动态部件。

EasyTool.MEFUtil 类

方法说明:

• LoadExportParts<T>：从指定目录动态加载导出部件
• LoadExportPartsFromAssembly<T>：从指定程序集动态加载导出部件
• LoadExportPartsFromFolder<T>：从指定文件夹中加载所有导出部件
• LoadExportPartsFromType<T>：从指定类型中加载所有导出部件
• LoadExportPartsFromFolders：加载多个目录中的导出部件
• GetImportPart<T>：从指定容器中获取导入部件的实例。
• GetImportParts<T>：从指定容器中获取导入部件的列表。

LoadExportParts-从指定目录动态加载导出部件

/// <summary>
/// 从指定目录动态加载导出部件
/// </summary>
/// <typeparam name="T">导出部件的类型</typeparam>
/// <param name="directory">目录路径</param>
/// <returns>导出部件的列表</returns>
public static IEnumerable<T> LoadExportParts<T>(string directory = null)

LoadExportPartsFromAssembly-从指定程序集动态加载导出部件

/// <summary>
/// 从指定程序集动态加载导出部件
/// </summary>
/// <typeparam name="T">导出部件的类型</typeparam>
/// <param name="assemblyName">程序集名称</param>
/// <returns>导出部件的列表</returns>
public static IEnumerable<T> LoadExportPartsFromAssembly<T>(string assemblyName)

LoadExportPartsFromFolder-从指定文件夹中加载所有导出部件

/// <summary>
/// 从指定文件夹中加载所有导出部件
/// </summary>
/// <typeparam name="T">导出部件类型</typeparam>
/// <param name="folderPath">指定文件夹路径</param>
/// <param name="searchOption">搜索选项</param>
/// <returns>导出部件列表</returns>
public static IEnumerable<T> LoadExportPartsFromFolder<T>(string folderPath, SearchOption searchOption = SearchOption.AllDirectories)

LoadExportPartsFromType-从指定类型中加载所有导出部件

/// <summary>
/// 从指定类型中加载所有导出部件
/// </summary>
/// <typeparam name="T">导出部件类型</typeparam>
/// <param name="type">指定类型</param>
/// <returns>导出部件列表</returns>
public static IEnumerable<T> LoadExportPartsFromType<T>(Type type)

LoadExportPartsFromFolders-加载多个目录中的导出部件

/// <summary>
/// 加载多个目录中的导出部件
/// </summary>
/// <typeparam name="T">导出部件类型</typeparam>
/// <param name="folderPaths">多个目录路径</param>
/// <returns>导出部件列表</returns>
public static IEnumerable<T> LoadExportPartsFromFolders<T>(IEnumerable<string> folderPaths)

GetImportPart-从指定容器中获取导入部件

/// <summary>
/// 从指定容器中获取导入部件
/// </summary>
/// <typeparam name="T">导入部件的类型</typeparam>
/// <param name="container">容器</param>
/// <returns>导入部件的实例</returns>
public static T GetImportPart<T>(CompositionContainer container)

GetImportParts-从指定容器中获取导入部件的列表

/// <summary>
/// 从指定容器中获取导入部件的列表
/// </summary>
/// <typeparam name="T">导入部件的类型</typeparam>
/// <param name="container">容器</param>
/// <returns>导入部件的列表</returns>
public static IEnumerable<T> GetImportParts<T>(CompositionContainer container)

代码示例

当使用 MEFUtil 动态加载部件时，需要将导出部件标记为[Export]，并且导入部件需要使用 [Import] 进行标记。

这里提供一个示例，假设我们有一个名为 ICalculator 的接口和两个实现类 Addition 和 Subtraction，我们希望动态加载实现类并使用它们：

// 定义接口和实现类
public interface ICalculator
{
    int Calculate(int a, int b);
}

[Export(typeof(ICalculator))]
public class Addition : ICalculator
{
    public int Calculate(int a, int b)
    {
        return a + b;
    }
}

[Export(typeof(ICalculator))]
public class Subtraction : ICalculator
{
    public int Calculate(int a, int b)
    {
        return a - b;
    }
}

// 加载部件并使用
var parts = MEFUtil.LoadExportParts<ICalculator>();
foreach (var part in parts)
{
    Console.WriteLine(part.Calculate(10, 5));
}

输出结果

15
5

这里我们使用 MEFUtil 加载了 ICalculator 接口的实现类，并且通过 foreach 循环遍历每个实现类并调用其 Calculate 方法，输出计算结果。

需要注意的是，在 Addition 和 Subtraction 类中需要使用 [Export] 进行标记，才能被 MEFUtil 加载。