Convert IEnumerable to DataTable

Is there a nice way to convert an IEnumerable to a DataTable?

I could use reflection to get the properties and the values, but that seems a bit inefficient, is there something build-in?

(I know the examples like: ObtainDataTableFromIEnumerable)

EDIT:
This question notified me of a problem handling null values.
The code I wrote below handles the null values properly.

public static DataTable ToDataTable<T>(this IEnumerable<T> items) {  
    // Create the result table, and gather all properties of a T        
    DataTable table = new DataTable(typeof(T).Name); 
    PropertyInfo[] props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);  

    // Add the properties as columns to the datatable
    foreach (var prop in props) { 
        Type propType = prop.PropertyType; 

        // Is it a nullable type? Get the underlying type 
        if (propType.IsGenericType && propType.GetGenericTypeDefinition().Equals(typeof(Nullable<>))) 
            propType = new NullableConverter(propType).UnderlyingType;  

        table.Columns.Add(prop.Name, propType); 
    }  

    // Add the property values per T as rows to the datatable
    foreach (var item in items) {  
        var values = new object[props.Length];  
        for (var i = 0; i < props.Length; i++) 
            values[i] = props[i].GetValue(item, null);   

        table.Rows.Add(values);  
    } 

    return table; 
} 

Look at this one: Convert List/IEnumerable to DataTable/DataView

In my code I changed it into a extension method:

public static DataTable ToDataTable<T>(this List<T> items)
{
    var tb = new DataTable(typeof(T).Name);

    PropertyInfo[] props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);

    foreach(var prop in props)
    {
        tb.Columns.Add(prop.Name, prop.PropertyType);
    }

     foreach (var item in items)
    {
       var values = new object[props.Length];
        for (var i=0; i<props.Length; i++)
        {
            values[i] = props[i].GetValue(item, null);
        }

        tb.Rows.Add(values);
    }

    return tb;
}

To all:

Note that the accepted answer has a bug in it relating to nullable types and the DataTable. The fix is available at the linked site (http://www.chinhdo.com/20090402/convert-list-to-datatable/) or in my modified code below:

    ///###############################################################
	/// <summary>
	/// Convert a List to a DataTable.
	/// </summary>
	/// <remarks>
	/// Based on MIT-licensed code presented at http://www.chinhdo.com/20090402/convert-list-to-datatable/ as "ToDataTable"
	/// <para/>Code modifications made by Nick Campbell.
	/// <para/>Source code provided on this web site (chinhdo.com) is under the MIT license.
	/// <para/>Copyright © 2010 Chinh Do
	/// <para/>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	/// <para/>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	/// <para/>THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	/// <para/>(As per http://www.chinhdo.com/20080825/transactional-file-manager/)
	/// </remarks>
	/// <typeparam name="T">Type representing the type to convert.</typeparam>
	/// <param name="l_oItems">List of requested type representing the values to convert.</param>
	/// <returns></returns>
    ///###############################################################
	/// <LastUpdated>February 15, 2010</LastUpdated>
	public static DataTable ToDataTable<T>(List<T> l_oItems) {
		DataTable oReturn = new DataTable(typeof(T).Name);
		object[] a_oValues;
		int i;

			//#### Collect the a_oProperties for the passed T
		PropertyInfo[] a_oProperties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);

			//#### Traverse each oProperty, .Add'ing each .Name/.BaseType into our oReturn value
			//####     NOTE: The call to .BaseType is required as DataTables/DataSets do not support nullable types, so it's non-nullable counterpart Type is required in the .Column definition
		foreach(PropertyInfo oProperty in a_oProperties) {
			oReturn.Columns.Add(oProperty.Name, BaseType(oProperty.PropertyType));
		}

			//#### Traverse the l_oItems
		foreach (T oItem in l_oItems) {
				//#### Collect the a_oValues for this loop
		    a_oValues = new object[a_oProperties.Length];

				//#### Traverse the a_oProperties, populating each a_oValues as we go
			for (i = 0; i < a_oProperties.Length; i++) {
				a_oValues[i] = a_oProperties[i].GetValue(oItem, null);
			}

				//#### .Add the .Row that represents the current a_oValues into our oReturn value
			oReturn.Rows.Add(a_oValues);
		}

			//#### Return the above determined oReturn value to the caller
		return oReturn;
	}

    ///###############################################################
	/// <summary>
	/// Returns the underlying/base type of nullable types.
	/// </summary>
	/// <remarks>
	/// Based on MIT-licensed code presented at http://www.chinhdo.com/20090402/convert-list-to-datatable/ as "GetCoreType"
	/// <para/>Code modifications made by Nick Campbell.
	/// <para/>Source code provided on this web site (chinhdo.com) is under the MIT license.
	/// <para/>Copyright © 2010 Chinh Do
	/// <para/>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	/// <para/>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	/// <para/>THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	/// <para/>(As per http://www.chinhdo.com/20080825/transactional-file-manager/)
	/// </remarks>
	/// <param name="oType">Type representing the type to query.</param>
	/// <returns>Type representing the underlying/base type.</returns>
    ///###############################################################
	/// <LastUpdated>February 15, 2010</LastUpdated>
	public static Type BaseType(Type oType) {
			//#### If the passed oType is valid, .IsValueType and is logicially nullable, .Get(its)UnderlyingType
		if (oType != null && oType.IsValueType &&
			oType.IsGenericType && oType.GetGenericTypeDefinition() == typeof(Nullable<>)
		) {
			return Nullable.GetUnderlyingType(oType);
		}
			//#### Else the passed oType was null or was not logicially nullable, so simply return the passed oType
		else {
			return oType;
		}
	}

