.NET基础 （17）反射

namespace NET.MST.Sixth.SimpleAssembly
{
/// <summary>
/// 创建一个包含私有成员、特性、方法的简单类型
/// </summary>
[Serializable]
class SimpleAssembly
{
private String _MyString;
public SimpleAssembly(String mystring)
{
_MyString = mystring;
}
public override string ToString()
{
return _MyString;
} static void Main(string[] args)
{
Console.WriteLine("简单程序集");
Console.Read();
}
}
}

partial class UseReflection
{
/// <summary>
/// 对一个程序集进行分析
/// </summary>
/// <param name="assembly"></param>
private static void AnalyzeAssembly(Assembly assembly)
{
Console.WriteLine("程序集名字：" + assembly.FullName);
Console.WriteLine("程序集位置：" + assembly.Location);
Console.WriteLine("程序集是否在GAC中：" +
assembly.GlobalAssemblyCache.ToString());
Console.WriteLine("包含程序集的模块名" +
assembly.ManifestModule.Name);
Console.WriteLine("运行程序集需要的CLR版本：" +
assembly.ImageRuntimeVersion);
Console.WriteLine("现在开始分析程序集中的模块");
Module[] modules = assembly.GetModules();
foreach (Module module in modules)
AnalyzeModule(module);
////递归分析引用程序集
////这里的代码供读者参考
//Console.WriteLine("开始分析引用的程序集");
//AssemblyName[] refassemblies = assembly.GetReferencedAssemblies();
//foreach (AssemblyName refname in refassemblies)
//{
// Assembly refassembly = Assembly.Load(refname);
// AnalyzeAssembly(refassembly);
//}
}
}
partial class UseReflection
{
/// <summary>
/// 对一个模块进行分析
/// </summary>
/// <param name="module">模块</param>
private static void AnalyzeModule(Module module)
{
Console.WriteLine("模块名：" + module.Name);
Console.WriteLine("模块的UUID：" + module.ModuleVersionId);
Console.WriteLine("开始分析模块下的类型");
Type[] types = module.GetTypes();
foreach (Type type in types)
AnalyzeType(type);
}
}
partial class UseReflection
{
/// <summary>
/// 对一个类型进行分析
/// </summary>
/// <param name="type">类型</param>
private static void AnalyzeType(Type type)
{
Console.WriteLine("类型名字：" + type.Name);
Console.WriteLine("类型的类别是：" + type.Attributes);
if (type.BaseType != null)
Console.WriteLine("类型的基类是：" + type.BaseType.Name);
Console.WriteLine("类型的GUID是：" + type.GUID);
//设置感兴趣的类型成员
BindingFlags flags = (BindingFlags.NonPublic | BindingFlags.Public |
BindingFlags.Static | BindingFlags.Instance);
//分析成员
FieldInfo[] fields = type.GetFields(flags);
if (fields.Length > )
{
Console.WriteLine("开始分析类型的成员");
foreach (FieldInfo field in fields)
AnalyzeField(field);
}
//分析包含的方法
MethodInfo[] methods = type.GetMethods(flags);
if (methods.Length > )
{
Console.WriteLine("开始分析类型的方法");
foreach (MethodInfo method in methods)
AnalyzeMethod(method);
}
//分析属性
PropertyInfo[] properties = type.GetProperties(flags);
if (properties.Length > )
{
Console.WriteLine("开始分析类型的属性");
foreach (PropertyInfo property in properties)
AnalyzeProperty(property);
}
}
}
partial class UseReflection
{
/// <summary>
/// 对一个成员进行分析，这里只做简单的分析
/// 可以进一步分析成员的可访问级别，
/// 或通过成员得到包含它的类型、模块等
/// </summary>
/// <param name="field">成员</param>
private static void AnalyzeField(FieldInfo field)
{
Console.WriteLine("成员名字：" + field.Name);
Console.WriteLine("成员的类别：" + field.Attributes);
Console.WriteLine("成员的类型名：" + field.FieldType.Name);
}
/// <summary>
/// 对一个方法进行分析
/// </summary>
/// <param name="method"></param>
private static void AnalyzeMethod(MethodInfo method)
{
Console.WriteLine("方法名字：" + method.Name);
Console.WriteLine("方法的类别：" + method.Attributes);
Console.WriteLine("开始分析方法的参数");
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length <= )
Console.WriteLine("方法没有参数");
foreach (ParameterInfo parameter in parameters)
AnalyzeParameter(parameter);
ParameterInfo retpar = method.ReturnParameter;
Console.WriteLine("分析方法的返回参数");
AnalyzeParameter(retpar);
}
/// <summary>
/// 分析方法参数
/// </summary>
/// <param name="parameter"></param>
private static void AnalyzeParameter(ParameterInfo parameter)
{
Console.WriteLine("参数名字：" + parameter.Name);
Console.WriteLine("参数的类别：" + parameter.Attributes);
Console.WriteLine("参数的类型：" + parameter.ParameterType.Name);
}
/// <summary>
/// 分析属性
/// </summary>
/// <param name="property"></param>
private static void AnalyzeProperty(PropertyInfo property)
{
Console.WriteLine("属性名字：" + property.Name);
Console.WriteLine("属性的类别：" + property.Attributes);
Console.WriteLine("是否可读：" + property.CanRead.ToString());
Console.WriteLine("是否可写：" + property.CanWrite.ToString());
}
}

