基于AppDomain的插件开发EMIT通用加载框架（四）

前面我们已经实现了IPlugin接口的插件自动加载。 但是程序使用中，可以不仅仅只有一个接口，而可能是多个接口并存，不能每个接口都手动实现代码类！怎么办？

解决方案是：泛型+EMIT。 使用泛型把自动加载和插件接口分开，使用EMIT自动生成代理类。

如4项目组成：自动加载+接口定义+接口实现+测试程序，如下图：

我们使用的方式上，仍没有什么改变：

private void FormMain_Load(object sender, EventArgs e)

{

//这里加上了泛型参数 IPlugin表示要求自动生成这个接口的代理类

var inst = PluginManager<IPlugin>.Instance;

inst.PluginChanged += OnPluginChanged;

}

void OnPluginChanged(object sender, PluginManagerEventArgs<IPlugin> e)

{

if (e.ChangeType == PluginChangeType.Created)

{

// 这里初始化插件，提供服务

e.PluginInstance.Run(DateTime.Now.ToString());

}

}

当然，最主要的项目就是"PluginLoader"

思路仍是使用RemotePluginLoader加载插件，但此类不再实现IPlugin,而是使用EMIT生成一个插件代理类，该代理类从MarshalByRefObject 继承以支持AppDomain间的通信。

public class RemotePluginLoader<T> : RemoteTypeLoader where T :class

