C# Linq按列表中的值分组

所以目前我有一个TrackinInfo类，它包含一个ID和一个EmailActionID列表，它是一个int。 我有一个此类的列表，数据如下所示：

ID,   |   EmailActions
_______________
 A    |   1, 3, 5
 B    |   3, 5, 6
 C    |   2, 4, 6

我试图编写一个Linq语句，将其转换为一个ID列表，该列表按列表中的每个值分组

因此，结果集如下所示：

ID   |   Values
_______________
 1    |   A
 2    |   C
 3    |   A, B
 4    |   C,
 5    |   A, B
 6    |   B, C

我不知道该如何写这个小组，谁能给我一些见解

DistinctValues = new List<int> {1,2,3,4,5,6};
TrackingInfo.Groupby(t => DistinctValues.foreach(d => 
                                           t.EmailActions.Contains(d))).Tolist()

DistinctValues=新列表{1,2,3,4,5,6}；
TrackingInfo.Groupby（t=>distinctValue.foreach（d=>
t、 EmailActions.Contains（d））.Tolist（）

---

当然，对于如何使用Linq实现这一点，这并没有任何建议，您需要的是

SelectMany

，但在这里使用查询语法更容易：

var result = from item in source
             from action in item.EmailActions
             group item.ID by action into g
             select new { ID = g.Key, Values = g.ToList() }

---

您可以首先使用

Enumerable.range

生成一个范围，然后匹配

EmailActions

，如下所示：

var res = Enumerable.Range(1, 6)
    .SelectMany(v => TrackingInfo.Where(info => info.EmailActions.Contains(v)).Select(info => new { Id, Value = v }))
    .GroupBy(p => p.Value)
    .Select(g => new {
        Id = g.Key
    ,   Values = g.Select(p => p.Id).ToList()
    });

---

很容易获得一个独特的

电子邮件操作列表

var distinctEmailActions = items.SelectMany(i => i.EmailActions).Distinct();

然后旋转这个有点复杂，但这里是：

var result = distinctEmailActions.Select(e => new { 
              ID=e, 
              Values = items.Where(i => i.EmailActions.Contains(e)).Select(i => i.ID) 
});

---

实例：

您可以使用以下方法实现这一点：-

var result = tracking.SelectMany(x => x.EmailActionIDs, 
                                    (trackObj, EmailIds) => new { trackObj, EmailIds })
                     .GroupBy(x => x.EmailIds)
                     .Select(x => new
                       {
                            ID = x.Key,
                            Values = String.Join(",", x.Select(z => z.trackObj.ID))
                       }).OrderBy(x => x.ID);

---

我喜欢你的思维方式。这与我在查看任何答案之前得出的结论几乎相同。与其他一些答案不同的是，不需要额外的

GroupBy

子句。此外，您还可以从示例中进行解密以获得正确的distinct