Making a self-contained boolean Expression with PredicateBuilder

Question

I'm trying to figure out how to use PredicateBuilder to determine if a specific set of records exists all within an Expression. So given an OrderId and a list of ProductIds as a specification, I want to know if the Order's OrderDetail records contain all of the specification items. Not just one or some of them - but all of them.

So I could do:

var inner = PredicateBuilder.False<OrderDetail>();

foreach (int spec in specs)
{
   temp = spec;            
   inner = inner.Or(d => d.ProductId == temp);
}

var outer = PredicateBuilder.True<OrderDetail>();

outer = outer.And(d => d.OrderId == orderId);
outer = outer.And(inner);

But then, after I get the result, I would have to a) eliminate duplicates (because in my case multiple OrderDetails can have the same ProductId) and then b) compare the result count to the spec count. All of this is doable outside the Expression, but is there an elegant way to evaluate all that in the Expression such that the result is a boolean?

That is, I'd like to have the Expression be self contained so that it can be passed around as is and those that I give it to don't have to know how to do the "post processing" to figure out if its true.

Answer 1

For the example you've given, I believe you can do it much simpler by looking at it differently.

Instead of working from your OrderDetails out, start with your specs and make sure that they are All in the OrderDetails collection. This one line of code will meet your requirement of making sure that a particular orderID contains all the specs and it's not at all complicated:

bool containsAllSpecs = specs.All 
    (s => orderDetails.Any (p => p.OrderId == orderId && p.ProductId == s));

I think what makes trying to build an Expression from within your OrderDetail class impossible is that the expression is applied to only a single item in the entire collection and therefor has no idea of the other items in the collection.

If you really want to create an Extension to hide as much logic as possible, you could put this in an extension:

static class MyExtensions
{
    public static bool ContainsAllSpecs(this IEnumerable<OrderDetail> orderDetails,
        int orderId,
        IEnumerable<int> specs)
    {
        return specs
         .All (s => orderDetails.Any (p => p.OrderId == orderId && p.ProductId == s));
    }
}

And then you would call it from code like:

bool containsAllSpecs = orderDetails.ContainsAllSpecs(orderId, specs);