Question

I’m looking exactly the same

How to efficiently query with filter on children at different levels?

but “in lambdas” syntax.

I am really need this, can anybody help? Thanks!

Answer 1

Here is the code snippet from the post you referenced in both the query syntax and the lambda syntax: https://stackoverflow.com/a/12324116/670028:

LINQ query syntax:

var listOfString = new List<string>() { "String1", "String2" };

var customers =
(
    from a in session.Query<A>()
    from b in a.B
    from c in b.C
    where a.Status == "Active"
            && listOfStrings.Contains( b.SomeField )
            && listOfStrings.Contains( c.someOtherField )
    select a )
    .ToList();

LINQ lambda syntax:

var listOfString = new List<string>() { "String1", "String2" };

var customers =
    (
        session.Query<A>()
            .SelectMany( a => a.B, ( a, b ) => new { a, b } )
            .SelectMany( @t => b.C, ( @t, c ) => new { @t, c } )
            .Where( @t => a.Status == "Active"
                            && listOfStrings.Contains( b.SomeField )
                            && listOfStrings.Contains( c.someOtherField ) ).
            Select
            ( @t => a ) )
        .ToList();

As you can see, it’s not as “clean” as the LINQ query syntax because you have to continue to project into a new anonymous type each time you use the .SelectMany() method. It can also get a little confusing with the all of those variable names which is why I tend to use the LINQ query syntax instead of lambdas when I need to perform queries like this.

And just for fun, here is an example of using .SelectMany() that looks a little better and more realistic by giving the anonymous types more meaningful names:

public void Get_StarPowerCorporations_PendingShipment_Orders_Shipping_To_NewYork_Or_Chicago()
{
    var session = UnitOfWork.Current.GetSession();

    var listOfCities = new List<string> { "New York", "Chicago" };

    var customerAndOrders = session.Query<Customer>()
        .SelectMany( c => c.Orders, ( Customer, Orders ) => new { Customer, Orders } )
        .SelectMany( CustomerAndOrders => CustomerAndOrders.Orders.OrderDetails, ( CustomerAndOrders, OrderDetails ) => new { CustomerAndOrders, OrderDetails } )
        .Where( x => x.CustomerAndOrders.Customer.CompanyName == "StarPower Corporatation"
                        && x.CustomerAndOrders.Orders.Status == "Pending Shipment"
                        && listOfCities.Contains( x.OrderDetails.City ) )
        .Select( x => x.CustomerAndOrders.Customer )
        .Fetch( x => x.Orders )
        .ToList();
}

public class Customer
{
    public int CustomerId { get; set; }
    public string CompanyName { get; set; }
    public IList<Address> Addresses { get; set; }
    public IList<Order> Orders { get; set; }
}

public class Address
{
    public int AddressId { get; set; }
}

public class Order
{
    public int OrderId { get; set; }
    public string Status { get; set; }
    public IList<OrderDetail> OrderDetails { get; set; }
}

public class OrderDetail
{
    public int OrderDetailId { get; set; }
    public string City { get; set; }
}