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 == 0) {
                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(1) });
                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);就能很方便的获取一个实体类集合。