/// <summary>
/// 这里的特性要求程序的运行需要完全信任的安全级别
/// </summary>
[PermissionSetAttribute(SecurityAction.Demand, Name = "FullTrust")]
partial class UseReflection
{
static void Main(string[] args)
{
//需要根据代码位置进行更新
//对程序集进行遍历分析
Assembly assembly = Assembly.LoadFrom(@"D:\project\CSHARP\SimpleAssembly.exe");
AnalyzeAssembly(assembly); //创建一个程序集中的类型的对象
//这里尝试创建SimpleAssembly对象
Console.WriteLine("利用反射创建类型");
String[] pars = { "测试反射" };
Object o = assembly.CreateInstance(assembly.GetModules()[].GetTypes()[].ToString(),
true, BindingFlags.CreateInstance, null, pars, null, null);
Console.WriteLine(o);
Console.Read();
}
}

运行程序集需要的CLR版本：v4.0.30319
现在开始分析程序集中的模块
模块名：SimpleAssembly.exe
模块的UUID：8f75ce48-76e6-40af-9f7f-adbd2fab16c6
开始分析模块下的类型
类型名字：SimpleAssembly
类型的类别是：AutoLayout, AnsiClass, Class, Serializable, BeforeFieldInit
类型的基类是：Object
类型的GUID是：c0a636a7--35f3--4ac9ac7f9fe7
开始分析类型的成员
成员名字：_MyString
成员的类别：Private
成员的类型名：String
开始分析类型的方法
方法名字：ToString
方法的类别：PrivateScope, Public, Virtual, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：String
方法名字：Main
方法的类别：PrivateScope, Private, Static, HideBySig
开始分析方法的参数
参数名字：args
参数的类别：None
参数的类型：String[]
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Void
方法名字：Equals
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
参数名字：obj
参数的类别：None
参数的类型：Object
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Boolean
方法名字：GetHashCode
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Int32
方法名字：GetType
方法的类别：PrivateScope, Public, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Type
方法名字：Finalize
方法的类别：PrivateScope, Family, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Void
方法名字：MemberwiseClone
方法的类别：PrivateScope, Family, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Object
类型名字：DownloadHelper
类型的类别是：AutoLayout, AnsiClass, Class, Public, BeforeFieldInit
类型的基类是：Object
类型的GUID是：7c376104-a9d8-3a0b-89a2-ae567c8a86d9
开始分析类型的方法
方法名字：DownloadBaiduWenku
方法的类别：PrivateScope, Public, Static, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Void
方法名字：ToString
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：String
方法名字：Equals
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
参数名字：obj
参数的类别：None
参数的类型：Object
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Boolean
方法名字：GetHashCode
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Int32
方法名字：GetType
方法的类别：PrivateScope, Public, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Type
方法名字：Finalize
方法的类别：PrivateScope, Family, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Void
方法名字：MemberwiseClone
方法的类别：PrivateScope, Family, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Object
类型名字：RARHelper
类型的类别是：AutoLayout, AnsiClass, Class, BeforeFieldInit
类型的基类是：Object
类型的GUID是：d5b4c611-21be-375b-9e4b-f4d9b3a20ad8
开始分析类型的方法
方法名字：Exists
方法的类别：PrivateScope, Public, Static, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Boolean
方法名字：CompressRAR
方法的类别：PrivateScope, Public, HideBySig
开始分析方法的参数
参数名字：path
参数的类别：None
参数的类型：String
参数名字：rarPath
参数的类别：None
参数的类型：String
参数名字：rarName
参数的类别：None
参数的类型：String
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Void
方法名字：UnRAR
方法的类别：PrivateScope, Public, HideBySig
开始分析方法的参数
参数名字：path
参数的类别：None
参数的类型：String
参数名字：rarPath
参数的类别：None
参数的类型：String
参数名字：rarName
参数的类别：None
参数的类型：String
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Boolean
方法名字：ToString
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：String
方法名字：Equals
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
参数名字：obj
参数的类别：None
参数的类型：Object
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Boolean
方法名字：GetHashCode
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Int32
方法名字：GetType
方法的类别：PrivateScope, Public, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Type
方法名字：Finalize
方法的类别：PrivateScope, Family, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Void
方法名字：MemberwiseClone
方法的类别：PrivateScope, Family, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Object
类型名字：TextHelper
类型的类别是：AutoLayout, AnsiClass, Class, Public, BeforeFieldInit
类型的基类是：Object
类型的GUID是：d80fb451--3d34--c0216b355090
开始分析类型的方法
方法名字：GetFileEncodeType
方法的类别：PrivateScope, Public, Static, HideBySig
开始分析方法的参数
参数名字：filename
参数的类别：None
参数的类型：String
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Encoding
方法名字：ToString
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：String
方法名字：Equals
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
参数名字：obj
参数的类别：None
参数的类型：Object
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Boolean
方法名字：GetHashCode
方法的类别：PrivateScope, Public, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Int32
方法名字：GetType
方法的类别：PrivateScope, Public, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Type
方法名字：Finalize
方法的类别：PrivateScope, Family, Virtual, HideBySig, VtableLayoutMask
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Void
方法名字：MemberwiseClone
方法的类别：PrivateScope, Family, HideBySig
开始分析方法的参数
方法没有参数
分析方法的返回参数
参数名字：
参数的类别：None
参数的类型：Object
利用反射创建类型
测试反射

