Csharp 将嵌套对象集合展平为 DataTable 的通用方法

发布于05月03日

我有一个对象列表，其中依次包含其他对象的嵌套列表.我想将对象图展平为DataTable.

我找到了一段代码，它获取一组对象并将它们映射到DataTable(见下文)，但它只支持基本属性类型.

我认为这只能通过递归实现，但也许有更好的方法来实现.

数据模型

假设我们有List个Customer个对象:

public class Item
{
    public string SKU { get; set; }
    public string Description { get; set; }
    public double Price { get; set; }
}

public class Order
{
    public string ID { get; set; }
    public List<Item> Items { get; set; }
}

public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
    public List<Order> Orders { get; set; }
}

我想将该系列完全扁平化为一个DataTable，包括以下DataColumn:

Customer.Name
Customer.Email
Customer.Order.ID
Customer.Order.Item.SKU
Customer.Order.Item.Description
Customer.Order.Item.Price

示例实现

下面是在堆栈溢出上的其他地方找到的一个示例实现，但是如果对象只包含基本属性，而不包含其他嵌套对象，那么这将起作用.我在函数中添加了一条注释，我认为我们可以在其中应用递归，但我不完全确定它是否有效.

public static DataTable CreateDataTableFromAnyCollection<T>(IEnumerable<T> list)
{
    Type type = typeof(T);
    var properties = type.GetProperties();

    DataTable dataTable = new DataTable();
    foreach (PropertyInfo info in properties)
    {
        dataTable.Columns.Add(new DataColumn(info.Name, Nullable.GetUnderlyingType(info.PropertyType) ?? info.PropertyType));
    }

    foreach (T entity in list)
    {
        object[] values = new object[properties.Length];
        for (int i = 0; i < properties.Length; i++)
        {
            values[i] = properties[i].GetValue(entity,null); // if not primitive pass a recursive call
        }

        dataTable.Rows.Add(values);
    }

    return dataTable;
}

Customer.Name	…	Customer.Orders.Items.SKU	Customer.Addresses.PostalCode
Bill Gates	…	001	98052
Bill Gates	…	002	98052
Bill Gates	…	001	98039
Bill Gates	…	002	98039

Customer.Name

…

Customer.Orders.ID

Customer.Orders.Items.SKU

Customer.Addresses.PostalCode

Bill Gates

…

001

98052

Bill Gates

…

002

98052

Bill Gates

…

001

98039

Bill Gates

…

002

98039

/// <summary> /// Populates a <paramref name="dataTable"/> with <see cref="DataColumn"/> /// definitions based on a given <paramref name="type"/>. Optionally prefixes /// the <see cref="DataColumn"/> name with a <paramref name="prefix"/> to /// handle nested types. /// </summary> /// <param name="type"> /// The <see cref="Type"/> to derive the <see cref="DataColumn"/> definitions /// from, based on properties. /// </param> /// <param name="dataTable"> /// The <see cref="DataTable"/> to add the <see cref="DataColumn"/> definitions to. /// </param> /// <param name="prefix"> /// The prefix to prepend to the <see cref="DataColumn"/> definition. /// </param> private static void EstablishDataTableFromType(Type type, DataTable dataTable, string prefix = "") { var properties = type.GetProperties(); foreach (System.Reflection.PropertyInfo property in properties) { if (!IsList(property.PropertyType)) { dataTable.Columns.Add( new DataColumn( prefix + property.Name, Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType ) ); } else { // If the property is a generic list, detect the generic type used // for that list var listType = property.PropertyType.GetGenericArguments().First(); // Recursively call this method in order to define columns for // nested types EstablishDataTableFromType(listType, dataTable, prefix + property.Name + "."); } } }

/// <summary> /// Populates a <paramref name="target"/> list with an array of <see cref=" /// object"/> instances representing the values of each property on a <paramref /// name="source"/>. /// </summary> /// <remarks> /// If the <paramref name="source"/> contains a nested <see cref="List{T}"/>, /// then this method will be called recursively, resulting in a new record for /// every nested <paramref name="source"/> in that <see cref="List{T}"/>. /// </remarks> /// <param name="source"> /// The source <see cref="Object"/> from which to pull the property values. /// </param> /// <param name="target"> /// A <see cref="List{T}"/> to store the <paramref name="source"/> values in. /// </param> /// <param name="columnIndex"> /// The index associated with the property of the <paramref name="source"/> /// object. /// </param> private static void GetValuesFromObject(Object source, List<object[]> target, ref int columnIndex) { var type = source.GetType(); var properties = type.GetProperties(); for (int i = 0; i < properties.Length; i++) { var property = properties[i]; var value = property.GetValue(source, null); var baseIndex = columnIndex; // If the property is not a list, write its value to every instance of // the target object. If there are multiple objects, the value should be // written to every permutation if (!IsList(property.PropertyType)) { foreach (var row in target) { row[columnIndex] = value; } columnIndex++; } // If the property is a generic list, recurse over each instance of that // object. As part of this, establish copies of the objects in the target // storage to ensure that every a new permutation is created for every // nested object. else { var list = (value as IList)!; var collated = new List<Object[]>(); foreach (var item in list) { columnIndex = baseIndex; var values = new List<Object[]>(); foreach (var baseItem in target) { values.Add((object[])baseItem.Clone()); } GetValuesFromObject(item, values, ref columnIndex); collated.AddRange(values); } target.Clear(); target.AddRange(collated); } } }

