C# 期权）； } 其他的 { table.LoadDataRow（值，true）； } } } table.EndLoadData（）； //把桌子还给我。 返回表； } 公共对象[]ShredObject（数据表，T实例） { FieldInfo[]fi=\

期权）； } 其他的 { table.LoadDataRow（值，true）； } } } table.EndLoadData（）； //把桌子还给我。 返回表； } 公共对象[]ShredObject（数据表，T实例） { FieldInfo[]fi=\u-fi； PropertyInfo[]pi=\u pi； if（instance.GetType（）！=typeof（T）） { //如果实例是从T派生的，则扩展表架构 //并获取属性和字段。 可扩展（表，实例.GetType（））； fi=instance.GetType（）.GetFields（）； pi=instance.GetType（）.GetProperties（）； } //将实例的属性和字段值添加到数组中。 Object[]value=新对象[table.Columns.Count]； foreach（fi中的字段信息f） { 值[_ordinalMap[f.Name]]=f.GetValue（实例）； } foreach（以pi表示的p属性） { 值[_ordinalMap[p.Name]]=p.GetValue（实例，null）； } //返回实例的属性和字段值。 返回值； } 公共数据表可扩展（数据表，类型） { //如果输入表为null或值为 //在序列中，由T型派生而来。 foreach（type.GetFields（）中的FieldInfo f） { 如果（！_ordinalMap.ContainsKey（f.Name）） { //如果字段不存在，则将其作为列添加到表中 //已经。 DataColumn dc=table.Columns.Contains（f.Name）？table.Columns[f.Name] ：table.Columns.Add（f.Name，f.FieldType）； //将字段添加到序号映射。 _序号映射添加（f.名称，dc.序号）； } } foreach（type.GetProperties（）中的PropertyInfo p） { 如果（！_ordinalMap.ContainsKey（p.Name）） { //如果该属性不存在，请将其作为列添加到表中 //已经。 DataColumn dc=table.Columns.Contains（p.Name）？table.Columns[p.Name] ：table.Columns.Add（p.Name，p.PropertyType）； //将属性添加到序号映射。 _序号映射添加（p.Name，dc.Ordinal）； } } //把桌子还给我。 返回表； } } /// ///直接从中复制的代码http://msdn.microsoft.com/en-us/library/bb669096.aspx /// 公共静态类CustomLINQtoDataSetMethods { 公共静态数据表CopyToDataTable（此IEnumerable源） { 返回新的ObjectShreder（）.Shred（source，null，null）； } 公共静态数据表CopyToDataTable（此IEnumerable源， 数据表，加载选项？选项） { 返回新的ObjectShreder（）.Shred（源、表、选项）； } }

---

你能发布你得到的输出吗？所以我运行了这段代码，它执行并打印预期的结果。我已经修改了答案，使之成为一个完全可编译且可执行的程序。哇，谢谢，我希望我可以避免使用那个怪物方法的MSDN文章，因为我一点也不了解它，但这将暂时起作用，直到我能想出一个更好的方法为止。这是一个很棒的解决方案。我想处理的一个测试是，是否缺少一列。例如，下面的数据：

addRow（dt，“foo”，“bar”，“a”，“w”）；addRow（dt，“foo”，“bar”，“c”，“y”）；addRow（dt，“foo”，“bar”，“d”，“z”）；addRow（dt，“foo”，“test”，“a”，“i”）；addRow（dt，“foo”，“test”，“c”，“k”）；addRow（dt，“foo”，“test”，“d”，“l”）
ObjectName | ColumnName  |  Property  |  Value
----------------------------------------------
foo        | bar         |  a         | w
foo        | bar         |  b         | x
foo        | bar         |  c         | y
foo        | bar         |  d         | z
foo        | test        |  a         | i
foo        | test        |  b         | j
foo        | test        |  c         | k
foo        | test        |  d         | l

ObjectName   |  ColumnName  |  a  |  b  |  c  |  d 
---------------------------------------------------
foo          |  bar         |  w  |  x  |  y  |  z
foo          |  test        |  i  |  j  |  k  |  l

