插件开发简单模型
一、前言
插件模型指应用程序由一些动态的独立模块构成，每个模块均具有一个或多个服务，并满足一定的插件协议，能够借助主程序实现主程序－插件，插件－插件之间的通讯。它定义了一套公共的接口，通过接口与插件进行通信，主要是通过反射来获取相关的属性和方法，然后再执行指定的操作。其实，它也可以理解为定义一套通用的解决方案，通过反射来获取相应的程序集的相关类型，然后执行这些指定类型的相关操作。它是一种即插即用的方案，更新及维护简便。
本文仅仅是描述插件开发的大体模型，设计比较简单，主要的步骤如下：
（1）、定义公共的接口以及抽象类。
（2）、定义和实现相关组件。
（3）、实现通用程序集反射操作类。
其中，公共的接口和抽象类定义在组件Jasen.Framework.Core中，该组件中提供通用程序集反射操作类AssemblyUtility；具体实现的相关组件为Jasen.Framework.Oracle、Jasen.Framework.Access和Jasen.Framework.SqlServer，它们都实现了Jasen.Framework.Core中的公共接口。客户端可以根据实际情况来进行相应的操作。相关组件图如下：
二、公共接口和抽象类的定义以及相关组件的定义和实现
首先，定义公共的接口以及抽象类，如下类图所示，定义一个公共的接口IDataTable，定义一个抽象类DataTable，这些公共的类型放置在最顶端的程序集中。而其他组件将分别重新创建，实现相对应的功能，如SqlServerDataTable、OracleDataTable和AccessDataTable实现各自的功能。注意：Assembly.LoadFile(file)动态加载程序集时，该程序集在当前的运行环境中必须不存在的，否则可能会出现意想不到的数据异常，因此相关组件的实现必须是独立的（仅仅是实现公共的接口）。
三、通用程序集反射操作类的实现
下面的AssemblyUtility主要是对程序集操作的通用类，可以根据指定目录以及文件列表动态获取相应的程序集。同时，也可以通过目录，文件以及程序集获取相关的类型集合和对象集合。其中需要注意的是，实现的子类必须提供默认构造函数。客户端可以通过该类获取相应的类型和对象集合，然后再执行相应的操作。这些操作都是通过动态加载程序集来实现的，代码如下所示：
{
public static IEnumerable<Type> GetImplementdTypesByDirectory<T>(string baseDirectory)
{
IList<Assembly> assemblies= GetAssemblies(baseDirectory);
List<Type> types = new List<Type>();
foreach (Assembly assembly in assemblies)
{
types.AddRange(GetImplementdTypes<T>(assembly));
}
return types;
}
public static IEnumerable<Type> GetImplementdTypes<T>(string assemblyFile)
{
if (!File.Exists(assemblyFile))
{
return null;
}
try
{
return GetImplementdTypes<T>(Assembly.LoadFile(assemblyFile));
}
catch (Exception ex)
{
return null;
}
}
public static IEnumerable<Type> GetImplementdTypes<T>(Assembly assembly)
{
if (assembly == null)
{
return null;
}
return assembly.GetExportedTypes().Where(p =>
p.IsSubclassOf(typeof(T)) && (!p.IsAbstract) && (!p.IsInterface));
}
public static IList<T> GetImplementedObjectsByDirectory<T>(string baseDirectory)
{
IList<Assembly> assemblies = GetAssemblies(baseDirectory);
List<T> entities = new List<T>();
foreach (Assembly assembly in assemblies)
{
entities.AddRange(GetImplementedObjects<T>(assembly));
}
return entities;
}
public static IList<T> GetImplementedObjects<T>(string assemblyFile)
{
if (!File.Exists(assemblyFile))
{
return null;
}
try
{
return GetImplementedObjects<T>(Assembly.LoadFile(assemblyFile));
}
catch (Exception ex)
{
return null;
}
}
public static IList<T> GetImplementedObjects<T>(Assembly assembly)
{
if (assembly == null)
{
return null;
}
IEnumerable<Type> types = GetImplementdTypes<T>(assembly);
var result = new List<T>();
foreach (Type type in types)
{
ConstructorInfo constructor = type.GetConstructor(new Type[0]);
if (constructor == null)
{
continue;
}
object instance = Activator.CreateInstance(type);
if (instance is T)
{
result.Add((T)instance);
}
}
return result;
}
public static IList<Assembly> GetAssemblies(string baseDirectory)
{
if (!Directory.Exists(baseDirectory))
{
return new List<Assembly>();
}
string[] files = Directory.GetFiles(baseDirectory, "*.dll");
return GetAssemblies(files);
}
public static IList<Assembly> GetAssemblies(string[] assemblyFiles)
{
IList<Assembly> assemblies = new List<Assembly>();
try
{
foreach (string file in assemblyFiles)
{
if (!File.Exists(file)||(!file.EndsWith(".dll",StringComparison.InvariantCultureIgnoreCase)))
{
continue;
}
assemblies.Add(Assembly.LoadFile(file));
}
}
catch (Exception ex)
{
return new List<Assembly>();
}
return assemblies;
}
}
public static IEnumerable<Type> GetImplementdTypesByDirectory<T>(string baseDirectory)
public static IEnumerable<Type> GetImplementdTypes<T>(string assemblyFile)
public static IList<T> GetImplementedObjects<T>(Assembly assembly)
以上3个方法根据不同的参数（目录、地址、程序集）来动态获取程序集中的特定类型集合，这些类型为类型T的类或者子类（非抽象类和接口）。
public static IList<T> GetImplementedObjectsByDirectory<T>(string baseDirectory)
public static IList<T> GetImplementedObjects<T>(string assemblyFile)
public static IList<T> GetImplementedObjects<T>(Assembly assembly)
而以上3个方法根据不同的参数（目录、地址、程序集）来动态获取程序集中的特定对象集合，这些对象为类型T的类或者子类（非抽象类和接口）的实例。当组件中子类存在有参构造函数时，必须实现默认构造函数。从如下代码可以看出：如果默认构造函数不存在，将不会添加该对象实例。
ConstructorInfo constructor = type.GetConstructor(new Type[0]);
if (constructor == null)
{
continue;
}
object instance = Activator.CreateInstance(type);
if (instance is T)
{
result.Add((T)instance);
}
四、通用程序集反射操作类的单元测试
AssemblyUtility类主要的单元测试如下，仅验证了正确的情况，代码如下：
{
[TestMethod()]
public void GetAssembliesTest()
{
string assemblyPath = AppDomain.CurrentDomain.BaseDirectory+"\\Files\\";
IList<Assembly> result = AssemblyUtility.GetAssemblies(assemblyPath);
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count);
}
[TestMethod()]
public void GetAssembliesByFilesTest()
{
string[] assemblyFiles = new string[] { AppDomain.CurrentDomain.BaseDirectory + "\\Jasen.Framework.Core.dll",
AppDomain.CurrentDomain.BaseDirectory + "\\Jasen.Framework.Core.Test.dll",
"www",
"ww.dll"};
IList<Assembly> result = AssemblyUtility.GetAssemblies(assemblyFiles);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
}
[TestMethod()]
public void GetImplementedObjectsByDirectoryTest()
{
string assemblyDir = AppDomain.CurrentDomain.BaseDirectory + "\\Files\\";
IList<DataTable> result = AssemblyUtility.GetImplementedObjectsByDirectory<DataTable>(assemblyDir);
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count);
}
[TestMethod()]
public void GetImplementedObjectsTest()
{
string assemblyFile =AppDomain.CurrentDomain.BaseDirectory + "\\Files\\Jasen.Framework.Oracle.dll";
IList<DataTable> result = AssemblyUtility.GetImplementedObjects<DataTable>(assemblyFile);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
}
[TestMethod()]
public void GetImplementedTypesTest()
{
string assemblyFile = AppDomain.CurrentDomain.BaseDirectory + "\\Files\\Jasen.Framework.Oracle.dll";
IEnumerable<Type> types = AssemblyUtility.GetImplementdTypes<DataTable>(assemblyFile);
Assert.IsNotNull(types);
int count = 0;
foreach (var type in types)
{
Assert.IsTrue(type.IsSubclassOf(typeof(DataTable)));
Assert.IsFalse(type.IsAbstract);
Assert.IsFalse(type.IsInterface);
count++;
}
Assert.AreEqual(1, count);
}
[TestMethod()]
public void GetImplementdTypesByDirectoryTest()
{
string assemblyDir = AppDomain.CurrentDomain.BaseDirectory + "\\Files\\";
IEnumerable<Type> types = AssemblyUtility.GetImplementdTypesByDirectory<DataTable>(assemblyDir);
Assert.IsNotNull(types);
int count = 0;
foreach (var type in types)
{
Assert.IsTrue(type.IsSubclassOf(typeof(DataTable)));
Assert.IsFalse(type.IsAbstract);
Assert.IsFalse(type.IsInterface);
count++;
}
Assert.AreEqual(3, count);
}
}
五、总结
全文中主要围绕AssemblyUtility通用类来进行讲解的，仅仅是插件开发的一个思路。具体应用的话，应该相对来说比较直接，在客户端获取相应的类型集合以及对象集合，然后再执行这些集合的具体操作即可。其中，实现的组件（插件）放置在指定的目录下，通过AssemblyUtility类即可动态加载目录下的程序集，从而获取到指定类型的数据。具体执行什么操作，实现什么功能，这些都是在组件（插件）中实现即可。
转自：http://www.cnblogs.com/jasenkin/archive/2011/07/15/component_development.html
