using Newtonsoft.Json;
|
using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Reflection;
|
using System.Runtime.Loader;
|
using System.Text;
|
using System.Threading.Tasks;
|
|
namespace LB_VisionProcesses
|
{
|
public class PluginManager
|
{
|
private static readonly List<Assembly> _loadedAssemblies = new List<Assembly>();
|
private static readonly Dictionary<string, AssemblyLoadContext> _loadContexts =
|
new Dictionary<string, AssemblyLoadContext>();
|
private static readonly object _lock = new object();
|
|
/// <summary>
|
/// 已加载的工具字典（键：显示名称，值：类型完全限定名）
|
/// </summary>
|
public static Dictionary<string, string> LoadedProcesses { get; } = new Dictionary<string, string>();
|
|
/// <summary>
|
/// 按分类组织的工具
|
/// </summary>
|
public static Dictionary<string, Dictionary<string, string>> CategorizedProcesses { get; } =
|
new Dictionary<string, Dictionary<string, string>>();
|
|
/// <summary>
|
/// 插件信息
|
/// </summary>
|
public static List<PluginInfo> PluginInfos { get; } = new List<PluginInfo>();
|
|
/// <summary>
|
/// 插件目录路径
|
/// </summary>
|
public static string PluginDirectory { get; set; } = "Plugins";
|
|
/// <summary>
|
/// 插件加载事件
|
/// </summary>
|
public static event EventHandler<PluginEventArgs> PluginLoaded;
|
public static event EventHandler<PluginEventArgs> PluginUnloaded;
|
|
static PluginManager()
|
{
|
// 确保插件目录存在
|
if (!Directory.Exists(PluginDirectory))
|
{
|
Directory.CreateDirectory(PluginDirectory);
|
}
|
}
|
|
/// <summary>
|
/// 加载所有插件
|
/// </summary>
|
public static void LoadAllPlugins()
|
{
|
lock (_lock)
|
{
|
ClearLoadedAssemblies();
|
|
// 加载主程序集的工具
|
ScanAssemblyForProcesses(Assembly.GetExecutingAssembly(), "LB_VisionProcesses");
|
|
// 加载插件目录的DLL
|
LoadAssembliesFromDirectory(PluginDirectory);
|
|
// 加载配置文件指定的插件
|
LoadFromConfig();
|
}
|
}
|
|
/// <summary>
|
/// 加载指定程序集
|
/// </summary>
|
public static bool LoadAssembly(string assemblyPath, string pluginName = null)
|
{
|
lock (_lock)
|
{
|
try
|
{
|
if (!File.Exists(assemblyPath))
|
{
|
Debug.WriteLine($"程序集文件不存在: {assemblyPath}");
|
return false;
|
}
|
|
// 检查是否已加载
|
var fileName = Path.GetFileName(assemblyPath);
|
if (_loadContexts.ContainsKey(fileName))
|
{
|
Debug.WriteLine($"程序集已加载: {fileName}");
|
return false;
|
}
|
|
// 创建隔离的加载上下文
|
var context = new PluginLoadContext(assemblyPath);
|
var assembly = context.LoadFromAssemblyPath(assemblyPath);
|
|
_loadedAssemblies.Add(assembly);
|
_loadContexts[fileName] = context;
|
|
// 扫描工具类
|
var pluginInfo = ScanAssemblyForProcesses(assembly, pluginName ?? Path.GetFileNameWithoutExtension(assemblyPath));
|
PluginInfos.Add(pluginInfo);
|
|
// 触发事件
|
PluginLoaded?.Invoke(null, new PluginEventArgs(pluginInfo));
|
|
return true;
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"加载程序集失败: {assemblyPath}, 错误: {ex.Message}");
|
return false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 加载指定目录下所有DLL
|
/// </summary>
|
public static void LoadAssembliesFromDirectory(string directoryPath)
|
{
|
if (!Directory.Exists(directoryPath))
|
{
|
Debug.WriteLine($"插件目录不存在: {directoryPath}");
|
return;
|
}
|
|
// 加载主DLL
|
var dllFiles = Directory.GetFiles(directoryPath, "*.dll")
|
.Where(f => !f.EndsWith(".resources.dll") &&
|
!f.Contains("\\ref\\") &&
|
!Path.GetFileName(f).StartsWith("System.") &&
|
!Path.GetFileName(f).StartsWith("Microsoft."))
|
.ToList();
|
|
// 先加载没有依赖的，再加载可能有依赖的
|
var orderedFiles = dllFiles.OrderBy(f =>
|
File.ReadAllBytes(f).Length).ToList(); // 按文件大小排序，小的先加载
|
|
foreach (var dllFile in orderedFiles)
|
{
|
try
|
{
|
LoadAssembly(dllFile);
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"加载DLL失败: {dllFile}, 错误: {ex.Message}");
|
}
|
}
|
}
|
|
/// <summary>
|
/// 卸载指定插件
|
/// </summary>
|
public static bool UnloadPlugin(string pluginName)
|
{
|
lock (_lock)
|
{
|
var pluginInfo = PluginInfos.FirstOrDefault(p => p.Name == pluginName);
|
if (pluginInfo == null)
|
return false;
|
|
try
|
{
|
// 从工具字典中移除
|
foreach (var process in pluginInfo.Processes)
|
{
|
LoadedProcesses.Remove(process.Key);
|
|
// 从分类字典中移除
|
if (CategorizedProcesses.ContainsKey(process.Value.Category))
|
{
|
CategorizedProcesses[process.Value.Category].Remove(process.Key);
|
}
|
}
|
|
// 触发事件
|
PluginUnloaded?.Invoke(null, new PluginEventArgs(pluginInfo));
|
|
// 从列表中移除
|
PluginInfos.Remove(pluginInfo);
|
|
// 尝试卸载程序集（需要.NET Core 3.0+）
|
var fileName = Path.GetFileName(pluginInfo.AssemblyPath);
|
if (_loadContexts.TryGetValue(fileName, out var context))
|
{
|
_loadContexts.Remove(fileName);
|
if (context.IsCollectible)
|
{
|
context.Unload();
|
}
|
}
|
|
return true;
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"卸载插件失败: {pluginName}, 错误: {ex.Message}");
|
return false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 扫描程序集中的工具类
|
/// </summary>
|
private static PluginInfo ScanAssemblyForProcesses(Assembly assembly, string pluginName)
|
{
|
var pluginInfo = new PluginInfo
|
{
|
Name = pluginName,
|
AssemblyPath = assembly.Location,
|
Version = assembly.GetName().Version?.ToString() ?? "1.0.0",
|
LoadedTime = DateTime.Now
|
};
|
|
try
|
{
|
var processTypes = assembly.GetTypes()
|
.Where(t => t.IsClass && !t.IsAbstract &&
|
typeof(IProcess).IsAssignableFrom(t))
|
.ToList();
|
foreach (var type in processTypes)
|
{
|
try
|
{
|
if (type.IsDefined(typeof(ProcessAttribute), false) || type.IsDefined(typeof(CategoryAttribute), false))
|
{
|
// 使用特性获取元数据，避免实例化
|
var processAttr = type.GetCustomAttribute<ProcessAttribute>();
|
var categoryAttr = type.GetCustomAttribute<CategoryAttribute>();
|
|
string displayName;
|
string category = "其他";
|
string description = "";
|
int order = 0;
|
|
if (processAttr != null)
|
{
|
displayName = processAttr.DisplayName;
|
category = processAttr.Category;
|
description = processAttr.Description;
|
order = processAttr.Order;
|
}
|
else
|
{
|
// 如果没有特性，使用类型名称
|
displayName = type.Name;
|
}
|
|
if (categoryAttr != null)
|
{
|
category = categoryAttr.Category;
|
}
|
|
// 避免重复名称
|
int suffix = 1;
|
string originalName = displayName;
|
while (LoadedProcesses.ContainsKey(displayName))
|
{
|
displayName = $"{originalName}_{suffix}";
|
suffix++;
|
}
|
|
string fullName = type.AssemblyQualifiedName;
|
|
// 添加到总字典
|
LoadedProcesses[displayName] = fullName;
|
|
// 按分类组织
|
if (!CategorizedProcesses.ContainsKey(category))
|
{
|
CategorizedProcesses[category] = new Dictionary<string, string>();
|
}
|
CategorizedProcesses[category][displayName] = fullName;
|
|
// 添加到插件信息
|
pluginInfo.Processes[displayName] = new ProcessInfo
|
{
|
TypeName = fullName,
|
DisplayName = displayName,
|
Category = category,
|
Description = description,
|
Order = order
|
};
|
|
Debug.WriteLine($"注册工具: {displayName} ({category})");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"注册工具类型 {type.Name} 失败: {ex.Message}");
|
}
|
}
|
}
|
catch (ReflectionTypeLoadException ex)
|
{
|
Debug.WriteLine($"扫描程序集 {assembly.FullName} 时类型加载失败: {ex.Message}");
|
foreach (var loaderEx in ex.LoaderExceptions)
|
{
|
Debug.WriteLine($"加载异常: {loaderEx?.Message}");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"扫描程序集 {assembly.FullName} 失败: {ex.Message}");
|
}
|
|
return pluginInfo;
|
}
|
|
/// <summary>
|
/// 从配置文件加载插件
|
/// </summary>
|
private static void LoadFromConfig()
|
{
|
var configPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "plugin.config.json");
|
if (File.Exists(configPath))
|
{
|
try
|
{
|
var config = File.ReadAllText(configPath);
|
var pluginConfigs = JsonConvert.DeserializeObject<List<PluginConfig>>(config);
|
|
foreach (var pluginConfig in pluginConfigs)
|
{
|
if (pluginConfig.Enabled)
|
{
|
var pluginPath = Path.Combine(PluginDirectory, pluginConfig.AssemblyName);
|
LoadAssembly(pluginPath, pluginConfig.Name);
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"读取插件配置失败: {ex.Message}");
|
}
|
}
|
}
|
|
/// <summary>
|
/// 清空已加载的程序集
|
/// </summary>
|
private static void ClearLoadedAssemblies()
|
{
|
lock (_lock)
|
{
|
_loadedAssemblies.Clear();
|
_loadContexts.Clear();
|
LoadedProcesses.Clear();
|
CategorizedProcesses.Clear();
|
PluginInfos.Clear();
|
}
|
}
|
|
/// <summary>
|
/// 重新加载所有插件
|
/// </summary>
|
public static void ReloadPlugins()
|
{
|
lock (_lock)
|
{
|
ClearLoadedAssemblies();
|
LoadAllPlugins();
|
}
|
}
|
|
/// <summary>
|
/// 获取所有分类
|
/// </summary>
|
public static List<string> GetCategories()
|
{
|
return CategorizedProcesses.Keys.OrderBy(k => k).ToList();
|
}
|
|
/// <summary>
|
/// 获取指定分类的工具
|
/// </summary>
|
public static Dictionary<string, string> GetProcessesByCategory(string category)
|
{
|
return CategorizedProcesses.ContainsKey(category)
|
? CategorizedProcesses[category]
|
: new Dictionary<string, string>();
|
}
|
|
/// <summary>
|
/// 创建工具实例
|
/// </summary>
|
public static IProcess CreateProcess(string displayName)
|
{
|
lock (_lock)
|
{
|
if (!LoadedProcesses.TryGetValue(displayName, out string typeName))
|
{
|
throw new KeyNotFoundException($"未找到工具: {displayName}");
|
}
|
|
try
|
{
|
var type = Type.GetType(typeName);
|
if (type == null)
|
{
|
// 尝试从已加载的程序集中查找
|
foreach (var assembly in _loadedAssemblies)
|
{
|
type = assembly.GetType(typeName.Split(',')[0]);
|
if (type != null) break;
|
}
|
}
|
|
if (type == null)
|
{
|
throw new TypeLoadException($"无法加载类型: {typeName}");
|
}
|
|
return Activator.CreateInstance(type) as IProcess;
|
}
|
catch (Exception ex)
|
{
|
throw new ApplicationException($"创建工具实例失败: {displayName}", ex);
|
}
|
}
|
}
|
}
|
}
|