class MainClass
{
/// <summary>
/// 使用发射的类型
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
//定义构造方法的参数
Object[] ctorParams = new Object[];
ctorParams[] = ;
ctorParams[] = ;
//发射程序集，并得到AddClass类型
Type type = CreateAssembly();
//新建AddClass对象
object ptInstance = Activator.CreateInstance(type, ctorParams);
//调用动态发射的ToString方法
Console.WriteLine(ptInstance.ToString());
//调用动态发射的GetResult方法
MethodInfo info = type.GetMethod("GetResult",new Type[]);
long result = (long)info.Invoke(ptInstance, null);
Console.WriteLine(result.ToString());
Console.Read();
} /// <summary>
/// 用来动态发射一个程序集的中间代码
/// 放回发射的类型
/// 创建的中间代码相当于这样的C#代码：
// public class AddClass
//{
// private long first;
// private long second; // public AddClass(long f, long s)
// {
// first = f;
// second = s;
// }
// public long GetResult()
// {
// return first + second;
// } // public override string ToString()
// {
// return "第一个数字是：" +
// first.ToString() +
// "\r\n第二个数字是：" +
// second.ToString();
// }
// }
/// </summary>
static Type CreateAssembly()
{
//在当前应用程序域中定义新程序集
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "NewAssembly";
AssemblyBuilder assemblybuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave);
//定义模块
ModuleBuilder addclassModule = assemblybuilder.DefineDynamicModule("AddClass", "AddClass.dll");
//定义模块中的类型
TypeBuilder addclass = addclassModule.DefineType("AddClass", TypeAttributes.Public);
//这个类型将包含两个私有成员
//名字分别为：first和second
FieldBuilder first = addclass.DefineField("first", typeof(long), FieldAttributes.Private);
FieldBuilder second = addclass.DefineField("second", typeof(long), FieldAttributes.Private);
//为AddClass定义一个公共构造方法
//接受两个长整型参数
Type[] ctorParams = new Type[] { typeof(long), typeof(long) };
//AddClass的基类是System.Object
Type objType = Type.GetType("System.Object");
//得到无参数构造方法
ConstructorInfo objCtor = objType.GetConstructor(new Type[]);
//AddClass的公共构造方法
ConstructorBuilder addCtor = addclass.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorParams);
//开始生成构造方法的中间代码
ILGenerator ctorIL = addCtor.GetILGenerator();
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Call, objCtor);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Stfld, first);
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_2);
ctorIL.Emit(OpCodes.Stfld, second);
ctorIL.Emit(OpCodes.Ret);
//这里生成long GetResult()方法
//用以得到两个数字相加的结果
MethodBuilder resultMethod = addclass.DefineMethod("GetResult", MethodAttributes.Public, typeof(long), new Type[]);
//发射GetResult方法的中间代码
ILGenerator resultIL = resultMethod.GetILGenerator();
// ILGenerator.EmitWriteLine(string) 生成一个字符串对象，
//并且通过控制台输出
resultIL.EmitWriteLine("开始执行相加：");
//执行相加程序
//这里的IL代码用来导入两个成员变量，相加并返回结果
resultIL.Emit(OpCodes.Ldarg_0);
resultIL.Emit(OpCodes.Ldfld, first);
resultIL.Emit(OpCodes.Ldarg_0);
resultIL.Emit(OpCodes.Ldfld, second);
resultIL.Emit(OpCodes.Add);
resultIL.Emit(OpCodes.Ret);
//发射String ToString方法
MethodBuilder tostringMethod = addclass.DefineMethod("ToString", MethodAttributes.Virtual | MethodAttributes.Public, typeof(String), new Type[]);
ILGenerator stringIL = tostringMethod.GetILGenerator();
stringIL.Emit(OpCodes.Ldstr,"第一个数字是：");
stringIL.Emit(OpCodes.Ldarg_0);
stringIL.Emit(OpCodes.Ldflda, first);
stringIL.Emit(OpCodes.Call, typeof(long).GetMethod("ToString",new Type[]));
stringIL.Emit(OpCodes.Ldstr, "\r\n第二个数字是：");
stringIL.Emit(OpCodes.Ldarg_0);
stringIL.Emit(OpCodes.Ldflda, second);
stringIL.Emit(OpCodes.Call, typeof(long).GetMethod("ToString", new Type[]));
Type[] types = new Type[];
for (int i = ; i < types.Length; i++)
types[i] = typeof(String);
stringIL.Emit(OpCodes.Call, typeof(String).GetMethod("Concat",types));
stringIL.Emit(OpCodes.Ret);
//说明方法重载System.Object方法
addclass.DefineMethodOverride(tostringMethod, typeof(System.Object).GetMethod("ToString"));
return addclass.CreateType();
}
}

