c#反射实践

  1，准备如下的XML文件

1.   <TestConfig>
2.     <Test1 Name="aaa" Code="001" />
3.     <Test2 Name="bbb" Code="002" DefaultText="Wellcome" />
4.     <Test3 Name="ccc" Code="003" >
5.       <Item Name="item1" Value="item1" />
6.       <Item Name="item2" Value="item2" />
7.     </Test3>
8.   </TestConfig> 

  2，新建与XML文件中节点名相同的数据类，用来保存配置文件中各个节点的设定值。按照上面XML文件结构，创建以下类：

1.   using System;
2.   using System.Collections.Generic;
3.   using System.Text;
4. namespace reflection.config
5. {
6.     //Test1节点对应的Class
7.     public class Test1
8.     {
9.         //构造器
10.         public Test1()
11.         {
12.             //
13.         }
14. 
    
15.         //节点属性-Name
16.         private string name;
17.         public string Name
18.         {
19.             set { this.name = value; }
20.             get { return this.name; }
21.         }
22. 
    
23.         //节点属性-Code
24.         private string code;
25.         public string Code
26.         {
27.             set { this.code = value; }
28.             get { return this.code; }
29.         }    
30.     }
31. }

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. 
   
5. namespace reflection.config
6. {
7.     //Test2节点对应的Class
8.     public class Test2
9.     {
10.         //构造器
11.         public Test2()
12.         {
13.             //
14.         }
15.         //节点属性-Name
16.         private string name;
17.         public string Name
18.         {
19.             set { this.name = value; }
20.             get { return this.name; }
21.         }
22.         //节点属性-Code
23.         private string code;
24.         public string Code
25.         {
26.             set { this.code = value; }
27.             get { return this.code; }
28.         }
29.         //节点属性-DefaultText;
30.         private string defaultText;
31.         public string DefaultText
32.         {
33.             set { this.defaultText = value; }
34.             get { return this.defaultText; }
35.         }
36.     }
37. }
38. 
    

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. 
   
5. namespace reflection.config
6. {
7.     //节点Test3对应的Class
8.     public class Test3
9.     {
10.         //构造器
11.         public Test3()
12.         {
13.             //
14.         }
15.         //节点属性-Name
16.         private string name;
17.         public string Name
18.         {
19.             set { this.name = value; }
20.             get { return this.name; }
21.         }
22.         //节点属性-Code
23.         private string code;
24.         public string Code
25.         {
26.             set { this.code = value; }
27.             get { return this.code; }
28.         }
29.         //子节点的List-Item
30.         private List<Item> itemLst;
31.         public List<Item> ItemLst
32.         {
33.             set { this.itemLst = value; }
34.             get { return this.itemLst; }
35.         }
36.     }
37. }
38. 
    

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. 
   
5. namespace reflection.config
6. {
7.     //节点Item对应的Class
8.     public class Item
9.     {
10.         //构造器
11.         public Item()
12.         {
13.             //
14.         }
15.         //节点属性-Name
16.         private string name;
17.         public string Name
18.         {
19.             set { this.name = value; }
20.             get { return this.name; }
21.         }
22.         //节点属性-Value
23.         private string value;
24.         public string Value
25.         {
26.             set { this.value = value; }
27.             get { return this.value; }
28.         }
29.     }
30. }

