C# 基于条件的过滤查询

我试图根据查询结果是否包含字符串“baby”来过滤查询结果

IEnumerable查询=
ICDUnitOfWork.AlphaGroups.Find（）.GroupJoin（ICDUnitOfWork.Alphas.Find（），
a=>a.AlphaGroupID，
g=>g.AlphaGroupID，
（字母组，字母）=>
新的ICD.ViewModels。
HomeSearchViewModel
{
字母群=
字母组，
阿尔法
})
。其中（行=>
行.字母组.标题.包含（“婴儿”）
||row.Alphas.Any（alpha=>alpha.Title.Contains（“baby”））
);

---

问题是，当Alpha.Title包含字符串“baby”时，它应该只显示包含“baby”的Alpha，而不是AlphaGroup中的每个Alpha。如果AlphaGroup.Title包含“baby”，则应继续显示组中的每个alpha。我如何才能做到这一点？

您可以尝试以下方法：

IEnumerable<ICD.ViewModels.HomeSearchViewModel> query =
                ICDUnitOfWork.AlphaGroups.Find()
                             .GroupJoin(
                                   ICDUnitOfWork.Alphas.Find()
                                                .GroupBy(a => new 
                                                                {
                                                                  BabyIndicator = a.Title.Contains("baby"),
                                                                  GroupID = a.AlphaGroupID
                                                                }),
                                   a => a.AlphaGroupID,
                                   g => g.Key.GroupID,
                                   (alphaGroups, alphas) =>
                                      new ICD.ViewModels.HomeSearchViewModel()
                                        {
                                          AlphaGroups = alphaGroups,
                                          Alphas = alphaGroups.Title.Contains("baby") ?
                                            alphas.Select(g => g.AsEnumerable()).Aggregate((g1,g2) => g1.Concat(g2)) :
                                            alphas.Aggregate(
                                            (g1,g2) => g1.Key.BabyIndicator ?
                                                       g1 :
                                                       g2).AsEnumerable()
                                        })

IEnumerable查询=
ICDUnitOfWork.AlphaGroups.Find（）
.GroupJoin(
ICDUnitOfWork.Alphas.Find（）
.GroupBy（a=>new
{
BabyIndicator=a.Title.Contains（“婴儿”），
GroupID=a.AlphaGroupID
}),
a=>a.AlphaGroupID，
g=>g.Key.GroupID，
（字母组，字母）=>
新ICD.ViewModels.HomeSearchViewModel（）
{
字母组=字母组，
Alphas=alphaGroups.Title.Contains（“婴儿”）？
alphas.Select（g=>g.AsEnumerable（））.Aggregate（（g1，g2）=>g1.Concat（g2））：
阿尔法骨料(
（g1，g2）=>g1.Key.BabyIndicator？
g1：
g2）.可计算（）
})

逻辑：

问题是当Alpha.Title包含字符串“baby”时 应该只显示包含“baby”的Alpha，而不是每个 阿尔法组中的阿尔法

在这里，我们根据groupID对Alpha进行分组，然后将其加入到AlphGroup中。所以我们有四种可能，没有组，一组没有婴儿，一组只有婴儿，每个都有一个。为了把这一切放在一起，我们把它们聚合起来。如果没有组，它将不返回组；如果有一个组，它将返回该组；如果有两个组，它将只返回一个有婴儿的组

如果AlphaGroup.Title包含“baby”，则应继续显示 组中的每个阿尔法

---

在这里，我们检查alphaGroup是否有一个标题婴儿，如果它返回整个分组，如果不应用alpha标题逻辑，那么联合可能更适合这种情况。一个返回所有符合条件的alpha，并与组中符合条件的所有alpha合并我认为这非常接近，但是我得到了错误：错误4无法隐式地将类型“System.Collections.Generic.IEnumerable”转换为“System.Collections.Generic.IEnumerable”。存在显式转换（是否缺少强制转换？@user547794已修复，聚合返回IEnumerable，但应返回分组，因此我们只需投影分组的可枚举位。。。。

IEnumerable<ICD.ViewModels.HomeSearchViewModel> query =
                ICDUnitOfWork.AlphaGroups.Find()
                             .GroupJoin(
                                   ICDUnitOfWork.Alphas.Find()
                                                .GroupBy(a => new 
                                                                {
                                                                  BabyIndicator = a.Title.Contains("baby"),
                                                                  GroupID = a.AlphaGroupID
                                                                }),
                                   a => a.AlphaGroupID,
                                   g => g.Key.GroupID,
                                   (alphaGroups, alphas) =>
                                      new ICD.ViewModels.HomeSearchViewModel()
                                        {
                                          AlphaGroups = alphaGroups,
                                          Alphas = alphaGroups.Title.Contains("baby") ?
                                            alphas.Select(g => g.AsEnumerable()).Aggregate((g1,g2) => g1.Concat(g2)) :
                                            alphas.Aggregate(
                                            (g1,g2) => g1.Key.BabyIndicator ?
                                                       g1 :
                                                       g2).AsEnumerable()
                                        })