var query = dt.AsEnumerable()
    .GroupBy(row => row.Field<string>("ColumnName"))
    .Select(g => new {
        ColumnName = g.Key,
        a = g.Where(row => row.Field<string>("Property") == "a").Select(c => c.Field<string>("Value")),
        b = g.Where(row => row.Field<string>("Property") == "b").Select(c => c.Field<string>("Value")),
        c = g.Where(row => row.Field<string>("Property") == "c").Select(c => c.Field<string>("Value")),
        d = g.Where(row => row.Field<string>("Property") == "d").Select(c => c.Field<string>("Value"))
    });

DataTable newDT = query.CopyToDataTable();

class Program
{
//Helper method to make the Select cleaner:
private static string GetProperty(IEnumerable<DataRow> rows, string propertyName)
{
    return rows
        .Where(row => row.Field<string>("Property") == propertyName)
        .Select(c => c.Field<string>("Value"))
        .FirstOrDefault();
}

//helper method for populating the datatable
private static void addRow(DataTable dt, string objectName, string columnName
    , string property, string value)
{
    var row = dt.NewRow();
    row["ObjectName"] = objectName;
    row["ColumnName"] = columnName;
    row["Property"] = property;
    row["Value"] = value;
    dt.Rows.Add(row);
}

public static void Main(string[] args)
{

    DataTable dt = new DataTable();
    dt.Columns.Add("ObjectName");
    dt.Columns.Add("ColumnName");
    dt.Columns.Add("Property");
    dt.Columns.Add("Value");

    addRow(dt, "foo", "bar", "a", "w");
    addRow(dt, "foo", "bar", "b", "x");
    addRow(dt, "foo", "bar", "c", "y");
    addRow(dt, "foo", "bar", "d", "z");
    addRow(dt, "foo", "test", "a", "i");
    addRow(dt, "foo", "test", "b", "j");
    addRow(dt, "foo", "test", "c", "k");
    addRow(dt, "foo", "test", "d", "l");

    var query = dt.AsEnumerable()
        .GroupBy(row => new
        {
            ObjectName = row.Field<string>("ObjectName"),
            ColumnName = row.Field<string>("ColumnName")
        })
        .Select(g => new
        {
            ObjectName = g.Key.ObjectName,
            ColumnName = g.Key.ColumnName,
            a = GetProperty(g, "a"),
            b = GetProperty(g, "b"),
            c = GetProperty(g, "c"),
            d = GetProperty(g, "d"),
        })
        .CopyToDataTable();

    foreach (DataRow row in query.Rows)
    {
        foreach (DataColumn column in query.Columns)
        {
            System.Console.Write(row[column] + "\t");
        }
        System.Console.WriteLine();
    }


    Console.WriteLine("Press any key to exit. . .");
    Console.ReadKey(true);
}
}

using System;
using System.Data;
using System.Collections.Generic;
using System.Reflection;


/// <summary>
/// Code copied directly from http://msdn.microsoft.com/en-us/library/bb669096.aspx
/// </summary>
/// <typeparam name="T"></typeparam>
public class ObjectShredder<T>
{
    private System.Reflection.FieldInfo[] _fi;
    private System.Reflection.PropertyInfo[] _pi;
    private System.Collections.Generic.Dictionary<string, int> _ordinalMap;
    private System.Type _type;

    // ObjectShredder constructor.
    public ObjectShredder()
    {
        _type = typeof(T);
        _fi = _type.GetFields();
        _pi = _type.GetProperties();
        _ordinalMap = new Dictionary<string, int>();
    }

    /// <summary>
    /// Loads a DataTable from a sequence of objects.
    /// </summary>
    /// <param name="source">The sequence of objects to load into the DataTable.</param>
    /// <param name="table">The input table. The schema of the table must match that 
    /// the type T.  If the table is null, a new table is created with a schema 
    /// created from the public properties and fields of the type T.</param>
    /// <param name="options">Specifies how values from the source sequence will be applied to 
    /// existing rows in the table.</param>
    /// <returns>A DataTable created from the source sequence.</returns>
    public DataTable Shred(IEnumerable<T> source, DataTable table, LoadOption? options)
    {
        // Load the table from the scalar sequence if T is a primitive type.
        if (typeof(T).IsPrimitive)
        {
            return ShredPrimitive(source, table, options);
        }

        // Create a new table if the input table is null.
        if (table == null)
        {
            table = new DataTable(typeof(T).Name);
        }

        // Initialize the ordinal map and extend the table schema based on type T.
        table = ExtendTable(table, typeof(T));

        // Enumerate the source sequence and load the object values into rows.
        table.BeginLoadData();
        using (IEnumerator<T> e = source.GetEnumerator())
        {
            while (e.MoveNext())
            {
                if (options != null)
                {
                    table.LoadDataRow(ShredObject(table, e.Current), (LoadOption)options);
                }
                else
                {
                    table.LoadDataRow(ShredObject(table, e.Current), true);
                }
            }
        }
        table.EndLoadData();

        // Return the table.
        return table;
    }

