Expression构建DataTable to Entity 映射委托

 namespace Echofool.Utility.Common {
     using System;
     using System.Collections.Generic;
     using System.Data;
     using System.Linq.Expressions;
     using System.Reflection;
     using System.Reflection.Emit;

     public class DataTableUtility {

         public static IEnumerable<T> Get<T>(DataTable table) where T : new() {
             if (table == null) {
                 yield break;
             }
             if (table.Rows.Count == ) {
                 yield break;
             }
             foreach (DataRow row in table.Rows) {
                 yield return Get<T>(row);
             }
         }

         public static T Get<T>(DataRow row) where T : new() {
             return GenericCache<T>.Factory(row);
         }

         public class GenericCache<T> where T : new() {
             static GenericCache() {
                 //Factory = GetFactoryIL(); 这里写错了
                   Factory = GetFactory();
             }
             public static readonly Func<DataRow, T> Factory;

             private static Func<DataRow, T> GetFactory() {
                 var type = typeof(T);
                 var rowType = typeof(DataRow);
                 var rowDeclare = Expression.Parameter(rowType, "row");
                 var instanceDeclare = Expression.Parameter(type, "instance");
                 var newExpression = Expression.New(type);
                 var instanceExpression = Expression.Assign(instanceDeclare, newExpression);
                 var nullEqualExpression = Expression.Equal(rowDeclare, Expression.Constant(null));
                 var containsMethod = typeof(DataColumnCollection).GetMethod("Contains");
                 var indexerMethod = rowType.GetMethod("get_Item", BindingFlags.Instance | BindingFlags.Public, null,
                                                       new[] { typeof(string) },
                                                       new[] { new ParameterModifier() });
                 var setExpressions = new List<Expression>();
                 var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
                 var columns = Expression.Property(Expression.Property(rowDeclare, "Table"), "Columns");
                 foreach (var propertyInfo in properties) {
                     if (propertyInfo.CanWrite) {
                         var propertyName = Expression.Constant(propertyInfo.Name, typeof(string));
                         var checkIfContainsColumn =
                             Expression.Call(columns, containsMethod, propertyName);
                         var propertyExpression = Expression.Property(instanceDeclare, propertyInfo);
                         var value = Expression.Call(rowDeclare, indexerMethod, propertyName);
                         var proertyAssign = Expression.Assign(propertyExpression, Expression.Convert(value, propertyInfo.PropertyType));
                         setExpressions.Add(Expression.IfThen(checkIfContainsColumn, proertyAssign));
                     }
                 }
                 var checkIfRowIsNull = Expression.IfThenElse(nullEqualExpression, Expression.Empty(), Expression.Block(setExpressions));
                 var body = Expression.Block(new[] { instanceDeclare }, newExpression, instanceExpression, checkIfRowIsNull, instanceDeclare);
                 return Expression.Lambda<Func<DataRow, T>>(body, rowDeclare).Compile();
             }
         }

         public static T GetByReflection<T>(DataRow dr) where T : new() {
             var t = new T();
             if (dr != null) {
                 foreach (var p in typeof(T).GetProperties()) {
                     if (!dr.Table.Columns.Contains(p.Name)) {
                         continue;
                     }
                     var obj = dr[p.Name];
                     var set = p.GetSetMethod();
                     if (set == null) {
                         continue;
                     }
                     p.SetValue(t, obj, null);
                 }
             }
             return t;
         }
     }
 }

通过Expression动态构建DataTable映射到实体类，在三层架构中，如果使用的数据层是使用Ado.Net技术，那么加上这个DataTable to Entity的工具类，将为你减少很多代码量。

主要目的是解决DataTable到Entity的映射关系。

         public class MyClass {
             public MyClass() { }

             public MyClass(DataRow row) {
                 if (row != null) {
                     if (row.Table.Columns.Contains("Name")) {
                         this.Name = (string)row["Name"];
                     }
                     if (row.Table.Columns.Contains("Age")) {
                         this.Age = (int)row["Age"];
                     }
                 }
             }

             public string Name { get; set; }
             public int Age { get; set; }

         }

如上定义的实体类MyClass，有一个string类型的Name属性和一个int类型的Age属性。

如果自定义构造函数是可以很方便的从DataRow对象中获取数据填充实体类，但如果涉及的实体类太多，而且如果想通过定义特性标记 来实现一些字段特殊处理，构造函数的方式，需要你写太多的代码，而且很多都是重复的逻辑。

现在使用DataTableUtility.Get<MyClass>.Get(row);就能很方便的获取一个实体类。

现在使用DataTableUtility.Get<MyClass>.Get(table);就能很方便的获取一个实体类集合。