CODEWITHSUNDEEP
linqentity-frameworkc#-4.0lambdalet
Reza Owliaei
Reza Owliaei

Reputation: 3363

How to "let" in lambda expression?

How can I rewrite this linq query to Entity on with lambda expression?
I want to use let keyword or an equivalent in my lambda expression.

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

For some similar questions like what is commented under my question, it's suggested to 

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

which will calculate AveragePrice for each item, while in Query style I mentioned, let expression prevents to calculate average many times.

Upvotes: 44

Views: 36847

Answers (4)

Yoeri
Yoeri

Reputation: 1906

Basically, you need to use Select and an anonymous type to add the average to your object, followed by the rest of your statement.

Not tested but it should look like this:

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);

Warning: This works well for Linq-to-Entities, but be careful with these constructs in Linq-to-Objects. Using let creates a new anonymous type per object in your collection, it consumes a lot of memory with large collections.

Look here for details: Let in chained extension methods

Upvotes: 27

daw
daw

Reputation: 2049

We can avoid the overhead of the lambda used in all the other answers with an inline out declaration:

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

And call it like this

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

Upvotes: 1

Timothy Shields
Timothy Shields

Reputation: 79441

Another option is to define this extension method:

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

Then write your query like this:

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

Upvotes: 4

Jay
Jay

Reputation: 57919

So, you can use the extension method syntax, which would involve one lambda expression more than you are currently using. There is no let, you just use a multi-line lambda and declare a variable:

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

Note that I changed the average price comparison, because yours would never return any results (more than 500 AND less that 250).

The alternative is

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);

Upvotes: 48

Related Questions