插件模型指应用程序由一些动态的独立模块构成,每个模块均具有一个或多个服务,并满足一定的插件协议,能够借助主程序实现主程序-插件,插件-插件之间的通讯。它定义了一套公共的接口,通过接口与插件进行通信,主要是通过反射来获取相关的属性和方法,然后再执行指定的操作。其实,它也可以理解为定义一套通用的解决方案,通过反射来获取相应的程序集的相关类型,然后执行这些指定类型的相关操作。它是一种即插即用的方案,更新及维护简便。
本文仅仅是描述插件开发的大体模型,设计比较简单,主要的步骤如下:
(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类即可动态加载目录下的程序集,从而获取到指定类型的数据。具体执行什么操作,实现什么功能,这些都是在组件(插件)中实现即可。
源代码下载:C#插件开发模型源代码