加入 2 个具有多列的数据表

Question

我有一个问题，想加入 2 个具有相同列的表。表 1 有 Name、LastName 列和许多其他列，表 2 有 Name、Comment 和许多其他列。我想将它们与名称列一起加入，结果应该是名称、姓氏、评论和其他列。我尝试使用左外 Linq，但不知道如何编写 select new，因为不知道我还有多少其他列。

我的表 1：

Name1   LastName ...
Niki   Row      ...
Hube   Slang    ...
Koke   Mi       ... 
...    ...      ...
...    ...      ...

表 2：

Name  Comment   ...
Koke   "Hello"  ...
Niki   "Hi"     ...

结果应该是：

Name   LastName   Comment ...
Niki    Row        "Hi"   ...
Hube    Sland             ...
Koke    Mi         "Hello"...
...     ...               ...

所以我尝试将这些行相互连接。但是它说table1中的数组比table 2中的数组长。还有其他方法可以加入吗？

        foreach (DataRow tbE in Table1.Rows)
        {
            foreach (DataRow opT in Table2.Rows)
            {
                if (tbE["Name"].ToString() == opT["Name"].ToString())
                {
                    var row = Result.NewRow();
                    row.ItemArray = tbE.ItemArray
                                       .Concat(opT.ItemArray).ToArray();

                    Result.Rows.Add(row);
                }
                else
                    Result.ImportRow(tbE);

            }
        } 
        Result.Columns.Remove(Name); 

Answer 1

您可以在这里使用我最近为another question 从头开始​​编写的这种方法（所以它没有经过真正的测试）。它允许通过一个公共键合并多个表。如果没有指定键，它将只使用默认的DataTable.Merge 方法：

public static DataTable MergeAll(this IList<DataTable> tables, String primaryKeyColumn)
{
    if (!tables.Any())
        throw new ArgumentException("Tables must not be empty", "tables");
    if(primaryKeyColumn != null)
        foreach(DataTable t in tables)
            if(!t.Columns.Contains(primaryKeyColumn))
                throw new ArgumentException("All tables must have the specified primarykey column " + primaryKeyColumn, "primaryKeyColumn");

    if(tables.Count == 1)
        return tables[0];

    DataTable table = new DataTable("TblUnion");
    table.BeginLoadData(); // Turns off notifications, index maintenance, and constraints while loading data
    foreach (DataTable t in tables)
    {
        table.Merge(t); // same as table.Merge(t, false, MissingSchemaAction.Add);
    }
    table.EndLoadData();

    if (primaryKeyColumn != null)
    {
        // since we might have no real primary keys defined, the rows now might have repeating fields
        // so now we're going to "join" these rows ...
        var pkGroups = table.AsEnumerable()
            .GroupBy(r => r[primaryKeyColumn]);
        var dupGroups = pkGroups.Where(g => g.Count() > 1);
        foreach (var grpDup in dupGroups)
        { 
            // use first row and modify it
            DataRow firstRow = grpDup.First();
            foreach (DataColumn c in table.Columns)
            {
                if (firstRow.IsNull(c))
                {
                    DataRow firstNotNullRow = grpDup.Skip(1).FirstOrDefault(r => !r.IsNull(c));
                    if (firstNotNullRow != null)
                        firstRow[c] = firstNotNullRow[c];
                }
            }
            // remove all but first row
            var rowsToRemove = grpDup.Skip(1);
            foreach(DataRow rowToRemove in rowsToRemove)
                table.Rows.Remove(rowToRemove);
        }
    }

    return table;
}

可以这样调用：

var tables = new[] { Table1, Table2 };
tables.MergeAll("Name");

编辑：这是来自调试器的屏幕截图以及您的示例数据：

所以它起作用了:)

这里的样本数据和测试：

var Table1 = new DataTable();
var Table2 = new DataTable();
Table1.Columns.Add("Name");
Table1.Columns.Add("LastName");

Table2.Columns.Add("Name");
Table2.Columns.Add("Comment");

