C#浅谈类实体与DataTable执行效率

问题根源：现在编码已经习惯了面向对象编码，数据库访问层也由ORM代替了ADO，DataTable一般用的越来越少，可是一些公用方法还是用到DataTable了，理由其实很简单就是公用方法里不用DataTable就得用反射访问实体集合，反射的访问效率比DataTable低很多是毋庸置疑的。可是我还是觉得很苦恼，心中有两个疑问：

1、访问实体集合到底比访问DataTable慢多少呢？

2、后台数据层提供的是实体集合，调用公用方法势必要转为DataTable，那转换耗时多少呢？

接下来我新建了一个控制台程序，简单写了一个实体对象：

public class TestEntity
    {
        public string Col1 { get; set; }
        public string Col2 { get; set; }
        public string Col3 { get; set; }
        public string Col4 { get; set; }
        public string Col5 { get; set; }
        public string Col6 { get; set; }
        public string Col7 { get; set; }
        public string Col8 { get; set; }
        public string Col9 { get; set; }
        public string Col10 { get; set; }
        public string Col11 { get; set; }
        public string Col12 { get; set; }
        public string Col13 { get; set; }
        public string Col14 { get; set; }
        public string Col15 { get; set; }
        public string Col16 { get; set; }
        public string Col17 { get; set; }
        public string Col18 { get; set; }
        public string Col19 { get; set; }
        public string Col20 { get; set; }
        public string Col21 { get; set; }
        public string Col22 { get; set; }
        public string Col23 { get; set; }
        public string Col24 { get; set; }
        public string Col25 { get; set; }
        public string Col26 { get; set; }
        public string Col27 { get; set; }
        public string Col28 { get; set; }
        public string Col29 { get; set; }
        public string Col30 { get; set; }
    }

然后写了一个创建实体集合的方法：

private static IList<TestEntity> CreateList(long count)
        {
            var result = new List<TestEntity>();

            for (var i = 0; i < count; i++)
            {
                var entity = new TestEntity();
                var propertys = typeof(TestEntity).GetProperties();
                foreach (var p in propertys)
                {
                    p.SetValue(entity, i.ToString());
                }
                result.Add(entity);
            }

            return result;
        }

然后写了一个创建DataTable的方法：

private static DataTable CreateTable(long count)
        {
            var result = new DataTable();

            for (var i = 1; i <= 30; i++)
            {
                result.Columns.Add(new DataColumn("Col" + i.ToString(), Type.GetType("System.String")));
            }

            for (var i = 0; i < count; i++)
            {
                var row = result.NewRow();
                for (var j = 1; j <= 30; j++)
                {
                    row["Col" + j.ToString()] = i;
                }
                result.Rows.Add(row);
            }

            return result;
        }

准备工作做好了，现在写了两个读取的方法：

private static void ReadEntity<T>(IList<T> list)
        {
            for (var i = 0; i < list.Count; i++)
            {
                var entity = list[i];
                var propertys = typeof(T).GetProperties();
                for (var j = 0; j < propertys.Count(); j++)
                {
                    var value = "";
                    value += propertys[j].GetValue(entity).ToString();
                }
            }
        }

private static void ReadDataTable(DataTable data)
        {
            for (var i = 0; i < data.Rows.Count; i++)
            {
                for (var j = 0; j < data.Columns.Count; j++)
                {
                    var value = "";
                    value += data.Rows[i][j].ToString();
                }
            }
        }

记录一下耗时，通过控制台打印出来：

static void Main(string[] args)
        {
            for (var i = 0; i < 10; i++)
            {
                var count = Convert.ToInt64(Console.ReadLine());
                if (count == 0) break;

                var list = CreateList(count);


                DateTime start = DateTime.Now;
                var table = CreateTable(count);
                DateTime end = DateTime.Now;

                var tick0 = (end - start).Ticks;

                start = DateTime.Now;
                ReadDataTable(table);
                end = DateTime.Now;

                var tick1 = (end - start).Ticks;

                start = DateTime.Now;
                ReadEntity(list);
                end = DateTime.Now;

                var tick2 = (end - start).Ticks;

                Console.WriteLine("DataTable:条数" + count + "耗时" + tick1.ToString());
                Console.WriteLine("反射读取Entity:条数" + count + "耗时" + tick2.ToString());
            }
        }

运行程序，输入行数，显示结果如下：

可以看出反射读取耗时与DataTable读取耗时相比2到4倍。

这时你肯定会想差这么多，看来公用方法使用DataTable是没错了。

但是，开头咱们提到的两个疑问，第一个疑问解决了，但是第二个疑问呢，转换耗时多少呢？

现在我把第二个疑问拆解了一下，转换需要进行的是，创建DataTable，遍历读取实体集合（注意一下这个不是反射），这样我就写了一个方法：

private static DataTable CreateTable(IList<TestEntity> list)
        {
            var result = new DataTable();

            for (var i = 1; i <= 30; i++)
            {
                result.Columns.Add(new DataColumn("Col" + i.ToString(), Type.GetType("System.String")));
            }

            for (var i = 0; i < list.Count; i++)
            {
                var row = result.NewRow();
                row["Col1"] = list[i].Col1;
                row["Col2"] = list[i].Col2;
                row["Col3"] = list[i].Col3;
                row["Col4"] = list[i].Col4;
                row["Col5"] = list[i].Col5;
                row["Col6"] = list[i].Col6;
                row["Col7"] = list[i].Col7;
                row["Col8"] = list[i].Col8;
                row["Col9"] = list[i].Col9;
                row["Col10"] = list[i].Col10;
                row["Col11"] = list[i].Col11;
                row["Col12"] = list[i].Col12;
                row["Col13"] = list[i].Col13;
                row["Col14"] = list[i].Col14;
                row["Col15"] = list[i].Col15;
                row["Col16"] = list[i].Col16;
                row["Col17"] = list[i].Col17;
                row["Col18"] = list[i].Col18;
                row["Col19"] = list[i].Col19;
                row["Col20"] = list[i].Col20;
                row["Col21"] = list[i].Col21;
                row["Col22"] = list[i].Col22;
                row["Col23"] = list[i].Col23;
                row["Col24"] = list[i].Col24;
                row["Col25"] = list[i].Col25;
                row["Col26"] = list[i].Col26;
                row["Col27"] = list[i].Col27;
                row["Col28"] = list[i].Col28;
                row["Col29"] = list[i].Col29;
                row["Col30"] = list[i].Col30;
                result.Rows.Add(row);
            }

            return result;
        }

在主函数增加时间记录：

start = DateTime.Now;
                CreateTable(list);
                end = DateTime.Now;

                var tick3 = (end - start).Ticks;
                Console.WriteLine("Entity:条数" + count + "耗时" + tick3.ToString());

执行结果如下：

创建DataTable加上读取与通过反射直接读取实体集合，耗时相差不是很明显了，起码不是倍率级的了，在大环境下，我个人觉得考虑到维护性和开发效率，我推荐直接使用反射写公用方法。