Note that both of these example are NOT extension methods like the example above.

Lastly... apologies for my extensive/excessive comments (I had a anal/mean prof that beat it into me! ;)

I've written a library to handle this for me. It's called DataTableProxy and is available as a NuGet package. Code and documentation is on Github

Firstly you need to add a where T:class constraint - you can't call GetValue on value types unless they're passed by ref.

Secondly GetValue is very slow and gets called a lot.

To get round this we can create a delegate and call that instead:

MethodInfo method = property.GetGetMethod(true);
Delegate.CreateDelegate(typeof(Func<TClass, TProperty>), method );

The problem is that we don't know TProperty, but as usual on here Jon Skeet has the answer - we can use reflection to retrieve the getter delegate, but once we have it we don't need to reflect again:

public class ReflectionUtility
{
    internal static Func<object, object> GetGetter(PropertyInfo property)
    {
    	// get the get method for the property
    	MethodInfo method = property.GetGetMethod(true);
    
    	// get the generic get-method generator (ReflectionUtility.GetSetterHelper<TTarget, TValue>)
    	MethodInfo genericHelper = typeof(ReflectionUtility).GetMethod(
    		"GetGetterHelper",
    		BindingFlags.Static | BindingFlags.NonPublic);
    
    	// reflection call to the generic get-method generator to generate the type arguments
    	MethodInfo constructedHelper = genericHelper.MakeGenericMethod(
    		method.DeclaringType,
    		method.ReturnType);
    
    	// now call it. The null argument is because it's a static method.
    	object ret = constructedHelper.Invoke(null, new object[] { method });
    
    	// cast the result to the action delegate and return it
    	return (Func<object, object>) ret;
    }
    
    static Func<object, object> GetGetterHelper<TTarget, TResult>(MethodInfo method)
    	where TTarget : class // target must be a class as property sets on structs need a ref param
    {
    	// Convert the slow MethodInfo into a fast, strongly typed, open delegate
    	Func<TTarget, TResult> func = (Func<TTarget, TResult>) Delegate.CreateDelegate(typeof(Func<TTarget, TResult>), method);
    
    	// Now create a more weakly typed delegate which will call the strongly typed one
    	Func<object, object> ret = (object target) => (TResult) func((TTarget) target);
    	return ret;
    }
}

So now your method becomes:

public static DataTable ToDataTable<T>(this IEnumerable<T> items) 
    where T: class
{  
    // ... create table the same way

    var propGetters = new List<Func<T, object>>();
foreach (var prop in props)
    {
        Func<T, object> func = (Func<T, object>) ReflectionUtility.GetGetter(prop);
        propGetters.Add(func);
    }

    // Add the property values per T as rows to the datatable
    foreach (var item in items) 
    {  
        var values = new object[props.Length];  
        for (var i = 0; i < props.Length; i++) 
        {
            //values[i] = props[i].GetValue(item, null);   
            values[i] = propGetters[i](item);
        }    

        table.Rows.Add(values);  
    } 

    return table; 
} 

You could further optimise it by storing the getters for each type in a static dictionary, then you will only have the reflection overhead once for each type.

So, 10 years later this is still a thing :)

