C# 将 IEnumerable 转换为 DataTable
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1253725/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Convert IEnumerable to DataTable
提问by Zyphrax
Is there a nice way to convert an IEnumerable to a DataTable?
是否有将 IEnumerable 转换为 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)
（我知道这样的例子：ObtainDataTableFromIEnumerable）
EDIT:
This questionnotified 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;
}
采纳答案by CD..
Look at this one: Convert List/IEnumerable to DataTable/DataView
看这个： 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;
}
回答by Rune Grimstad
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.
afaik 没有内置任何东西，但自己构建它应该很容易。我会按照你的建议去做，并使用反射来获取属性并使用它们来创建表的列。然后我将遍历 IEnumerable 中的每个项目并为每个项目创建一行。唯一需要注意的是，如果您的集合包含多种类型的项目（比如 Person 和 Animal），那么它们可能不具有相同的属性。但是如果你需要检查它取决于你的用途。
回答by Campbeln
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:
请注意，接受的答案中有一个与可为空类型和 DataTable 相关的错误。该修复程序可在链接站点 ( http://www.chinhdo.com/20090402/convert-list-to-datatable/) 或我修改后的代码中找到：
///###############################################################
/// <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 NOTextension methods like the example above.
请注意，这两个例子都是不扩展方法像上面的例子。
Lastly... apologies for my extensive/excessive comments (I had a anal/mean prof that beat it into me! ;)
最后......为我的广泛/过度评论道歉（我有一个肛门/卑鄙的教授打败了我！;）
回答by Keith
Firstly you need to add a where T:classconstraint - you can't call GetValueon value types unless they're passed by ref.
首先，您需要添加一个where T:class约束 - 您不能调用GetValue值类型，除非它们被ref.
Secondly GetValueis very slow and gets called a lot.
其次GetValue是非常慢并且被调用了很多。
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:
问题是我们不知道TProperty，但像往常一样，Jon Skeet在这里给出了答案——我们可以使用反射来检索 getter 委托，但是一旦我们有了它，我们就不需要再次反射：
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.
您可以通过将每种类型的 getter 存储在静态字典中来进一步优化它，然后每种类型只会有一次反射开销。
回答by tom.dietrich
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
我写了一个库来为我处理这个问题。它称为 DataTableProxy，可作为NuGet 包使用。代码和文档在Github 上
回答by Andrey Angerchik
I solve this problem by adding extension method to IEnumerable.
我通过向 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);
}
}
}
回答by Displee
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:
我也遇到了这个问题。就我而言，我不知道 IEnumerable 的类型。所以上面给出的答案是行不通的。但是，我是这样解决的：
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.
请记住，使用此方法，至少需要 IEnumerable 中的一项。如果不是这种情况，DataTable 将不会创建任何列。
回答by Florian Fida
So, 10 years later this is still a thing :)
所以，10 年后这仍然是一件事:)
I've tried every answer on this page (ATOW)
and also some ILGenerator powered solutions (FastMemberand Fast.Reflection).
But a compiled Lambda Expression seems to be the fastest.
At least for my use cases (on .Net Core 2.2).
我已经尝试了此页面 (ATOW) 上的所有答案
以及一些 ILGenerator 驱动的解决方案（FastMember和Fast.Reflection）。
但是编译的 Lambda 表达式似乎是最快的。
至少对于我的用例（在 .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.
仅适用于属性（而非字段），但适用于匿名类型。
回答by Chris HG
A 2019 answer if you're using .NET Core - use the Nuget ToDataTable library. Advantages:
如果您使用的是 .NET Core，则为2019 年的答案 - 使用Nuget ToDataTable 库。好处：
- Better performance than reflectionor using DataTableProxy
- Also creates SqlParameters for use with SQL Server Table-Valued Parameters
- 比反射或使用DataTableProxy更好的性能
- 还创建用于SQL Server 表值参数的SqlParameters
Disclaimer- I'm the author of ToDataTable
免责声明- 我是 ToDataTable 的作者
Performance- I span up some Benchmark .Nettests and included them in the ToDataTable repo. The results were as follows:
性能- 我跨越了一些Benchmark .Net测试并将它们包含在ToDataTable 存储库中。结果如下：
Creating a 100,000 Row Datatable:
创建 100,000 行数据表：
Reflection 818.5 ms
DataTableProxy 1,068.8 ms
ToDataTable 449.0 ms