/// <summary>
/// 使用者
/// </summary>
class Customer
{
static void Main(string[] args)
{
//根据需要获得不同的产品零件
IProduct window = FactoryManager.GetProduct(RoomParts.Window);
IProduct roof = FactoryManager.GetProduct(RoomParts.Roof);
IProduct pillar = FactoryManager.GetProduct(RoomParts.Pillar);
Console.Read();
}
}
/// <summary>
/// 屋子产品的零件
/// </summary>
enum RoomParts
{
Roof,
Window,
Pillar
}
/// <summary>
/// 工厂接口
/// </summary>
interface IFactory
{
IProduct Produce();
}
/// <summary>
/// 产品接口
/// </summary>
interface IProduct
{
String GetName();
}
/// <summary>
/// 工厂管理者
/// </summary>
class FactoryManager
{
public static IProduct
GetProduct(RoomParts part)
{
IFactory factory = null;
//这里就是传统工厂模式的弊端
//工厂管理者和工厂类族耦合
switch (part)
{
case RoomParts.Pillar:
factory = new PillarFactory();
break;
case RoomParts.Roof:
factory = new RoofFactory();
break;
case RoomParts.Window:
factory = new WindowFactory();
break;
}
IProduct product = factory.Produce();
Console.WriteLine("生产了一个产品：" +
product.GetName());
return product;
}
}
#region 工厂类族
class RoofFactory : IFactory
{
public IProduct Produce()
{
return new Roof();
}
}
class WindowFactory : IFactory
{
public IProduct Produce()
{
return new Window();
}
}
class PillarFactory : IFactory
{
public IProduct Produce()
{
return new Pillar();
}
}
#endregion #region 产品类族
class Roof : IProduct
{
public String GetName()
{
return "屋顶";
}
}
class Window : IProduct
{
public String GetName()
{
return "窗户";
}
}
class Pillar : IProduct
{
public String GetName()
{
return "柱子";
}
}
#endregion