{

protected Type pluginType;

public T Plugin { get; private set; }

protected override System.Reflection.Assembly LoadAssembly(string assemblyPath)

{

var ass = base.LoadAssembly(assemblyPath);

//查找插件

Type typePlugin = typeof(T);

this.pluginType = ass.GetTypes().Where(t => typePlugin.IsAssignableFrom(t)).FirstOrDefault();

//生成代理插件类，并从MarshalByRefObject继承以支持AppDomain通信

this.Plugin = InterfaceProxyBuilder<T>.CreateProxy((T)System.Activator.CreateInstance(pluginType), typeof(MarshalByRefObject));

return ass;

}

/// <summary>

///直接在远程Domain中，执行方法。要求支持序列化

/// </summary>

/// <param name="action">执行的匿名方法</param>

public void Execute(Action action)

{

action();

}

/// <summary>

///直接在远程Domain中，执行函数。要求支持序列化

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="fun"></param>

/// <returns></returns>

public T Execute<T>(Func<T> fun)

{

return fun();

}

在调用方，基于插件更新时，我们要求统一更新引用，也有生成一个代理类。 所不同的是，该代理类每次都要访问函数，从而每次都可以检查插件的情况并进行控制：

public class PluginCallerProxy<T> where T : class

{

private T _targetPlugin;

private T _proxyPlugin;

private PluginLoader<T> _pluginLoader;

private System.Threading.ReaderWriterLockSlim locker = new ReaderWriterLockSlim();

/// <summary>

///构造一个代理类，保存在 ProxyPlugin 属性中

/// </summary>

/// <param name="loader"></param>

public PluginCallerProxy(PluginLoader<T> loader)

{

this.PluginLoader = loader;

this.TargetPlugin = loader.Plugin;

//从函数生成代理类

this._proxyPlugin = InterfaceProxyBuilder<T>.CreateFuncProxy(() => this.TargetPlugin, typeof(object));

}

/// <summary>

///供使用的代理

/// </summary>

public T ProxyPlugin

{

get { return _proxyPlugin; }

}

#region实现

internal PluginLoader<T> PluginLoader

{

get

{

return _pluginLoader;

}

set

{

_pluginLoader = value;

this.TargetPlugin = _pluginLoader == null ? null : _pluginLoader.Plugin;

}

}

internal T TargetPlugin

{

get

{

locker.EnterReadLock();

try

{

if (_targetPlugin == null)

{

throw new PluginException("插件已经卸载");

}

return _targetPlugin;

}

finally

{

locker.ExitReadLock();

}

}

set

{

locker.EnterWriteLock();

try

{

_targetPlugin = value;

}

finally

{

locker.ExitWriteLock();

}

}

}

#endregion

}

最终得到新的插件管理类，代码如下：

public class PluginManager<T> where T : class

{

#region实现

#region字段

private static PluginManager<T> _instance = null;

private FileSystemWatcher pluginWatcher;

private Timer timerProcess = null;

private ConcurrentDictionary<string, FileSystemEventArgs> changedPlugins = new ConcurrentDictionary<string, FileSystemEventArgs>();

private ConcurrentDictionary<string, PluginCallerProxy<T>> plugins = new ConcurrentDictionary<string, PluginCallerProxy<T>>();

#endregion

static PluginManager()

{

if (_instance == null)

{

lock (typeof(PluginManager<T>))

{

if (_instance == null)

_instance = new PluginManager<T>();

}

}

}

private PluginManager()

{

string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "plugins");

//监控

this.pluginWatcher = new FileSystemWatcher(path, "*.dll");

this.pluginWatcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName;

this.pluginWatcher.Changed += OnPluginChanged;

this.pluginWatcher.Created += OnPluginChanged;

this.pluginWatcher.Deleted += OnPluginChanged;

this.pluginWatcher.Renamed += OnPluginRenamed;

pluginWatcher.EnableRaisingEvents = true;

timerProcess = new Timer(new TimerCallback(e => this.ProcessChangedPlugin()));

//加载所有

Directory.GetFiles(path, "*.dll").ToList().ForEach(file =>

{

FileInfo fi = new FileInfo(file);

this.changedPlugins[fi.Name] = new FileSystemEventArgs(WatcherChangeTypes.Created, fi.DirectoryName, fi.Name);

});

this.timerProcess.Change(10, -1);

}

void OnPluginRenamed(object sender, RenamedEventArgs e)

{

//重命名，理解为去掉原来的，增加新命名的

FileInfo old = new FileInfo(e.OldFullPath);

this.changedPlugins[old.Name] = new FileSystemEventArgs(WatcherChangeTypes.Deleted, old.DirectoryName, old.Name);

FileInfo n = new FileInfo(e.FullPath);

this.changedPlugins[n.Name] = new FileSystemEventArgs(WatcherChangeTypes.Created, n.DirectoryName, n.Name);

//1秒后再处理

this.timerProcess.Change(1000, -1);

}

void OnPluginChanged(object sender, FileSystemEventArgs e)

{

Debug.Print(e.Name + e.ChangeType);

//记录变更

this.changedPlugins[e.Name] = e;

//1秒后再处理

this.timerProcess.Change(1000, -1);

}

protected void ProcessChangedPlugin()

{

#region处理插件变化

foreach (var kv in this.changedPlugins)

{

FileSystemEventArgs e;

if (changedPlugins.TryRemove(kv.Key, out e))

{

Debug.Print(e.Name + "=>" + e.ChangeType);

switch (e.ChangeType)

{

case WatcherChangeTypes.Created:

{

//加载

var loader = new PluginLoader<T>(e.Name);

var proxy = new PluginCallerProxy<T>(loader);

plugins.TryAdd(e.Name, proxy);

OnPluginChange(new PluginManagerEventArgs<T>(e.Name, PluginChangeType.Created, proxy.ProxyPlugin));

}

break;

case WatcherChangeTypes.Deleted:

{

PluginCallerProxy<T> proxy;

if (plugins.TryRemove(e.Name, out proxy))

{

OnPluginChange(new PluginManagerEventArgs<T>(e.Name, PluginChangeType.Deleted, proxy.ProxyPlugin));

var loader = proxy.PluginLoader;

proxy.PluginLoader = null;

loader.Unload();

}

}

break;

case WatcherChangeTypes.Changed:

{

PluginCallerProxy<T> proxy;

if (plugins.TryGetValue(e.Name, out proxy))

{

OnPluginChange(new PluginManagerEventArgs<T>(e.Name, PluginChangeType.Deleted, proxy.ProxyPlugin));

var loader = proxy.PluginLoader;

loader.Unload();

loader = new PluginLoader<T>(e.Name);

proxy.PluginLoader = loader;

OnPluginChange(new PluginManagerEventArgs<T>(e.Name, PluginChangeType.Created, proxy.ProxyPlugin));

}

}

break;

}

}

}

#endregion

}

protected virtual void OnPluginChange(PluginManagerEventArgs<T> e)

{

if (PluginChanged != null)

{

PluginChanged(this, e);

}

}

#endregion

#region公共

public static PluginManager<T> Instance

{

get

{

return _instance;

}

}

public event PluginChangeHandle<T> PluginChanged;

#endregion

}

