Linq 关键字为Into的联接表上的Where子句

我希望在筛选其中一个表时联接两个表。这样很好

var matching = from a in ctx.A
               join b in ctx.B on a.BId equals b.Id
               where idList.Contains(b.Id)
               select a;

但是，如果我也使用

into

关键字来命名连接的结果

var matching = from a in ctx.A
               join b in ctx.B on a.BId equals b.Id into c
               where idList.Contains(b.Id)
               select a;

我得到一个编译器错误告诉我

名称“b”在当前上下文中不存在

但是，我可以在这一点上引用

a

，也可以引用“c”，而不会出现问题

这到底是为什么？我如何将where子句应用于

b

这到底是为什么

因为在一个

连接到
子句之后，该子句引入的范围变量不在范围内，而前面的变量在范围内。别忘了你正在加入
c
，因此
b
的每个值实际上都是值组（
c
）的一部分

我如何将where子句应用于b

通过更早地这样做：

var matching = from a in ctx.A
               join b in ctx.B.Where(x => idList.Contains(x.Id))
                 on a.BId equals b.Id into c
               where c.Any()
               select a;

编辑：这可以放入稍微多一些面向查询表达式的代码中，如下所示：

var matchingBs = from b in ctx.B
                 where idList.Contains(b.Id)
                 select b;
var matching = from a in ctx.A
               join b in matchingBs
                 on a.BId equals b.Id into c
               where c.Any()
               select a;

（您可以使用嵌套查询表达式，但我一般不喜欢这些。）

或者在
c
上使用
Any
：

var matching = from a in ctx.A
               join b in ctx.B on a.BId equals b.Id into c
               where c.Any(b => idList.Contains(b.Id))
               select a;

甚至：

var matching = from a in ctx.A
               where ctx.B.Any(b => idList.Contains(x.Id) &&
                                    a.BId == b.Id)
               select a;

可重写为：

var matching = ctx.A.Where(a => ctx.B.Any(b => idList.Contains(x.Id) &&
                                          a.BId == b.Id));

理解
join
和
join-into
之间的结果差异很重要-第一个创建“成对”连接；第二种方法创建一个组联接，其中额外范围变量的结果是一组匹配项

这到底是为什么

因为在一个
连接到
子句之后，该子句引入的范围变量不在范围内，而前面的变量在范围内。别忘了你正在加入
c
，因此
b
的每个值实际上都是值组（
c
）的一部分

我如何将where子句应用于b

通过更早地这样做：

var matching = from a in ctx.A
               join b in ctx.B.Where(x => idList.Contains(x.Id))
                 on a.BId equals b.Id into c
               where c.Any()
               select a;

编辑：这可以放入稍微多一些面向查询表达式的代码中，如下所示：

var matchingBs = from b in ctx.B
                 where idList.Contains(b.Id)
                 select b;
var matching = from a in ctx.A
               join b in matchingBs
                 on a.BId equals b.Id into c
               where c.Any()
               select a;

（您可以使用嵌套查询表达式，但我一般不喜欢这些。）

或者在
c
上使用
Any
：

var matching = from a in ctx.A
               join b in ctx.B on a.BId equals b.Id into c
               where c.Any(b => idList.Contains(b.Id))
               select a;

甚至：

var matching = from a in ctx.A
               where ctx.B.Any(b => idList.Contains(x.Id) &&
                                    a.BId == b.Id)
               select a;

可重写为：

var matching = ctx.A.Where(a => ctx.B.Any(b => idList.Contains(x.Id) &&
                                          a.BId == b.Id));

理解
join
和
join-into
之间的结果差异很重要-第一个创建“成对”连接；第二种方法创建一个组联接，其中额外范围变量的结果是一组匹配。
所有示例都至少需要一些Linq方法语法。这不能仅用查询语法来表达吗？@EricJ:我认为你不能不使用
Any
。我将在中编辑一个“最小方法语法”版本。您的所有示例都至少需要一些Linq方法语法。这不能仅用查询语法来表达吗？@EricJ:我认为你不能不使用
Any
。我将在中编辑一个“最小方法语法”版本。