Table1.Rows.Add("Niki", "Row");
Table1.Rows.Add("Hube", "Slang");
Table1.Rows.Add("Koke", "Mi");

Table2.Rows.Add("Koke", "Hello");
Table2.Rows.Add("Niki", "Hi");

var tables = new DataTable[] { Table1, Table2 };
DataTable merged = tables.MergeAll("Name");

Answer 2

这是我的一点贡献。此部分代码可用于连接指定列名上的任意两个 DataTable。 （您不需要知道其余列）以下是一些功能：

1. 生成的 DataTable 不会有用于连接的重复列。例如如果您加入“名称”列，最后您将只有一个“名称”列，而不是每个表中的一个副本。
2. 如果存在未在连接中使用的重复列，则第二个表中的重复列将通过在末尾附加“_2”来重命名。它可以以其他方式运行，只需更改那部分代码即可。
3. 支持多个连接列。为此，为它们创建了一个 JoinKey 类，以供 LINQ 进行比较。

4. 此代码是我在网上找到的代码和我的反复试验的混合体。我是 LINQ 新手，欢迎批评~

   public class JoinKey
   {
       List<object> objects { get; set; }
   
       public JoinKey(List<object> objects)
       {
           this.objects = objects;
       }
   
       public override bool Equals(object obj)
       {
           if (obj == null || obj.GetType() != typeof(JoinKey))
               return false;
           return objects.SequenceEqual(((JoinKey)obj).objects);
       }
   
       public override int GetHashCode()
       {
           int hash = 0;
           foreach (var foo in objects)
           {
               hash = hash * 31 + foo.GetHashCode();
           }
           return hash;
       }
   }
   
   public enum JoinType
   {
       Inner = 0,
       Left = 1
   }
   
       //Joins two tables and spits out the joined new DataTable. Tables are joined on onCol column names
       //If the right table has column name clashes with the left column, the column names will be appended "_2" and added to joined table
       public static DataTable Join(DataTable left, DataTable right, JoinType joinType, params string[] onCol)
       {
           Func<DataRow, object> getKey = (row) =>
           {
               return new JoinKey(onCol.Select(str => row[str]).ToList());
           };
           var dt = new DataTable(left.TableName);
           var colNumbersToRemove = new List<int>();
           //Populate the columns
           foreach (DataColumn col in left.Columns)
           {
               if (dt.Columns[col.ColumnName] == null)
                   dt.Columns.Add(new DataColumn(col.ColumnName, col.DataType, col.Expression, col.ColumnMapping));
           }
           for (int colIdx = 0; colIdx < right.Columns.Count; ++colIdx)
           {
               var col = right.Columns[colIdx];
               //if this is joined column, it will be removed.
               if (onCol.Contains(col.ColumnName))
               {
                   colNumbersToRemove.Add(colIdx);
               }
               else
               {
                   //if this is duplicate column, it will be renamed.
                   if (dt.Columns[col.ColumnName] != null)
                   {
                       col.ColumnName += "_2";
                   }
                   dt.Columns.Add(new DataColumn(col.ColumnName, col.DataType, col.Expression, col.ColumnMapping));
               }
           }
   
           if (joinType == JoinType.Left)
           {
               var res = from l in left.AsEnumerable()
                         join r in right.AsEnumerable()
                         on getKey(l) equals getKey(r) into temp
                         from r in temp.DefaultIfEmpty()
                         select l.ItemArray.Concat(((r == null) ? (right.NewRow().ItemArray) : r.ItemArray).Minus(colNumbersToRemove)).ToArray();
               foreach (object[] values in res)
                   dt.Rows.Add(values);
           }
           else
           {
               //Inner Join
               var res = from l in left.AsEnumerable()
                         join r in right.AsEnumerable()
                         on getKey(l) equals getKey(r) into temp
                         from r in temp
                         select l.ItemArray.Concat(((r == null) ? (right.NewRow().ItemArray) : r.ItemArray).Minus(colNumbersToRemove)).ToArray();
               foreach (object[] values in res)
                   dt.Rows.Add(values);
           }
           return dt;
       }