具有非唯一列的左联接/合并数据表c#

Question

我有两个数据表有不同的结构，一个表有一个列调用“活动ID”，这并不是唯一的，我想加入它在B表的“活动ID”，这是唯一的。

所以它相当于sql中的内容。

select * from 
A left join B on 
A.[Campagin ID] = B.[Cmpaign ID]

我尝试过datatable.merge不能工作，因为它只能根据唯一的列字段合并。

我试过林克和兰达。

var resultDt = from c in dt.AsEnumerable()
                       join lookup in lookupDt.AsEnumerable() on c["Campaign ID"].ToString() equals lookup["EventID"]
                           .ToString() into results
                       from r in results.DefaultIfEmpty()
                       select new { a=c, b =lookup };

它返回两组数据，而不是一组数据。

我也试过用字典，但它太贵了，无法运行。

如果选择r，它将只返回表B值

I expected the output would be like
select * from 
A left join B on 
A.[Campagin ID] = B.[Cmpaign ID]

在SQL中

如果表A是

Campaign ID                            Description      Number
eda1e64c-0002-4000-8000-000000000198            
eda1e64c-0002-4000-8000-000000000198            
eda1e64c-0002-4000-8000-000000000198            
eda1e64c-0002-4000-8000-000000000198            
eda1e64c-0002-4000-8000-000000000000    Testing 123     1111
                                        Description 2   3333

表B就像

Campaign ID                             Name      
eda1e64c-0002-4000-8000-000000000198    Test Name1  
eda1e64c-0002-4000-8000-000000000000    Test Name2      

预期结果

Campaign ID                             Description      Number   Name
eda1e64c-0002-4000-8000-000000000198                             Test Name1
eda1e64c-0002-4000-8000-000000000198                             Test Name1
eda1e64c-0002-4000-8000-000000000198                             Test Name1
eda1e64c-0002-4000-8000-000000000198                             Test Name1
eda1e64c-0002-4000-8000-000000000000    Testing 123     1111     Test Name2

我是否可以使用任何默认的c#方法，或者使用任何有效的方法来做到这一点？非常感谢你的帮助。

Answer 1

我认为您已经接近了，只需将LINQ查询输出转换为一个对象数组，并将其作为一个单独的新datatable；请记住，LINQ的主要目的是查询和返回结果集合，而不是修改现有的内容：

左联接使用LINQ，手动输出列表，手动消费到数据表

            var query =
                from ce in c.AsEnumerable()
                join le in lookup.AsEnumerable() on c.Field<Guid>("Campaign ID") equals le.Field<Guid>("Campaign ID") into cele
                from lenull in cele.DefaultIfEmpty()
                select new object[]
                {
                  ce.Field<Guid>("Campaign ID"),
                  ce.Field<string>("Description"),
                  ce.Field<int>("Number"), //don't know how your table has null here, maybe <int?>
                  lenull?.Field<string>("Name")
                };

            DataTable c = new DataTable(); //to hold results
            c.Columns.Add("Campaign ID", typeof(Guid)); 
            c.Columns.Add("Description"); 
            c.Columns.Add("Number", typeof(int)); 
            c.Columns.Add("Name");
            foreach (var at in query)
                c.Rows.Add(at);

因为lenull可能为空，所以我使用null传播器来避免空引用异常试图获取空行的字段。我们也可以动态地这样做，不需要反射，但速度要慢得多。对于下面的示例，我使用了自己的简单数据对，设置如下：

        //setup part
        DataTable a = new DataTable();
        a.Columns.Add("ID", typeof(int));
        a.Columns.Add("Name", typeof(string));
        a.Columns.Add("Age", typeof(int));
        DataTable b = new DataTable();
        var pk = b.Columns.Add("ID", typeof(int));
        b.Columns.Add("Address", typeof(string));
        b.Columns.Add("YearsAt", typeof(int));
        b.PrimaryKey = new[] { pk };

        a.Rows.Add(1, "John", 22);
        a.Rows.Add(2, "Mary", 33);
        a.Rows.Add(3, "Bill", 44);

        b.Rows.Add(1, "JohnAddr", 3);
        b.Rows.Add(2, "MaryAddr", 4);

