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);就能很方便的獲取一個實體類集合。