    public DataTable ShredPrimitive(IEnumerable<T> source, DataTable table, LoadOption? options)
    {
        // Create a new table if the input table is null.
        if (table == null)
        {
            table = new DataTable(typeof(T).Name);
        }

        if (!table.Columns.Contains("Value"))
        {
            table.Columns.Add("Value", typeof(T));
        }

        // Enumerate the source sequence and load the scalar values into rows.
        table.BeginLoadData();
        using (IEnumerator<T> e = source.GetEnumerator())
        {
            Object[] values = new object[table.Columns.Count];
            while (e.MoveNext())
            {
                values[table.Columns["Value"].Ordinal] = e.Current;

                if (options != null)
                {
                    table.LoadDataRow(values, (LoadOption)options);
                }
                else
                {
                    table.LoadDataRow(values, true);
                }
            }
        }
        table.EndLoadData();

        // Return the table.
        return table;
    }

    public object[] ShredObject(DataTable table, T instance)
    {

        FieldInfo[] fi = _fi;
        PropertyInfo[] pi = _pi;

        if (instance.GetType() != typeof(T))
        {
            // If the instance is derived from T, extend the table schema
            // and get the properties and fields.
            ExtendTable(table, instance.GetType());
            fi = instance.GetType().GetFields();
            pi = instance.GetType().GetProperties();
        }

        // Add the property and field values of the instance to an array.
        Object[] values = new object[table.Columns.Count];
        foreach (FieldInfo f in fi)
        {
            values[_ordinalMap[f.Name]] = f.GetValue(instance);
        }

        foreach (PropertyInfo p in pi)
        {
            values[_ordinalMap[p.Name]] = p.GetValue(instance, null);
        }

        // Return the property and field values of the instance.
        return values;
    }

    public DataTable ExtendTable(DataTable table, Type type)
    {
        // Extend the table schema if the input table was null or if the value 
        // in the sequence is derived from type T.            
        foreach (FieldInfo f in type.GetFields())
        {
            if (!_ordinalMap.ContainsKey(f.Name))
            {
                // Add the field as a column in the table if it doesn't exist
                // already.
                DataColumn dc = table.Columns.Contains(f.Name) ? table.Columns[f.Name]
                    : table.Columns.Add(f.Name, f.FieldType);

                // Add the field to the ordinal map.
                _ordinalMap.Add(f.Name, dc.Ordinal);
            }
        }
        foreach (PropertyInfo p in type.GetProperties())
        {
            if (!_ordinalMap.ContainsKey(p.Name))
            {
                // Add the property as a column in the table if it doesn't exist
                // already.
                DataColumn dc = table.Columns.Contains(p.Name) ? table.Columns[p.Name]
                    : table.Columns.Add(p.Name, p.PropertyType);

                // Add the property to the ordinal map.
                _ordinalMap.Add(p.Name, dc.Ordinal);
            }
        }

        // Return the table.
        return table;
    }
}

/// <summary>
/// Code copied directly from http://msdn.microsoft.com/en-us/library/bb669096.aspx
/// </summary>
public static class CustomLINQtoDataSetMethods
{
    public static DataTable CopyToDataTable<T>(this IEnumerable<T> source)
    {
        return new ObjectShredder<T>().Shred(source, null, null);
    }

    public static DataTable CopyToDataTable<T>(this IEnumerable<T> source,
                                                DataTable table, LoadOption? options)
    {
        return new ObjectShredder<T>().Shred(source, table, options);
    }

}