Question

I am using this below:

    public static DataTable DataTableJoiner(DataTable dt1, DataTable dt2)
    {
        using (DataTable targetTable = dt1.Clone())
        {
            var dt2Query = dt2.Columns.OfType<DataColumn>().Select(dc =>
                new DataColumn(dc.ColumnName, dc.DataType, dc.Expression, 
                    dc.ColumnMapping));
            var dt2FilterQuery = from dc in dt2Query.AsEnumerable()
                                 where targetTable.Columns
                                       .Contains(dc.ColumnName) == false
                                 select dc;
            targetTable.Columns.AddRange(dt2FilterQuery.ToArray());
            var rowData = from row1 in dt1.AsEnumerable()
                          join row2 in dt2.AsEnumerable()
                          on row1.Field<int>("Code") equals 
                             row2.Field<int>("Code")
                          select row1.ItemArray
                              .Concat(row2.ItemArray
                              .Where(r2 => 
                                  row1.ItemArray.Contains(r2) == false)).ToArray();
            foreach (object[] values in rowData) targetTable.Rows.Add(values);
            return targetTable;
        }
    }

There is a problem with this line:

select row1.ItemArray.Concat(row2.ItemArray.Where(r2 => 
     row1.ItemArray.Contains(r2) == false)).ToArray();

It seems to be saying don’t include me if this value (rather than column) already exists.

I am using this method to join two tables together based on a column that both tables share, but I only want the unique columns with data of both tables as a final result.

Any ideas?

Answer 1

I am not sure if I understand your requirement 100%, but this:

row2.ItemArray.Where(r2 => row1.ItemArray.Contains(r2) == false)

will filter out those items that happen to appear in any column of table 1, not just the column you are joining on.

So what I would try to do is filter the item based on the index, using an overload of the Where extension method:

// Get the index of the column we are joining on:
int joinColumnIndex = dt2.Columns.IndexOf("Code");

// Now we can filter out the proper item in the rowData query:
row2.ItemArray.Where((r2,idx) => idx != joinColumnIndex)

…

No, wait. Here:

var dt2FilterQuery = from dc in dt2Query.AsEnumerable()
                     where targetTable.Columns
                           .Contains(dc.ColumnName) == false
                     select dc;

You are filtering out all columns of table 2 whose name also appear in table 1. So what you probably want is this:

public static DataTable DataTableJoiner(DataTable dt1, DataTable dt2)
{
    DataTable targetTable = dt1.Clone();

    var dt2Query = dt2.Columns.OfType<DataColumn>().Select(dc =>
        new DataColumn(dc.ColumnName, dc.DataType, dc.Expression, 
            dc.ColumnMapping));

    var dt2FilterQuery = from dc in dt2Query.AsEnumerable()
                         where !targetTable.Columns.Contains(dc.ColumnName)
                         select dc;

    var columnsToAdd = dt2FilterQuery.ToArray();
    var columnsIndices = columnsToAdd.Select(dc => dt2.Columns.IndexOf(dc.ColumnName));

    targetTable.Columns.AddRange(columnsToAdd);

    var rowData = from row1 in dt1.AsEnumerable()
                      join row2 in dt2.AsEnumerable()
                      on row1.Field<int>("Code") equals 
                         row2.Field<int>("Code")
                      select row1.ItemArray
                          .Concat(row2.ItemArray
                          .Where((r2,idx) => 
                              columnsIndices.Contains(idx))).ToArray();

    foreach (object[] values in rowData) targetTable.Rows.Add(values);
    return targetTable;
}

Btw. I don’t quite understand why you are wrapping the DataTable you return in a using statement. Imho it is kind of pointless to dispose the very object you return to your caller right away…