LINQ and Expression Trees Interview Questions

decimal threshold = 100m;
List<decimal> totals = [50m, 120m, 300m];

IEnumerable<decimal> large = totals.Where(t => t > threshold);  // nothing runs yet
threshold = 200m;             // the lambda captured the variable, not its value
totals.Add(500m);             // read at enumeration time, not declaration time

Console.WriteLine(string.Join(", ", large));  // 300, 500

// IQueryable<Order>: the whole pipeline becomes one SQL statement.
var recent = await db.Orders
    .Where(o => o.CustomerId == customerId && o.PlacedOn >= since)
    .OrderByDescending(o => o.PlacedOn)
    .Select(o => new OrderSummary(o.Id, o.Total))
    .ToListAsync(ct);

// AsEnumerable switches to LINQ to Objects: every matching-by-nothing row loads first.
var slow = db.Orders.AsEnumerable().Where(o => o.CustomerId == customerId).ToList();

public static IOrderedQueryable<T> OrderByProperty<T>(
    this IQueryable<T> source, string propertyName, bool descending = false)
{
    var parameter = Expression.Parameter(typeof(T), "x");
    var property = Expression.Property(parameter, propertyName);   // throws if missing
    var keySelector = Expression.Lambda(property, parameter);

    var call = Expression.Call(
        typeof(Queryable),
        descending ? nameof(Queryable.OrderByDescending) : nameof(Queryable.OrderBy),
        [typeof(T), property.Type],
        source.Expression,
        Expression.Quote(keySelector));

    return (IOrderedQueryable<T>)source.Provider.CreateQuery<T>(call);
}

using System.Linq.Expressions;

Expression<Func<int, bool>> isAdult = age => age >= 18;
Func<int, bool> compiled = isAdult.Compile();          // expensive: do this once
Console.WriteLine(compiled(21));                        // cheap: invoke the cached delegate

private static readonly Func<ShopContext, Guid, IAsyncEnumerable<Order>> ByCustomer =
    EF.CompileAsyncQuery((ShopContext db, Guid customerId) =>
        db.Orders.Where(o => o.CustomerId == customerId).OrderByDescending(o => o.PlacedAt));

// Risky: each call below re-runs the underlying query or iterator.
IEnumerable<Order> overdue = repository.StreamOverdueOrders();
if (overdue.Any())
{
    logger.LogWarning("{Count} overdue orders", overdue.Count());  // second enumeration
    await notifier.SendAsync(overdue, ct);                          // third enumeration
}

// Safer: materialize once, then reuse the stable snapshot.
IReadOnlyList<Order> overdueList = [.. repository.StreamOverdueOrders()];
if (overdueList.Count > 0)
{
    logger.LogWarning("{Count} overdue orders", overdueList.Count);
    await notifier.SendAsync(overdueList, ct);
}

// Throws at run time: IsVip can't translate, and it isn't in the final projection.
var fails = await db.Orders.Where(o => IsVip(o.CustomerId)).ToListAsync(ct);

// Fine: FormatLabel runs client-side, but only after filtering and paging at the database.
var page = await db.Orders
    .Where(o => o.PlacedOn >= since)
    .OrderByDescending(o => o.PlacedOn)
    .Take(20)
    .Select(o => new { o.Id, Label = FormatLabel(o) })   // client-side in the final projection
    .ToListAsync(ct);

// Preferred: a captured variable becomes one SQL parameter; one cached plan serves every value.
var status = OrderStatus.Pending;
var pending = await db.Orders.Where(o => o.Status == status).ToListAsync(ct);

// Avoid in a hot path: each distinct literal compiles and caches a separate query shape.
var pendingLiteral = await db.Orders.Where(o => o.Status == OrderStatus.Pending).ToListAsync(ct);

// Idiomatic, but allocates a closure, a delegate and an enumerator per call.
static int CountAboveLinq(List<int> values, int limit) => values.Count(v => v > limit);

// Hot-path version: no allocations, direct access to the list's backing array.
static int CountAboveLoop(List<int> values, int limit)
{
    var count = 0;
    foreach (var v in CollectionsMarshal.AsSpan(values))
        if (v > limit) count++;
    return count;
}