9.动态生成实体类，根据XML模板使用Emit生成动态类绑定到DataGrid

   在实际项目中，我们可能会遇到用户自定义XML模板字段，根据这个模板上的字段来显示相应的字段的值到DataGrid。在这种情况下，需要使用 XmlReader解析获取这个用户自定义的XML模板上有哪些字段，根据这个字段动态的生成一个实体类，之后再为此动态生成的实体类实例化，并且生成实 体类集合绑定到DataGrid即可。(注意：平时我们绑定DataGrid是先在代码里面声明了实体类，实例化多个实体化类，形成实体类集合，绑定到 DataGrid。可如果用户自定义XML格式的字段的时候，每次的实体类就不能为静态的了。必须为动态的才行。)

         一、首先我们准备一个XML格式的模板数据。模拟用户自定义的XML模板字段。这里的XML模板字段可以自由添改。

1. <NewDataSet> 
2.                 <Table  TableName='City'  TableShowName='城市' > 
3.                     <Column   Name='CityName' ShowName='城市名称' />  
4.                     <Column   Name='CityTel' ShowName='城市区号' />  
5.                     <Column   Name='CityCounty' ShowName='城市所属国家' /> 
6.                 </Table>  
7.                 <Table  TableName='User'  TableShowName='用户' > 
8.                     <Column   Name='UserName' ShowName='用户名' />  
9.                     <Column   Name='UserPwd' ShowName='用户密码' />  
10.                     <Column   Name='UserTel' ShowName='用户电话' />  
11.                     <Column   Name='UserEmail' ShowName='用户邮箱' />  
12.                 </Table>  
13.             </NewDataSet> 

        再声明一个实体类来保存字段的Name和显示名称ShowName，并且把这些字段存放到List<>中去。

1. /// <summary> 
2. /// 存放动态表格的字段 
3. /// </summary> 
4. public class GridClass 
5. { 
6. private string _ShowName; 
7. private string _Name; 
8. /// <summary> 
9. /// 显示名称 
10. /// </summary> 
11. public string ShowName 
12. { 
13. get { return _ShowName; } 
14. set { _ShowName = value; } 
15. } 
16. /// <summary> 
17. /// 字段名称 
18. /// </summary> 
19. public string Name 
20. { 
21. get { return _Name; } 
22. set { _Name = value; } 
23. } 
24. } 

        二、准备好数据之后，我们开始解析这个XML文档，并且根据此XML文档生成两个动态Tabel实体类。这里我们首先贴出关键代码，根据代码来解读：

1. List<GridClass> gridClassList = new List<GridClass>();//声明一个GridClass实体类的集合。 
2.      using (XmlReader xmlRead = XmlReader.Create(new StringReader(XMLStr))) 
3.      { 
4.          xmlRead.Read(); 
5.          while (xmlRead.Read()) 
6.          { 
7.              //获取到一个TABLE,然后转化为一个动态的实体类。 
8.              gridClassList.Clear();//循环读取Tabel元素的时候，清空GridClass实体类集合。 
9.              xmlRead.ReadToFollowing("Table");//读取Table的显示名称和Tabel的名称。 
10.              string TableShowName = xmlRead.GetAttribute("TableShowName"); 
11.              string TableName = xmlRead.GetAttribute("TableName"); 
12.              try 
13.              { 
14.                  using (XmlReader xReader2 = xmlRead.ReadSubtree())//将此Tabel读取为一个子XmlReader以供下一步使用。 
15.                  { 
16.                      while (xReader2.ReadToFollowing("Column")) 
17.                      { 
18.                          //循环读取Column元素，然后获取到Tabel的字段的显示名称和字段名称。并且添加到gridClassList 
19.                          string ShowName = xReader2.GetAttribute("ShowName"); 
20.                          string Name = xReader2.GetAttribute("Name"); 
21.                          GridClass gclass = new GridClass() { ShowName = ShowName, Name = Name }; 
22.                          gridClassList.Add(gclass); 
23.                      } 
24.                      //声明一个Dictionary<string, string>的List<>集合 
25.                      List<Dictionary<string, string>> dicList = new List<Dictionary<string, string>>(); 
26.                      //声明一个Dictionary<string, string>实体，然后为此实体赋值列名为读取Column元素得到的字段名称 
27.                      Dictionary<string, string> dic = new Dictionary<string, string>(); 
28.                      for (int j = 0; j < gridClassList.Count; j++) 
29.                      { 
30.                          dic[gridClassList[j].Name] = "--"+gridClassList[j].Name+"--"; 
31.                      } 
32.                      dicList.Add(dic); 
33.                      //动态生成一个DataGrid，并且绑定数据源 
34.                      DataGrid dgrid = new DataGrid(); 
35.                      dgrid.HorizontalAlignment = HorizontalAlignment.Left; 
36.                      dgrid.VerticalAlignment = VerticalAlignment.Top; 
37.                      dgrid.Margin = new Thickness(20, 5, 0, 0); 
38.                      dgrid.Width = 960; 
39.                      dgrid.Name = TableName; 
40.                      dgrid.ItemsSource = GetEnumerable(dicList).ToDataSource(); 
41.  
42.                      this.mainPanel.Children.Add(dgrid); 
43.                  } 
44.              } 
45.              catch (Exception ex) 
46.              { } 
47.          } 
48.      } 
49.  } 

        这里解析出关键的字段值，然后动态生成DataGrid，并且绑定了数据库。这些操作是不是很熟悉？几乎和原来绑定数据差不多？关键在以下几句：

