扩展DataTable支持ToList方法 - 聚财吧 - 财富知识网 - 投资聚集财富,知识就是财富,健康是最大的财富.

扩展DataTable支持ToList方法 2024/4/23 11:37:43

//反射实现方式（效率不高）
public static List<TResult> ToList<TResult>(this DataTable dt) where TResult : class, new()
{
            List<PropertyInfo> prlist = new List<PropertyInfo>();
            Type t = typeof(TResult);
            Array.ForEach<PropertyInfo>(t.GetPropertiesCache(), p => { if (dt.Columns.IndexOf(p.Name) != -1) prlist.Add(p); });
            List<TResult> oblist = new List<TResult>();
            foreach (DataRow row in dt.Rows) {
                TResult ob = new TResult();
                prlist.ForEach(p => { if (row[p.Name] != DBNull.Value) p.SetValue(ob, row[p.Name], null); });
                oblist.Add(ob);
            }
            return oblist;
  }

通过Emit下的类实现（效率最高）
public static List<TResult> ToList<TResult>(this DataTable dt) where TResult : class, new()
{
            List<TResult> list = new List<TResult>();
            if (dt == null) return list;
            DataTableEntityBuilder<TResult> eblist = DataTableEntityBuilder<TResult>.CreateBuilder(dt.Rows[0]);
            foreach(DataRow info in dt.Rows) list.Add(eblist.Build(info));
            dt.Dispose(); dt = null;
            return list;
}

public class DataTableEntityBuilder<Entity>
{
        private static readonly MethodInfo getValueMethod = typeof(DataRow).GetMethod("get_Item", new Type[] { typeof(int) });
        private static readonly MethodInfo isDBNullMethod = typeof(DataRow).GetMethod("IsNull", new Type[] { typeof(int) });
        private delegate Entity Load(DataRow dataRecord);
        private Load handler;
        private DataTableEntityBuilder() { }
        public Entity Build(DataRow dataRecord) {
            return handler(dataRecord);
        }
        public static DataTableEntityBuilder<Entity> CreateBuilder(DataRow dataRecord) {
            DataTableEntityBuilder<Entity> dynamicBuilder = new DataTableEntityBuilder<Entity>();
            DynamicMethod method = new DynamicMethod("DynamicCreateEntity", typeof(Entity), new Type[] { typeof(DataRow) }, typeof(Entity), true);
            ILGenerator generator = method.GetILGenerator();
            LocalBuilder result = generator.DeclareLocal(typeof(Entity));
            generator.Emit(OpCodes.Newobj, typeof(Entity).GetConstructor(Type.EmptyTypes));
            generator.Emit(OpCodes.Stloc, result);
            for (int i = 0; i < dataRecord.ItemArray.Length; i++) {
                PropertyInfo propertyInfo = typeof(Entity).GetProperty(dataRecord.Table.Columns[i].ColumnName);
                Label endIfLabel = generator.DefineLabel();
                if (propertyInfo != null && propertyInfo.GetSetMethod() != null) {
                    generator.Emit(OpCodes.Ldarg_0);
                    generator.Emit(OpCodes.Ldc_I4, i);
                    generator.Emit(OpCodes.Callvirt, isDBNullMethod);
                    generator.Emit(OpCodes.Brtrue, endIfLabel);
                    generator.Emit(OpCodes.Ldloc, result);
                    generator.Emit(OpCodes.Ldarg_0);
                    generator.Emit(OpCodes.Ldc_I4, i);
                    generator.Emit(OpCodes.Callvirt, getValueMethod);
                    generator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
                    generator.Emit(OpCodes.Callvirt, propertyInfo.GetSetMethod());
                    generator.MarkLabel(endIfLabel);
                }
            }
            generator.Emit(OpCodes.Ldloc, result);
            generator.Emit(OpCodes.Ret);
            dynamicBuilder.handler = (Load)method.CreateDelegate(typeof(Load));
            return dynamicBuilder;
        }
    }

http://itworktor.blog.163.com/blog/static/1752030292010111032535751/

public static class DataTableExtensions
{
    public static List<T> ToList<T>(this DataTable dt) where T : new()
    {
        var list = new List<T>();
        if (dt == null) return list;
        var len = dt.Rows.Count;
 
        for (var i = 0; i < len; i++)
        {
            var info = new T();
            foreach (DataColumn dc in dt.Rows[i].Table.Columns)
            {
                var field = dc.ColumnName;
                var value = dt.Rows[i][field].ToString();
                if (string.IsNullOrEmpty(value)) continue;
                if (IsDate(value))
                {
                    value = DateTime.Parse(value).ToString();
                }
 
                var p = info.GetType().GetProperty(field);
 
                try
                {
                    if (p.PropertyType == typeof(string))
                    {
                        p.SetValue(info, value, null);
                    }
                    else if (p.PropertyType == typeof(int))
                    {
                        p.SetValue(info, int.Parse(value), null);
                    }
                    else if (p.PropertyType == typeof(bool))
                    {
                        p.SetValue(info, bool.Parse(value), null);
                    }
                    else if (p.PropertyType == typeof(DateTime))
                    {
                        p.SetValue(info, DateTime.Parse(value), null);
                    }
                    else if (p.PropertyType == typeof(float))
                    {
                        p.SetValue(info, float.Parse(value), null);
                    }
                    else if (p.PropertyType == typeof(double))
                    {
                        p.SetValue(info, double.Parse(value), null);
                    }
                    else
                    {
                        p.SetValue(info, value, null);
                    }
                }
                catch (Exception)
                {
                    //p.SetValue(info, ex.Message, null);
                }
            }
            list.Add(info);
        }
        dt.Dispose(); dt = null;
        return list;
    }
    /// <summary>
    /// 按照属性顺序的列名集合
    /// </summary>
    public static IList<string> GetColumnNames(this DataTable dt)
    {
        DataColumnCollection dcc = dt.Columns;
        //由于集合中的元素是确定的，所以可以指定元素的个数，系统就不会分配多余的空间，效率会高点
        IList<string> list = new List<string>(dcc.Count);
        foreach (DataColumn dc in dcc)
        {
            list.Add(dc.ColumnName);
        }
        return list;
    }
    private static bool IsDate(string d)
    {
        DateTime d1;
        double d2;
        return !double.TryParse(d, out d2) && DateTime.TryParse(d, out d1);
    }
}

http://www.cnblogs.com/blackice/archive/2013/01/09/2852596.html

关闭

返回顶部