注意每个类的命名，它们和XML文件中每个节点的名字必须完全相同，否则在使用反射不能对类对象进行数据设定，另外每个类中的属性名也要与文件中节点的属性一致，对于文件中存在子节点的节点，类的创建方法可参照Test3类的编写方法，用范型List<>来保存并列的子节点。

 3，节点的读取，参照下面代码中的ReadConfigInfo()和initNodeObject()方法

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. using System.Xml;
5. using System.Reflection;
7. namespace reflection.config
8. {
9.     //读取Xml文件中的配置信息时的Class
10.     public class TestConfig
11.     {
12.         //xml文件的路径
13.         private string filePath;
14.         //构造器
15.         public TestConfig(string configFilePath)
16.         {
17.             //
18.             filePath = configFilePath;
19.         }
20.         //节点属性-Test1
21.         private Test1 test1;
22.         public Test1 TestOne
23.         {
24.             set { this.test1 = value; }
25.             get { return this.test1; }
26.         }
27.         //节点属性-test2
28.         private Test2 test2;
29.         public Test2 TestTwo
30.         {
31.             set { this.test2 = value; }
32.             get { return this.test2; }
33.         }
34.         //节点属性-test3
35.         private Test3 test3;
36.         public Test3 TestThree
37.         {
38.             set { this.test3 = value; }
39.             get { return this.test3; }
40.         }
41.         /// <summary>
42.         /// 读取XML文件中各节点信息
43.         /// </summary>
44.         public void ReadConfigInfo()
45.         {
46.             try
47.             {
48.                 XmlDocument xmlDoc = new XmlDocument();
49.                 xmlDoc.Load(filePath);
50.                 Type selfType = this.GetType();
51.                 PropertyInfo[] proLst = selfType.GetProperties();
52.                 foreach (PropertyInfo pro in proLst)
53.                 {
54.                     Type proType = pro.PropertyType;
55.                     string typeName = proType.FullName;
56.                     //创建节点对象
57.                     object nodeObj = Activator.CreateInstance(proType);
58.                     initNodeObject(xmlDoc, nodeObj, 0);
59.                     pro.SetValue(this, nodeObj, null);
60.                 }
61.                 //读取节点Test1的数据
62.                 /*Test1 t1 = new Test1();
63.                 initNodeObject(xmlDoc, t1, 0);
64.                 this.TestOne = t1;
65.                 //读取节点Test2的数据
66.                 Test2 t2 = new Test2();
67.                 initNodeObject(xmlDoc, t2, 0);
68.                 this.TestTwo = t2;
69.                 //读取节点Test3的数据
70.                 Test3 t3 = new Test3();
71.                 initNodeObject(xmlDoc, t3, 0);
72.                 this.TestThree = t3;*/
73.             }
74.             catch (Exception ex)
75.             {
76.                 throw new Exception("从testConfig.xml文件中读取配置信息时，发生错误!"  , ex.InnerException);
77.             }
79.         }
80.         /// <summary>
81.         /// 把XML文件中节点信息读取到指定的对象中
82.         /// </summary>
83.         /// <param name="xmlDoc">XML文件的DOC对象</param>
84.         /// <param name="nodeObj">保存节点信息的对象</param>
85.         private void initNodeObject(XmlDocument xmlDoc, Object nodeObj, int nodeIndex)
86.         {
87.             string nodeName = nodeObj.GetType().Name;
88.             //取得XML文件中对应的节点
89.             XmlNode node = xmlDoc.GetElementsByTagName(nodeName).Item(nodeIndex);
90.             //取得对象的属性列表
91.             PropertyInfo[] proLst = nodeObj.GetType().GetProperties();
92.             foreach (PropertyInfo pro in proLst)
93.             {
94.                 if (pro.PropertyType.IsGenericType == false)
95.                 {
96.                     string fieldName = pro.Name;
97.                     //取得配置文件中的设定值
98.                     string configValue = node.Attributes.GetNamedItem(fieldName).Value;
99.                     //把取得数据保存到对象的属性中
100.                     pro.SetValue(nodeObj, configValue, null);
101.                 }
102.                 else
103.                 {
104.                     Type t = pro.PropertyType;
105.                     Object olist = Activator.CreateInstance(t);
106.                     Type[] typeParam = t.GetGenericArguments();
107.                     MethodInfo addMethod = t.GetMethod("Add");
108.                     if (typeParam.Length == 1)
109.                     {
110.                         Type paramType = typeParam[0];
111.                         //取得节点名称
112.                         string childNodeName = paramType.Name;
113.                         //取得节点列表
114.                         XmlNodeList nodeLst = xmlDoc.GetElementsByTagName(childNodeName);
115.                         int count = 0;
116.                         foreach (XmlElement element in nodeLst)
117.                         {
118.                             //创建一个参数类型的实例                      
119.                             object obj = Activator.CreateInstance(paramType);
120.                             initNodeObject(xmlDoc, obj, count);
121.                             count = count + 1;
122.                             addMethod.Invoke(olist, new object[] { obj });
123.                         }
125.                         pro.SetValue(nodeObj, olist, null);
126.                     }
127.                 }
128.             }
129.         }
130.     }
131. }

代码讨论：
1，在上记代码中统一使用了类属性，即每个属性带有get和set方法，当然也可以使用类字段。
2，在ReadConfigInfo()和initNodeObject()方法中都用到反射。
在ReadConfigInfo()中使用如下语句取得需要保存Xml文件节点配置信息的类对象，
Type selfType = this.GetType();
PropertyInfo[] proLst = selfType.GetProperties(); //如果使用类字段， 应该使用GetFileds()方法，取得FieldInfo类型数组，
以下语句是用来实例化对象的，这里看不到new操作符了哦
Type proType = pro.PropertyType;
string typeName = proType.FullName;
 //创建节点对象
object nodeObj = Activator.CreateInstance(proType);
//把结果保存到相应的属性中。
pro.SetValue(this, nodeObj, null);

在initNodeObject()方法中，应用方法与上记说明基本相同，不同的是这是一个第归方法，用于取得含有子节点Xml节点中的数据。对于含有子节点的Xml节点，使用以下语句判断对应的类对象中保存字节点的属性
if (pro.PropertyType.IsGenericType == false)
{
//当前节点属性值设定
}
else
{
//取得保存子节点数据的对象类型
Type t = pro.PropertyType;
//创建对象实例
Object olist = Activator.CreateInstance(t);
//取得范型对象可以保存的数据类型
Type[] typeParam = t.GetGenericArguments();
//取得向List中添加数据的方法
MethodInfo addMethod = t.GetMethod("Add");
//其他处理可参照代码中的注释。
}

综上所述，读取XML文件配置数据的方法就写完了，以后，如果要在XML文件中追加配置信息，只需要在工程中添加对应的节点类，在TestConfig类中追加对应的类的属性就可以了。ReadConfigInfo()和initNodeObject()方法就会完成对应设定处理。