如何在 lambda 表达式中“让”？

Question

如何使用 lambda 表达式将此 linq 查询重写为实体？
我想在我的 lambda 表达式中使用 let 关键字或等效关键字。

var results = from store in Stores
              let AveragePrice =  store.Sales.Average(s => s.Price)
              where AveragePrice < 500 && AveragePrice > 250

对于一些类似的问题，比如我的问题下评论了什么，建议

.Select(store=> new { AveragePrice = store.Sales.Average(s => s.Price), store})

它将计算每个项目的AveragePrice，而在我提到的查询样式中，let 表达式会阻止多次计算平均值。

Answer 1

因此，您可以使用扩展方法语法，这将涉及比您当前使用的多一个 lambda 表达式。没有let，你只需使用多行lambda并声明一个变量：

var results = Stores.Where(store => 
{
    var averagePrice = store.Sales.Average(s => s.Price);
    return averagePrice > 250 && averagePrice < 500;
});

请注意，我更改了平均价格比较，因为您的将永远不会返回任何结果（超过 500 且少于 250）。

另一种选择是

var results = Stores.Select(store => new { Store = store, AveragePrice = store.Sales.Average(s => s.Price})
    .Where(x => x.AveragePrice > 250 && x.AveragePrice < 500)
    .Select(x => x.Store);

Answer 2

基本上，您需要使用 Select 和匿名类型将平均值添加到您的对象，然后是您的语句的其余部分。

未经测试，但应该如下所示：

Stores.Select(
x => new { averagePrice = x.Sales.Average(s => s.Price), store = x})
.Where(y => y.averagePrice > 500 && y.averagePrice < 250)
.Select(x => x.store);

警告，小心这些结构。使用 let 为集合中的每个对象创建一个新的匿名类型，它会在大型集合中消耗大量内存 ...

详情请看这里： Let in chained extension methods

Answer 3

另一种选择是定义这个扩展方法：

public static class Functional
{
    public static TResult Pipe<T, TResult>(this T value, Func<T, TResult> func)
    {
        return func(value);
    }
}    

然后像这样编写您的查询：

var results = Stores
    .Where(store => store.Sales.Average(s => s.Price)
        .Pipe(averagePrice => averagePrice < 500 && averagePrice > 250));

Answer 4

我们可以通过 inline out 声明避免在所有其他答案中使用的 lambda 的开销：

public static class FunctionalExtensions
{
    public static T Assign<T>(this T o, out T result) =>
        result = o;
}

然后这样称呼它

var results = Stores
    .Where(store => store.Sales
        .Average(s => s.Price)
        .Assign(out var averagePrice) < 500 && averagePrice > 250);