Converting DataTable to List of class

I created an extension method for DataTable to convert them into a List<T>

public static class Helper
{
    /// <summary>
    /// Converts a DataTable to a list with generic objects
    /// </summary>
    /// <typeparam name="T">Generic object</typeparam>
    /// <param name="table">DataTable</param>
    /// <returns>List with generic objects</returns>
    public static List<T> DataTableToList<T>(this DataTable table) where T : class, new()
    {
        try
        {
            List<T> list = new List<T>();

            foreach (var row in table.AsEnumerable())
            {
                T obj = new T();

                foreach (var prop in obj.GetType().GetProperties())
                {
                    try
                    {
                        PropertyInfo propertyInfo = obj.GetType().GetProperty(prop.Name);
                        propertyInfo.SetValue(obj, Convert.ChangeType(row[prop.Name], propertyInfo.PropertyType), null);
                    }
                    catch
                    {
                        continue;
                    }
                }

                list.Add(obj);
            }

            return list;
        }
        catch
        {
            return null;
        }
    }
}

Example:

DataTable dtTable = GetEmployeeDataTable();
List<Employee> employeeList = dtTable.DataTableToList<Employee>();

This "foreach" code performs faster:

private static void TestForEach(DataTable table)
{
    var categoryList = new List<Category>(table.Rows.Count);
    foreach (DataRow row in table.Rows)
    {
        var values = row.ItemArray;
        var category = new Category()
            {
                Id = values[0],
                Name = values[1],
                DisplayOrder = values[2],
                IsActive = (double)values[3] == 1 ? true : false
            };
        categoryList.Add(category);
    }
}

Than your initial code:

private static void TestMethodOriginal(DataTable table)
{
    var list = table.AsEnumerable()
        .Skip(1)
        .Select(dr =>
            new Category
                {
                    Id = Convert.ToInt64(dr.Field<double>("ID")),
                    Name = dr.Field<string>("Name"),
                    DisplayOrder =
                        Convert.ToInt32(dr.Field<double>("Display Order")),
                    IsActive =
                        dr.Field<double>("Active") == 1 ? true : false
                }).ToList();
}

Here is the test code:

public static void Main(string[] args)
{
    DataTable table = GetDataTable();
    var sw = new Stopwatch();

    sw.Start();
    TestMethodOriginal(table);
    sw.Stop();
    Console.WriteLine("Elapsed={0}", sw.ElapsedMilliseconds);

    sw.Reset();

    sw.Start();
    TestForEach(table);
    sw.Stop();
    Console.WriteLine("Elapsed={0}", sw.ElapsedMilliseconds);

    Console.ReadKey();
}

private static DataTable GetDataTable()
{
    var table = new DataTable();
    table.Columns.Add("ID", typeof(double));
    table.Columns.Add("Name", typeof(string));
    table.Columns.Add("Display Order", typeof(double));
    table.Columns.Add("Active", typeof(double));

    var rand = new Random();

    for (int i = 0; i < 100000; i++)
    {
        table.Rows.Add(i, "name" + i, rand.Next(0, i), rand.Next(0, 2));
    }
    return table;
}

Performanse time in milleseconds (LINQ vs ForEach loop):

• 1000 iterations -> 6 ms vs 1 ms
• 10000 -> 20 vs 5
• 100000 -> 193 vs 58
• 1000000 -> 1716 vs 1179

You can lose some of the reflection badness in Gaui's answer with a little bit of refactoring and a little bit of caching as such:

public static class Helper
{
    private static readonly IDictionary<Type, IEnumerable<PropertyInfo>> _Properties =
        new Dictionary<Type, IEnumerable<PropertyInfo>>();

    /// <summary>
    /// Converts a DataTable to a list with generic objects
    /// </summary>
    /// <typeparam name="T">Generic object</typeparam>
    /// <param name="table">DataTable</param>
    /// <returns>List with generic objects</returns>
    public static IEnumerable<T> DataTableToList<T>(this DataTable table) where T : class, new()
    {
        try
        {
            var objType = typeof(T);
            IEnumerable<PropertyInfo> properties;

            lock (_Properties)
            {
                if (!_Properties.TryGetValue(objType, out properties))
                {
                    properties = objType.GetProperties().Where(property => property.CanWrite);
                    _Properties.Add(objType, properties);
                }
            }

            var list = new List<T>(table.Rows.Count);

            foreach (var row in table.AsEnumerable().Skip(1))
            {
                var obj = new T();

                foreach (var prop in properties)
                {
                    try
                    {
                        prop.SetValue(obj, Convert.ChangeType(row[prop.Name], prop.PropertyType), null);
                    }
                    catch
                    {
                    }
                }

                list.Add(obj);
            }

            return list;
        }
        catch
        {
            return Enumerable.Empty<T>();
        }
    }
}