C# 将DataTable转换成实体（泛型+扩展方法）

1、泛型方法（1）

using System;
using System.Collections.Generic;
using System.Data;
using System.Reflection;

/// <summary>
/// 将DataTable数据源转换成实体类
/// </summary>
/// <typeparam name="T">实体</typeparam>
public static class ToModel<T> where T : new()
{
    /// <summary>
    /// 将DataTable数据源转换成实体类
    /// </summary>
    public static List<T> ConvertToModel(DataTable dt)
    {
        List<T> ts = new List<T>();
        foreach (DataRow dr in dt.Rows)
        {
            T t = new T();
            PropertyInfo[] propertys = t.GetType().GetProperties();// 获得此模型的公共属性
            foreach (PropertyInfo pi in propertys)
            {
                if (dt.Columns.Contains(pi.Name))
                {
                    if (!pi.CanWrite) continue;
                    var value = dr[pi.Name];
                    if (value != DBNull.Value)
                    {
                        switch (pi.PropertyType.FullName)
                        {
                            case "System.Decimal":
                                pi.SetValue(t, decimal.Parse(value.ToString()), null);
                                break;
                            case "System.String":
                                pi.SetValue(t, value.ToString(), null);
                                break;
                            case "System.Int32":
                                pi.SetValue(t, int.Parse(value.ToString()), null);
                                break;
                            default:
                                pi.SetValue(t, value, null);
                                break;
                        }
                    }
                }
            }
            ts.Add(t);
        }
        return ts;
    }
}

2、泛型方法（2）

public static T GetEntity<T>(DataTable table) where T : new()
{
	T entity = new T();
	foreach (DataRow row in table.Rows)
	{
		foreach (var item in entity.GetType().GetProperties())
		{
			if (row.Table.Columns.Contains(item.Name))
			{
				if (DBNull.Value != row[item.Name])
				{
					item.SetValue(entity, Convert.ChangeType(row[item.Name], item.PropertyType), null);
				}
			}
		}
	}
	return entity;
}

public static IList<T> GetEntities<T>(DataTable table) where T : new()
{
	IList<T> entities = new List<T>();
	foreach (DataRow row in table.Rows)
	{
		T entity = new T();
		foreach (var item in entity.GetType().GetProperties())
		{
			item.SetValue(entity, Convert.ChangeType(row[item.Name], item.PropertyType), null);
		}
		entities.Add(entity);
	}
	return entities;
}

​

3、泛型+扩展方法（1）

using System;
using System.Collections.Generic;
using System.Data;
using System.Reflection;

namespace DotNet
{
    public static class ExtendClass
    {
        public static IEnumerable<T> ToEntitys<T>(this DataTable dt) where T : new()
        {
            Type type = typeof(T);
            PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
            FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
            List<T> list = new List<T>();
            foreach (DataRow dr in dt.Rows)
            {
                T entity = (default(T) == null) ? Activator.CreateInstance<T>() : default(T);
                PropertyInfo[] array = properties;
                for (int i = 0; i < array.Length; i++)
                {
                    PropertyInfo property = array[i];
                    if (dt.Columns.Contains(property.Name))
                    {
                        Type valueType = property.PropertyType;
                        property.SetValue(entity, Convert.ChangeType(dr[property.Name], valueType), null);
                    }
                }
                FieldInfo[] array2 = fields;
                for (int j = 0; j < array2.Length; j++)
                {
                    FieldInfo field = array2[j];
                    if (dt.Columns.Contains(field.Name))
                    {
                        Type valueType2 = field.FieldType;
                        field.SetValue(entity, Convert.ChangeType(dr[field.Name], valueType2));
                    }
                }
                list.Add(entity);
            }
            return list;
        }
    }
}

扩展方法使用：

DataTable dt = GetTable();
var list = dt.ToEntitys<MyEntitie>();

4、泛型+扩展方法（2）

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;

namespace DotNet
{
    public static class ExtendClass
    {
        /// <summary>
        /// DataRow扩展方法：将DataRow类型转化为指定类型的实体
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <returns></returns>
        public static T ToModel<T>(this DataRow dr) where T : class, new()
        {
            return ToModel<T>(dr, true);
        }

        /// <summary>
        /// DataRow扩展方法：将DataRow类型转化为指定类型的实体
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="dateTimeToString">是否需要将日期转换为字符串，默认为转换,值为true</param>
        /// <returns></returns>
        /// <summary>
        public static T ToModel<T>(this DataRow dr, bool dateTimeToString) where T : class, new()
        {
            if (dr != null)
                return ToList<T>(dr.Table, dateTimeToString).First();
            return null;
        }
    
        /// <summary>
        /// DataTable扩展方法：将DataTable类型转化为指定类型的实体集合
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="dateTimeToString">是否需要将日期转换为字符串，默认为转换,值为true</param>
        /// <returns></returns>
        public static List<T> ToList<T>(this DataTable dt, bool dateTimeToString) where T : class, new()
        {
            List<T> list = new List<T>();
            if (dt != null)
            {
                List<PropertyInfo> infos = new List<PropertyInfo>();
                Array.ForEach<PropertyInfo>(typeof(T).GetProperties(), p =>
                {
                    if (dt.Columns.Contains(p.Name))
                    {
                        infos.Add(p);
                    }
                });
                SetList<T>(list, infos, dt, dateTimeToString);
            }
            return list;
        }
    
        private static void SetList<T>(List<T> list, List<PropertyInfo> infos, DataTable dt, bool dateTimeToString) where T : class, new()
        {
            foreach (DataRow dr in dt.Rows)
            {
                T model = new T();
                infos.ForEach(p =>
                {
                    if (dr[p.Name] != DBNull.Value)
                    {
                        object tempValue = dr[p.Name];
                        if (dateTimeToString && dr[p.Name].GetType() == typeof(DateTime))
                            tempValue = dr[p.Name].ToString();
                        try
                        {
                            p.SetValue(model, tempValue, null);
                        }
                        catch { }
                    }
                });
                list.Add(model);
            }
        }
    }

}