1. //声明一个Dictionary<string, string>的List<>集合 
2.                           List<Dictionary<string, string>> dicList = new List<Dictionary<string, string>>(); 
3.                           //声明一个Dictionary<string, string>实体，然后为此实体赋值列名为读取Column元素得到的字段名称 
4.                           Dictionary<string, string> dic = new Dictionary<string, string>(); 
5.                           for (int j = 0; j < gridClassList.Count; j++) 
6.                           { 
7.                               dic[gridClassList[j].Name] = "--"+gridClassList[j].Name+"--"; 
8.                           } 
9.                           dicList.Add(dic); 

        通过这段代码我们得到了一个 List<Dictionary<string, string>>格式的Dictionary<string, string>集合。这里Dictionary的Key值，即为一列字段名，Value为该列的具体值，那么一个 Dictionary[0],Dictionary[1],Dictionary[2],Dictionary[3],Dictionary[4],Dictionary[5] 即为一行有字段名的数据，整个List<Dictionary>就是一个多行有字段名的数据，这就相当于一个类似于DataTabel的表 了。

        三、当然更关键的下一句：dgrid.ItemsSource = GetEnumerable(dicList).ToDataSource();这句话肯定是得到了一个类似于List<object>对象 集的东西，才能够绑定到ItemSource属性上来。具体是如何得到这个数据集的呢？在这里暂且先卖一个关子，请看下面源码：

1. public IEnumerable<IDictionary> GetEnumerable(List<Dictionary<string, string>> SourceList) 
2.      { 
3.          for (int i = 0; i < SourceList.Count; i++) 
4.          { 
5.              var dict = new Dictionary<string, string>(); 
6.              dict = SourceList[i]; 
7.              yield return dict; 
8.          } 
9.      } 

        这个函数是将List<Dictionary<string, string>>的数据，通过遍历的方式读取出来，使用yield return关键字来获取到IEnumerable<IDictionary>类型的返回值。在这里取到一个数据格式转换的作用，我们看下面 这个隐藏起来的类。这个类是国外友人Vladimir Bodurov 编 写的，它扩展了IEnumerable接口，让此接口可以将普通的IEnumerable集合通过Emit转化成为实体类集合。想必现在我们再来看 dgrid.ItemsSource = GetEnumerable(dicList).ToDataSource();这句代码就很清晰了吧，在这里我们就实现了动态创建类的过程。