附：

1. EMIT代理生成

/// <summary>

///从接口 TPlugin 生成代理类

/// </summary>

/// <typeparam name="TPlugin">要求是一个接口</typeparam>

public static class InterfaceProxyBuilder<TPlugin> where TPlugin : class

{

private static ConcurrentDictionary<Type, Type> proxies = new ConcurrentDictionary<Type, Type>();

private static void CheckTargetType(Type targetType)

{

if (!targetType.IsInterface)

{

throw new NotImplementedException("T 必须为接口");

}

}

/// <summary>

///生成接口实例对像的代理

/// </summary>

/// <typeparam name="TObject"></typeparam>

/// <param name="target"></param>

/// <returns></returns>

public static TPlugin CreateProxy<TObject>(TObject target, Type baseType) where TObject : TPlugin

{

Type targetType =typeof(TPlugin);

CheckTargetType(targetType);

var proxyType = proxies.GetOrAdd(targetType, t =>

{

return CreateProxyType(t, baseType);

});

return System.Activator.CreateInstance(proxyType, target) as TPlugin;

}

/// <summary>

///生成一个接口的代理类，并从baseType继承

/// </summary>

/// <param name="targetType">接口类型</param>

/// <param name="baseType">基类</param>

/// <returns>代理类</returns>

public static Type CreateProxyType(Type targetType, Type baseType)

{

Debug.Assert(targetType.IsInterface,"必须是接口");

string typeName = string.Concat(targetType.FullName, "_Proxy");

AssemblyName assemblyName = new AssemblyName("DynamicAssembly");

AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);

var module = assemblyBuilder.DefineDynamicModule("DynamicProxy", "DynamicAssembly.dll");

//声明类

var typeBuilder = module.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed, baseType, new Type[] { targetType }); //

//实现类

//字段

var fieldBuilder = typeBuilder.DefineField("target", targetType, FieldAttributes.Private);

fieldBuilder.SetConstant(null);

//构造函数

var cnstBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { targetType });

{

var il = cnstBuilder.GetILGenerator();

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Ldarg_1);

il.Emit(OpCodes.Stfld, fieldBuilder);

il.Emit(OpCodes.Ret);

}

//属性

Dictionary<MethodInfo, MethodBuilder> map = new Dictionary<MethodInfo, MethodBuilder>();

//方法代理

var methods = targetType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);

methods.ToList().ForEach(mi =>

{

var retType = mi.ReturnType;

var parmTypes = mi.GetParameters().ToList().ConvertAll(pi => pi.ParameterType).ToArray();

MethodAttributes methodAttrs = mi.Attributes & (~MethodAttributes.Abstract);

var methodBuilder = typeBuilder.DefineMethod(mi.Name, methodAttrs, CallingConventions.Standard, mi.ReturnType, parmTypes);

//方法体

{

var il = methodBuilder.GetILGenerator();

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Ldfld, fieldBuilder);

if (parmTypes.Length > 0)

{

for (int i = 1; i <= parmTypes.Length; ++i)

{

switch (i)

{

case 0:

il.Emit(OpCodes.Ldarg_0);

break;

case 1:

il.Emit(OpCodes.Ldarg_1);

break;

case 2:

il.Emit(OpCodes.Ldarg_2);

break;

case 3:

il.Emit(OpCodes.Ldarg_3);

break;

default:

il.Emit(OpCodes.Ldarg_S, i);

break;

}

}

}

il.Emit(OpCodes.Callvirt, mi);

if (mi.ReturnType == typeof(void))

{

il.Emit(OpCodes.Pop);

}

il.Emit(OpCodes.Ret);

}

map.Add(mi, methodBuilder);

});

var props = targetType.GetProperties();

props.ToList().ForEach(pi =>

{

var propBuilder = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, pi.ReflectedType, null);

if (pi.CanRead)

{

var mi = pi.GetGetMethod();

Debug.Assert(map.ContainsKey(mi));

var builder = map[mi];

propBuilder.SetGetMethod(builder);

}

if (pi.CanWrite)

{

var mi = pi.GetSetMethod();

Debug.Assert(map.ContainsKey(mi));

var builder = map[mi];

propBuilder.SetSetMethod(builder);

}

});

var ret = typeBuilder.CreateType();

#if DEBUG