/// <summary>
/// 使用者
/// </summary>
class Customer
{
static void Main(string[] args)
{
//使用者的代码和传统实现一样
IProduct window = FactoryManager.GetProduct(RoomParts.Window);
IProduct pillar = FactoryManager.GetProduct(RoomParts.Pillar);
IProduct roof = FactoryManager.GetProduct(RoomParts.Roof);
Console.Read();
}
}
/// <summary>
/// 工厂管理类型
/// </summary>
class FactoryManager
{
public static IProduct GetProduct(RoomParts part)
{
Factory factory = new Factory();
IProduct product = factory.Produce(part);
Console.WriteLine("生产了一个产品：" +
product.GetName());
return product;
}
} /// <summary>
/// 屋子产品的零件
/// </summary>
enum RoomParts
{
Roof,
Window,
Pillar
}
/// <summary>
/// 这个特性用来附加在产品类型之上，
/// 来标注该类型代码哪个产品，方便反射使用
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
class ProductAttribute : Attribute
{
//标注零件的成员
private RoomParts _myRoomPart; public ProductAttribute(RoomParts part)
{
_myRoomPart = part;
}
public RoomParts RoomPart
{
get
{
return _myRoomPart;
}
}
}
/// <summary>
/// 这个特性用来附加在产品接口之上
/// 来标注一共实现了多少产品零件，方便反射使用
/// </summary>
[AttributeUsage(AttributeTargets.Interface)]
class ProductListAttribute : Attribute
{
private Type[] _myList; public ProductListAttribute(Type[] Products)
{
_myList = Products;
}
public Type[] ProductList
{
get
{
return _myList;
}
}
} #region 产品类族
/// <summary>
/// 产品零件接口，
/// 需要添加所有实现该接口的列表
/// </summary>
[ProductList(new Type[]{
typeof(Roof),
typeof(Window),
typeof(Pillar)})]
interface IProduct
{
String GetName();
}
/// <summary>
/// 屋顶类型
/// </summary>
[Product(RoomParts.Roof)]
class Roof : IProduct
{
public String GetName()
{
return "屋顶";
}
}
/// <summary>
/// 窗户类型
/// </summary>
[Product(RoomParts.Window)]
class Window : IProduct
{
public String GetName()
{
return "窗户";
}
}
/// <summary>
/// 柱子类型
/// </summary>
[Product(RoomParts.Pillar)]
class Pillar : IProduct
{
public String GetName()
{
return "柱子";
}
}
#endregion #region 工厂类
/// <summary>
/// 工厂类型，这里不再需要一个类族，
/// 而只需要一个工厂类型
/// </summary>
class Factory
{
public IProduct Produce(RoomParts part)
{
//通过反射，从IProduct 接口中获得属性,
//从而获得所有的产品零件列表
ProductListAttribute Attr = (ProductListAttribute)
Attribute.GetCustomAttribute(typeof(IProduct),
typeof(ProductListAttribute)); //遍历所有的实现产品零件类型
foreach (Type type in Attr.ProductList)
{
//利用反射查找其属性
ProductAttribute pa = (ProductAttribute)
Attribute.GetCustomAttribute(
type, typeof(ProductAttribute));
//确定是否是需要的零件
if (pa.RoomPart == part)
{
//再一次利用反射
//创建产品零件类型
Object product = Assembly.GetExecutingAssembly().
CreateInstance(type.FullName);
return product as IProduct;
}
}
//不应该到达这里
return null;
}
}
#endregion