1. DataSourceCreator.cs 
2.  
3. public static class DataSourceCreator 
4. { 
5. private static readonly Regex PropertNameRegex = 
6. new Regex(@"^[A-Za-z]+[A-Za-z1-9_]*$", RegexOptions.Singleline); 
7. public static List<object> ToDataSource(this IEnumerable<IDictionary> list) 
8. { 
9. IDictionary firstDict = null; 
10. bool hasData = false; 
11. foreach (IDictionary currentDict in list) 
12. { 
13. hasData = true; 
14. firstDict = currentDict; 
15. break; 
16. } 
17. if (!hasData) 
18. { 
19. return new List<object> { }; 
20. } 
21. if (firstDict == null) 
22. { 
23. throw new ArgumentException("IDictionary entry cannot be null"); 
24. } 
25. Type objectType = null; 
26. TypeBuilder tb = GetTypeBuilder(list.GetHashCode()); 
27. ConstructorBuilder constructor = 
28. tb.DefineDefaultConstructor( 
29. MethodAttributes.Public | 
30. MethodAttributes.SpecialName | 
31. MethodAttributes.RTSpecialName); 
32. foreach (DictionaryEntry pair in firstDict) 
33. { 
34. if (PropertNameRegex.IsMatch(Convert.ToString(pair.Key), 0)) 
35. { 
36. CreateProperty(tb, 
37. Convert.ToString(pair.Key), 
38. pair.Value == null ? 
39. typeof(object) : 
40. pair.Value.GetType()); 
41. } 
42. else 
43. { 
44. throw new ArgumentException( 
45. @"Each key of IDictionary must be 
46. alphanumeric and start with character."); 
47. } 
48. } 
49. objectType = tb.CreateType(); 
50. return GenerateArray(objectType, list, firstDict); 
51. } 
52. private static List<object> GenerateArray(Type objectType, IEnumerable<IDictionary> list, IDictionary firstDict) 
53. { 
54. var itemsSource = new List<object>(); 
55. foreach (var currentDict in list) 
56. { 
57. if (currentDict == null) 
58. { 
59. throw new ArgumentException("IDictionary entry cannot be null"); 
60. } 
61. object row = Activator.CreateInstance(objectType); 
62. foreach (DictionaryEntry pair in firstDict) 
63. { 
64. if (currentDict.Contains(pair.Key)) 
65. { 
66. PropertyInfo property = 
67. objectType.GetProperty(Convert.ToString(pair.Key)); 
68. property.SetValue( 
69. row, 
70. Convert.ChangeType( 
71. currentDict[pair.Key], 
72. property.PropertyType, 
73. null), 
74. null); 
75. } 
76. } 
77. itemsSource.Add(row); 
78. } 
79. return itemsSource; 
80. } 
81. private static TypeBuilder GetTypeBuilder(int code) 
82. { 
83. AssemblyName an = new AssemblyName("TempAssembly" + code); 
84. AssemblyBuilder assemblyBuilder = 
85. AppDomain.CurrentDomain.DefineDynamicAssembly( 
86. an, AssemblyBuilderAccess.Run); 
87. ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule"); 
88. TypeBuilder tb = moduleBuilder.DefineType("TempType" + code 
89. , TypeAttributes.Public | 
90. TypeAttributes.Class | 
91. TypeAttributes.AutoClass | 
92. TypeAttributes.AnsiClass | 
93. TypeAttributes.BeforeFieldInit | 
94. TypeAttributes.AutoLayout 
95. , typeof(object)); 
96. return tb; 
97. } 
98. private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType) 
99. { 
100. FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, 
101. propertyType, 
102. FieldAttributes.Private); 
103.  
104. PropertyBuilder propertyBuilder = 
105. tb.DefineProperty( 
106. propertyName, PropertyAttributes.HasDefault, propertyType, null); 
107. MethodBuilder getPropMthdBldr = 
108. tb.DefineMethod("get_" + propertyName, 
109. MethodAttributes.Public | 
110. MethodAttributes.SpecialName | 
111. MethodAttributes.HideBySig, 
112. propertyType, Type.EmptyTypes); 
113. ILGenerator getIL = getPropMthdBldr.GetILGenerator(); 
114. getIL.Emit(OpCodes.Ldarg_0); 
115. getIL.Emit(OpCodes.Ldfld, fieldBuilder); 
116. getIL.Emit(OpCodes.Ret); 
117. MethodBuilder setPropMthdBldr = 
118. tb.DefineMethod("set_" + propertyName, 
119. MethodAttributes.Public | 
120. MethodAttributes.SpecialName | 
121. MethodAttributes.HideBySig, 
122. null, new Type[] { propertyType }); 
123. ILGenerator setIL = setPropMthdBldr.GetILGenerator(); 
124. setIL.Emit(OpCodes.Ldarg_0); 
125. setIL.Emit(OpCodes.Ldarg_1); 
126. setIL.Emit(OpCodes.Stfld, fieldBuilder); 
127. setIL.Emit(OpCodes.Ret); 
128. propertyBuilder.SetGetMethod(getPropMthdBldr); 
129. propertyBuilder.SetSetMethod(setPropMthdBldr); 
130. } 
131. } 

本文实例源码采用VS2010+Silverlight 4.0编写，点击 SLReadDanamicClassToDataGrid.rar 下载此源码。

文转自程兴亮 51CTO博客，原文链接:http://blog.51cto.com/chengxingliang/821464