assemblyBuilder.Save(string.Concat(typeName, "_", DateTime.Now.ToString("yyyyMMddHHmmss") , ".dll"));

#endif

return ret;

}

public static TPlugin CreateFuncProxy(Func<TPlugin> targetFunc, Type baseType)

{

Type targetType = typeof(TPlugin);

CheckTargetType(targetType);

var proxyType = proxies.GetOrAdd(typeof(Func<TPlugin>), t =>

{

return CreateFuncProxyType(t, baseType);

});

return System.Activator.CreateInstance(proxyType, targetFunc) as TPlugin;

}

/// <summary>

///生成一个接口工厂的代理类，并从baseType继承

/// </summary>

/// <param name="targetType">接口工厂类型要求必须为 Func&lt;TPlugin&gt;</param>

/// <param name="baseType">基类</param>

/// <returns>代理类</returns>

public static Type CreateFuncProxyType(Type targetType, Type baseType)

{

var miInvoke = targetType.GetMethod("Invoke");

Debug.Assert(miInvoke != null, "Func<T>.Invoke 必须有");

Type interfaceType = miInvoke.ReturnType;

string typeName = string.Concat(interfaceType.FullName, "_FuncProxy");

AssemblyName assemblyName = new AssemblyName("DynamicAssembly");

AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);

var module = assemblyBuilder.DefineDynamicModule("DynamicProxy", "DynamicAssembly.dll");

//声明类

var typeBuilder = module.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed, baseType, new Type[] { interfaceType }); //

//实现类

//字段

var fieldBuilder = typeBuilder.DefineField("targetFunc", targetType, FieldAttributes.Private);

fieldBuilder.SetConstant(null);

//构造函数

var cnstBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { targetType });

{

var il = cnstBuilder.GetILGenerator();

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Ldarg_1);

il.Emit(OpCodes.Stfld, fieldBuilder);

il.Emit(OpCodes.Ret);

}

//属性

Dictionary<MethodInfo, MethodBuilder> map = new Dictionary<MethodInfo, MethodBuilder>();

//方法代理

var methods = interfaceType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);

methods.ToList().ForEach(mi =>

{

var retType = mi.ReturnType;

var parmTypes = mi.GetParameters().ToList().ConvertAll(pi => pi.ParameterType).ToArray();

MethodAttributes methodAttrs = mi.Attributes & (~MethodAttributes.Abstract);

var methodBuilder = typeBuilder.DefineMethod(mi.Name, methodAttrs, CallingConventions.Standard, mi.ReturnType, parmTypes);

//方法体

{

var il = methodBuilder.GetILGenerator();

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Ldfld, fieldBuilder);

il.Emit(OpCodes.Callvirt, miInvoke);

if (parmTypes.Length > 0)

{

for (int i = 1; i <= parmTypes.Length; ++i)

{

switch (i)

{

case 0:

il.Emit(OpCodes.Ldarg_0);

break;

case 1:

il.Emit(OpCodes.Ldarg_1);

break;

case 2:

il.Emit(OpCodes.Ldarg_2);

break;

case 3:

il.Emit(OpCodes.Ldarg_3);

break;

default:

il.Emit(OpCodes.Ldarg_S, i);

break;

}

}

}

il.Emit(OpCodes.Callvirt, mi);

if (mi.ReturnType == typeof(void))

{

il.Emit(OpCodes.Pop);

}

il.Emit(OpCodes.Ret);

}

map.Add(mi, methodBuilder);

});

var props = interfaceType.GetProperties();

props.ToList().ForEach(pi =>

{

var propBuilder = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, pi.ReflectedType, null);

if (pi.CanRead)

{

var mi = pi.GetGetMethod();

Debug.Assert(map.ContainsKey(mi));

var builder = map[mi];

propBuilder.SetGetMethod(builder);

}

if (pi.CanWrite)

{

var mi = pi.GetSetMethod();

Debug.Assert(map.ContainsKey(mi));

var builder = map[mi];

propBuilder.SetSetMethod(builder);

}

});

var ret = typeBuilder.CreateType();

#if DEBUG

assemblyBuilder.Save(string.Concat(typeName, "_Func_", DateTime.Now.ToString("yyyyMMddHHmmss"), ".dll"));

#endif

return ret;

}

}

 

2. 项目类关系图：