左加入LINQ，手动输出列表，动态消耗

            var query =
                from ae in a.AsEnumerable()
                join be in b.AsEnumerable() on ae.Field<int>("ID") equals be.Field<int>("ID_") into aebe
                from be2 in aebe.DefaultIfEmpty()
                select new Dictionary<string, object>
                {
                    {"ID", ae.Field<int>("ID")},
                    {"Name", ae.Field<string>("Name") },
                    {"Age", ae.Field<int>("Age") },
                    {"Address", be2?.Field<string>("Address") },
                    {"YearsAt", be2?.Field<int>("YearsAt") }
                };

            //setup datatable
            DataTable c = new DataTable();                    

            int keyCount = query.First().Keys.Count; //track columns needed to be added
            foreach (var dict in query)
            {
                var ro = c.NewRow();
                foreach (string key in dict.Keys)
                {
                    if (keyCount > 0 && dict[key] != null && !c.Columns.Contains(key))
                    { //if the column is not in the table, and the value isnt null (so we can deduce the type)
                        c.Columns.Add(key, dict[key].GetType());
                        keyCount--; //mark it as added. Eventually this will hit 0 and we won't evaluate the other two clauses
                    }

                    if (dict[key] != null) //don't store nulls
                        ro[key] = dict[key];
                }
                c.Rows.Add(ro);
            } 

当然，您可能会抱怨，您仍然必须在LINQ查询选择中指定您想要的所有列。我们也可以使之充满活力：

左加入LINQ，动态输出列表，动态消耗

             var query =
                from ae in a.AsEnumerable()
                join be in b.AsEnumerable() on ae.Field<int>("ID") equals be.Field<int>("ID_") into aebe
                from be2 in aebe.DefaultIfEmpty()
                select MapToDict(ae, be2);

            //setup datatable
            DataTable c = new DataTable();                    

            int keyCount = query.First().Keys.Count;
            foreach (var dict in query)
            {
                //have we got all our columns addded yet?
                var ro = c.NewRow();
                foreach (string key in dict.Keys)
                {
                    if (keyCount > 0 && dict[key] != null && !c.Columns.Contains(key))
                    { //if the column is not in the table, and the value isnt null (so we can deduce the type)
                        c.Columns.Add(key, dict[key].GetType());
                        keyCount--; //mark it as added. Eventually this will hit 0 and we won't evaluate the other two clauses
                    }

                    if (dict[key] != null) //don't store nulls
                        ro[key] = dict[key];
                }
                c.Rows.Add(ro);
            }

我从来不喜欢在LINQ中加入DataTables，我一直喜欢：

• 在b上建立主键
• 向重复的b的列名和类型中添加新列(如果存在名称冲突，则重命名b列，添加int )
• 迭代，调用b.Find(某个列从
• 如果find没有返回null，则对于b中的每一列，将a行中相同的命名列设置为查找给您的b行中的值。

下面是执行上述操作的代码：

左联接使用循环

        //ensure unique named columns in b, and grow a's columns
        foreach (DataColumn bcol in b.Columns) {
            while (a.Columns.Contains(bcol.ColumnName))
                bcol.ColumnName += "_";
            a.Columns.Add(bcol.ColumnName, bcol.DataType);
        }

        //perform left join
        foreach (DataRow aro in a.Rows) {
            var f = b.Rows.Find(aro["ID"]);
            if (f != null)
                foreach (DataColumn bcol in b.Columns)
                    aro[bcol.ColumnName] = f[bcol];
        }

将其转换为扩展方法可能非常简单，这样任何表都可以像a.LeftJoin(b，aID："ID"，bID："ID")那样将另一个表连接到它上。如果您想要一个比简单的等价物更复杂的逻辑，那么就需要进行一些代码更改。

奇怪的是，我连续地尝试了所有4种方法，并对它们进行了计时。在我的上下文中，循环比具有固定结构和硬编码列名的LINQ快2.5倍，比使用字典使事情变得动态快4倍：

        for (int lc = 0; lc < 10; lc++) {

            //setup 100K rows
            DataTable a = new DataTable();
            a.Columns.Add("ID", typeof(int));
            a.Columns.Add("Name", typeof(string));
            a.Columns.Add("Age", typeof(int));
            DataTable b = new DataTable();
            var pk = b.Columns.Add("ID", typeof(int));
            b.Columns.Add("Address", typeof(string));
            b.Columns.Add("YearsAt", typeof(int));
            b.PrimaryKey = new[] { pk };

            Random r = new Random();
            for (int i = 0; i < 100000; i++)
            {
                a.Rows.Add(i, Guid.NewGuid().ToString(), r.Next(20, 99));
                if (r.Next(0, 9) < 1)
                    b.Rows.Add(i, Guid.NewGuid().ToString(), r.Next(1, 10));

            }

            Stopwatch sw = Stopwatch.StartNew();

### INSERT CHOSEN METHOD HERE ###

            sw.Stop();

            Console.WriteLine($"Time: {sw.ElapsedMilliseconds}ms");

        }

结果通常是用于循环处理100 K行的80 to，用于LINQ硬编码(手动选择、手动表)的200 to和用于LINQ字典(dynamic loops )方法的400 to。

Answer 2

不如这样吧：

TableAlist.Select(A => A.CampaignId, A.Description, A.Number, 
     Name = TableBlist.FirstOrDefault(B => B.CampaignId == A.CampaignId)?.Name ?? "").ToList()