I've tried every answer on this page (ATOW)
and also some ILGenerator powered solutions (FastMember and Fast.Reflection).
But a compiled Lambda Expression seems to be the fastest.
At least for my use cases (on .Net Core 2.2).

This is what I am using for now:

public static class EnumerableExtensions {

	internal static Func<TClass, object> CompileGetter<TClass>(string propertyName) {
		var param = Expression.Parameter(typeof(TClass));
		var body = Expression.Convert(Expression.Property(param, propertyName), typeof(object));
		return Expression.Lambda<Func<TClass, object>>(body,param).Compile();
	}     

	public static DataTable ToDataTable<T>(this IEnumerable<T> collection) {
		var dataTable = new DataTable();
		var properties = typeof(T)
						.GetProperties(BindingFlags.Public | BindingFlags.Instance)
						.Where(p => p.CanRead)
						.ToArray();

		if (properties.Length < 1) return null;
		var getters = new Func<T, object>[properties.Length];

		for (var i = 0; i < properties.Length; i++) {
			var columnType = Nullable.GetUnderlyingType(properties[i].PropertyType) ?? properties[i].PropertyType;
			dataTable.Columns.Add(properties[i].Name, columnType);
			getters[i] = CompileGetter<T>(properties[i].Name);
		}

		foreach (var row in collection) {
			var dtRow = new object[properties.Length];
			for (var i = 0; i < properties.Length; i++) {
				dtRow[i] = getters[i].Invoke(row) ?? DBNull.Value;
			}
			dataTable.Rows.Add(dtRow);
		}

		return dataTable;
	}
}

Only works with properties (not fields) but it works on Anonymous Types.

A 2019 answer if you're using .NET Core - use the Nuget ToDataTable library. Advantages:

• Better performance than reflection or using DataTableProxy
• Also creates SqlParameters for use with SQL Server Table-Valued Parameters

Disclaimer - I'm the author of ToDataTable

Performance - I span up some Benchmark .Net tests and included them in the ToDataTable repo. The results were as follows:

Creating a 100,000 Row Datatable:

Reflection                 818.5 ms
DataTableProxy			 1,068.8 ms
ToDataTable	               449.0 ms

I also came across this problem. In my case, I didn't know the type of the IEnumerable. So the answers given above wont work. However, I solved it like this:

public static DataTable CreateDataTable(IEnumerable source)
    {
        var table = new DataTable();
        int index = 0;
        var properties = new List<PropertyInfo>();
        foreach (var obj in source)
        {
            if (index == 0)
            {
                foreach (var property in obj.GetType().GetProperties())
                {
                    if (Nullable.GetUnderlyingType(property.PropertyType) != null)
                    {
                        continue;
                    }
                    properties.Add(property);
                    table.Columns.Add(new DataColumn(property.Name, property.PropertyType));
                }
            }
            object[] values = new object[properties.Count];
            for (int i = 0; i < properties.Count; i++)
            {
                values[i] = properties[i].GetValue(obj);
            }
            table.Rows.Add(values);
            index++;
        }
        return table;
    }

Keep in mind that using this method, requires at least one item in the IEnumerable. If that's not the case, the DataTable wont create any columns.

MoreLINQ includes a .ToDataTable() method.

• morelinq (NuGet Gallery)
• Source code
• Example
• Documentation

There is nothing built in afaik, but building it yourself should be easy. I would do as you suggest and use reflection to obtain the properties and use them to create the columns of the table. Then I would step through each item in the IEnumerable and create a row for each. The only caveat is if your collection contains items of several types (say Person and Animal) then they may not have the same properties. But if you need to check for it depends on your use.

I solve this problem by adding extension method to IEnumerable.

public static class DataTableEnumerate
{
    public static void Fill<T> (this IEnumerable<T> Ts, ref DataTable dt) where T : class
    {
        //Get Enumerable Type
        Type tT = typeof(T);

        //Get Collection of NoVirtual properties
        var T_props = tT.GetProperties().Where(p => !p.GetGetMethod().IsVirtual).ToArray();

        //Fill Schema
        foreach (PropertyInfo p in T_props)
            dt.Columns.Add(p.Name, p.GetMethod.ReturnParameter.ParameterType.BaseType);

        //Fill Data
        foreach (T t in Ts)
        {
            DataRow row = dt.NewRow();

            foreach (PropertyInfo p in T_props)
                row[p.Name] = p.GetValue(t);

            dt.Rows.Add(row);
        }

    }
}