/// <summary> /// Given a <paramref name="list"/> of <typeparamref name="T"/> objects, will /// return a <see cref="DataTable"/> with a <see cref="DataRow"/> representing /// each instance of <typeparamref name="T"/>. /// </summary> /// <remarks> /// If <typeparamref name="T"/> contains any nested <see cref="IList{T}"/>, the /// schema will be flattened. As such, each instances of <typeparamref name= /// "T"/> will have one record for every nested item in each <see cref= /// "IList{T}"/>. /// </remarks> /// <typeparam name="T"> /// The <see cref="Type"/> that the source <paramref name="list"/> contains a /// list of. /// </typeparam> /// <param name="list"> /// A list of <typeparamref name="T"/> instances to be added to the <see cref= /// "DataTable"/>. /// </param> /// <returns> /// A <see cref="DataTable"/> containing (at least) one <see cref="DataRow"/> /// for each item in <paramref name="list"/>. /// </returns> public static DataTable CreateDataTableFromAnyCollection<T>(IEnumerable<T> list) { var dataTable = new DataTable(); EstablishDataTableFromType(typeof(T), dataTable, typeof(T).Name + "."); foreach (T source in list) { var values = new List<Object[]>(); var currentIndex = 0; // Establish an initial array to store the values of the source object values.Add(new object[dataTable.Columns.Count]); if (source is not null) { GetValuesFromObject(source, values, ref currentIndex); } // If the source object contains nested lists, then multiple permutations // of source object will be returned foreach (var value in values) { dataTable.Rows.Add(value); } } return dataTable; }

/// <summary> /// Simple helper function to determine if a given <paramref name="type"/> is a /// generic <see cref="List{T}"/>. /// </summary> /// <param name="type"> /// The <see cref="Type"/> to determine if it is a <see cref="List{T}"/> /// </param> /// <returns> /// Returns <c>true</c> if the <paramref name="type"/> is a generic <see cref= /// "List{T}"/>. /// </returns> private static bool IsList(Type type) => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>);

[Fact] public void CreateDataTableFromAnyCollection() { // ARRANGE var customers = new List<Customer>(); // Create an object graph of Customer, Order, and Item instances, three per // collection for (var i = 0; i < 3; i++) { var customer = new Customer() { Email = "Customer" + i + "@domain.tld", Name = "Customer " + i }; for (var j = 0; j < 3; j++) { var order = new Order() { ID = i + "." + j }; for (var k = 0; k < 3; k++) { order.Items.Add( new Item() { Description = "Item " + k, SKU = "0123-" + k, Price = i + (k * .1) } ); } customer.Orders.Add(order); } customers.Add(customer); } // ACT var dataTable = SqlCommandExtensions.CreateDataTableFromAnyCollection<Customer>(customers); // ASSERT Assert.Equal(27, dataTable.Rows.Count); // CLEANUP VALUES dataTable.Dispose(); }

Csharp 将嵌套对象集合展平为 DataTable 的通用方法

数据模型

示例实现

推荐答案

基本方法

挑战

解决方案

验证

局限性

结论

Csharp相关问答推荐

程序集.加载从exe的异常

通过EFCore上传大量数据.

迭代C#List并在数据库中 for each 元素执行SELECT语句—更有效的方式？

是否可以使用EF—Core进行临时部分更新？

将XPS转换为PDF C#

Polly使用泛型重试和重试包装函数

如何在没有额外副本的情况下将存储在IntPtr下的原始图像数据写入WinUI3中的Image控件？

在C#中，有没有一种方法可以集中定义跨多个方法使用的XML参数描述符？

如何解决提交按钮后 Select 选项错误空参照异常

HttpRequestMessage.SetPolicyExecutionContext不会将上下文传递给策略

正在寻找新的.NET8 Blazor Web应用程序.如何将.js添加到.razor页面？

如何让两个.NET版本不兼容的项目对话？

如何在.NET Maui中将事件与MVVM一起使用？

如何将%{v_扩展}转换为%{v_扩展}>>

在同一个捕获中可以有多种类型的异常吗？

C#System.Commandline：如何向命令添加参数以便向其传递值？

C#中使用ReadOnlySpan的泛型类型推理

单位中快照的倾斜方向

使用Try-Catch-Finally为API端点处理代码--有什么缺点？

缩写的MonthNames有问题