将数据表转换为通用列表的最快方法

Question

我有一个返回数据表的数据层选择方法。 它是从业务层方法调用的，然后该方法应返回强类型的通用列表。

我想做的与这个问题非常相似（但不相同）：
如何将 DataTable 转换为通用列表？< /a>

不同的是，我希望列表包含强类型对象而不是数据行（而且，我这里还没有可用的 linq）。

我担心的是表现。 业务层方法将从表示层调用，并且结果将被迭代以显示给用户。 在业务层添加额外的迭代似乎非常浪费，只有在演示时才立即再次执行，所以我希望这尽可能快。

这是一项常见的任务，所以我真的在寻找一种可以一遍又一遍重复的好模式。

Answer 1

上面示例的问题是速度非常慢。 我有一个大约有 400 行的数据表，这个转换需要 5 或 6 秒！

这看起来确实是一个非常常见的任务，所以我很惊讶没有看到有人在这里提供更高效的解决方案。

* 更新！！ *
只是为了好玩，我想尝试使用 LINQ 进行转换，而不是迭代 DataTable 并添加到我的列表中。 以下是我所做的：

   List<MyObject> returnList = new List<MyObject>();

   MyDataTable dtMyData = new MyTableAdapter().GetMyData();

   returnLists = (from l in dtMyData
                 select new MyObject
                 {
                    Active = l.IsActive,
                    Email = l.Email,
                    //...
                    //About 40 more properties
                    //...
                    ZipCode = l.Zipcode
                  }).ToList();

第一个方法（迭代每一行）花费了 5.3 秒，而使用 LINQ 的方法花费了 1.8 秒！

Answer 2

您是否提前知道DataTable 的结构和类型化对象？ 您可以使用委托来进行映射。 如果您不知道（即您所知道的只是Type 和属性），则有多种方法可以加速动态成员访问（例如HyperDescriptor）。

不管怎样，考虑一个迭代器块； 这样你就不必第二次缓冲对象； 当然，如果您只处理较小的行数，这不是问题。

您能澄清其中任何一点吗？ 我可以添加更多细节...

最简单的是，有什么问题：（

DataTable table = new DataTable {
    Columns = {
        {"Foo", typeof(int)},
        {"Bar", typeof(string)}
     }
};
for (int i = 0; i < 5000; i++) {
    table.Rows.Add(i, "Row " + i);
}

List<MyType> data = new List<MyType>(table.Rows.Count);
foreach (DataRow row in table.Rows) {
    data.Add(new MyType((int)row[0], (string)row[1]));
}

上面的问题可能会引导正确的方法...）

Answer 3

我知道这个答案很晚了，但我花了一个小时或更长时间来准备这个代码，因为我首先需要这个，然后我认为寻找这个问题的解决方案的人可能会使用这个。

为了让我的答案正确工作，您的列表属性的名称需要与数据库表列（字段）或数据表列名称相同。

解决方案：

public List<dynamic> GetListFromDT(Type className, DataTable dataTable)
        {
            List<dynamic> list = new List<dynamic>();
            foreach (DataRow row in dataTable.Rows)
            {
                object objClass = Activator.CreateInstance(className);
                Type type = objClass.GetType();
                foreach (DataColumn column in row.Table.Columns)
                {
                    PropertyInfo prop = type.GetProperty(column.ColumnName);
                    prop.SetValue(objClass, row[column.ColumnName], null);   
                }
                list.Add(objClass);
            }
            return list;
        }

如何使用？

假设您有一个名为 dtPersons 的值填充数据表，

DataTable dtPersons; //populate this datatable

那么假设您有一个具有以下属性的类。

public class Persons{
    public string Name {get; set;}
    public int Age {get; set;}
}

现在打包该方法并将其放入您的模型中。
调用如下方法。

List<dynamic> dynamicListReturned = GetListFromDT(typeof(Persons), dataTable);
List<Persons> listPersons = dynamicListReturned.Cast<Persons>().ToList();

现在您已经从 listPersons 中的数据表中获取了列表。

记住：类属性中的名称和
数据表/数据库应该相同

Answer 4

无论如何，您需要遍历数据行并将它们转换为对象，但是您可以使用构造函数编写自定义集合，该构造函数接受数据行集合，并在请求时将每个项目转换为您的对象类型，而不是全部在一次。

假设您定义了实现 IList 的自定义集合。 然后它可以有两个内部字段 - 对数据行集合的引用和 List。 List 将被初始化为数据行集合的长度，但具有空值。

现在，在索引器中，您可以检查 List 是否包含该索引处的值，如果没有，您可以使用任何有用的方法创建对象，并在返回之前将其存储在那里。

这将推迟对象的创建，直到被请求为止，并且您将只创建所请求的对象。

您的对象可能需要一个采用 DataRow 的构造函数，或者您需要某种工厂来创建它们，但这是另一个主题。

Answer 5

只是为了在一个简单的控制台应用程序中为马克的答案提供更多的用户友好性：

class Program
{
    static void Main(string[] args)
    {
        //define a DataTable obj
        DataTable table = new DataTable
        {
            Columns = {
            {"Foo", typeof(int)},
            {"Bar", typeof(string)}
         }
        };
        //populate it the DataTable 
        for (int i = 0; i < 3; i++)
        {
            table.Rows.Add(i, "Row " + i);
        }

        List<MyType> listWithTypedObjects= new List<MyType>(table.Rows.Count);
        foreach (DataRow row in table.Rows)
        {
            listWithTypedObjects.Add(new MyType((int)row[0], (string)row[1]));
        }

        Console.WriteLine(" PRINTING THE POPULATED LIST ");
        foreach (MyType objMyType in listWithTypedObjects)
        {
            Console.Write(" I have object of the type " + objMyType.ToString() + " => " );
            Console.Write(" with Prop1OfTypeInt " + objMyType.Prop1OfTypeInt.ToString() + " , ");
            Console.WriteLine(" with Prop1OfTypeInt " + objMyType.Prop2OfTypeString.ToString() + "  "); 
        }

        Console.WriteLine(" \n \n \n HIT A KEY TO EXIT THE PROGRAM ");
        Console.ReadKey();
    }
}

class MyType {

    public int Prop1OfTypeInt { get; set; }
    public string Prop2OfTypeString { get; set; } 

    /// <summary>
    /// Note the order of the passed parameters is important !!!
    /// </summary>
    public MyType( int prop1OfTypeInt , string prop2OfTypeString)
    {
        this.Prop1OfTypeInt = prop1OfTypeInt;
        this.Prop2OfTypeString = prop2OfTypeString; 

    }
}

Answer 6

public partial class issuereceive_manageroffice_bal
{
    public int issue_id{get;set;}
    public string process{get;set;}
    public DateTime issue_date{get;set;}
    public TimeSpan issue_time{get;set;}
    public string eg_no{get;set;}
    public string lotno{get;set;}
    public string clarity{get;set;}
    public string sieves{get;set;}
    public string shape{get;set;}
    public double issue_carat{get;set;}
    public int issue_pieces{get;set;}
    public int receive_pieces{get;set;}
    public double receive_carat{get;set;}
    public int kp_pieces{get;set;}
    public decimal kp_carat{get;set;}
    public double loss{get;set;}
    public string issue_manager{get;set;}
    public string issue_by{get;set;}
    public string receive_by{get;set;}
    public int status{get;set;}
    public DateTime receive_date{get;set;}
    public string receive_time{get;set;}
    public int factory_id{get;set;}

}


List<issuereceive_manageroffice_bal> issue_receive_list = new List<issuereceive_manageroffice_bal>();
issue_receive_list =
      (from DataRow dr in DataTable.Rows
      select new issuereceive_manageroffice_bal()
           {
               issue_id = 0,
               issue_time = TimeSpan.Parse("0"),
               receive_time = null,
               shape = null,
               process = dr["process"].ToString(),
               issue_date = Convert.ToDateTime(dr["issue_date"]),
               eg_no = dr["eg_no"].ToString(),
               lotno = dr["lotno"].ToString(),
               clarity = dr["clarity"].ToString(),
               sieves = dr["sieves"].ToString(),
               issue_carat = dr["issue_carat"].ToString() != "" ? double.Parse(dr["issue_carat"].ToString()) : 0,
               issue_pieces = dr["issue_pieces"].ToString() != "" ? int.Parse(dr["issue_pieces"].ToString()) : 0,
               receive_carat = dr["receive_carat"].ToString() != "" ? double.Parse(dr["receive_carat"].ToString()) : 0,
               kp_pieces = dr["kp_pieces"].ToString() != "" ? int.Parse(dr["kp_pieces"].ToString()) : 0,
               kp_carat = dr["kp_carat"].ToString() != "" ? decimal.Parse(dr["kp_carat"].ToString()) : 0,
               loss = dr["loss"].ToString() != "" ? double.Parse(dr["loss"].ToString()) : 0,
               issue_manager = dr["lotno"].ToString(),
               issue_by = dr["issue_by"].ToString(),
               receive_by = dr["receive_by"].ToString(),
               status = dr["status"].ToString() != "" ? int.Parse(dr["status"].ToString()) : 0,
               receive_date = Convert.ToDateTime(dr["receive_date"]),
               factory_id = dr["factory_id"].ToString() != "" ? int.Parse(dr["factory_id"].ToString()) : 0,

           }).ToList();