LINQ to SQL: notando una expresión preconstruida

Question

Estoy construyendo una biblioteca de funciones para una de mis clases centrales L2S, todas las cuales devuelven un bool para permitir la verificación de ciertas situaciones.

Ejemplo:

Expression<Func<Account, bool>> IsSomethingX = 
     a => a.AccountSupplementary != null 
     && a.AccountSupplementary.SomethingXFlag != null 
     && a.AccountSupplementary.SomethingXFlag.Value; 

Ahora para consultar cuando esto no es cierto, no puedo hacer esto:

var myAccounts= context.Accounts 
     .Where(!IsSomethingX); // does not compile 

Sin embargo, usando la sintaxis de la clase PredicateBuilder, he llegado hasta con esto:

public static IQueryable<T> WhereNot<T>(this IQueryable<T> items, 
     Expression<Func<T, bool>> expr1) 
{ 
    var invokedExpr = Expression.Invoke(expr1, expr1.Parameters.Cast<Expression>()); 
    return items.Where(Expression.Lambda<Func<T, bool>> 
      (Expression.Not(invokedExpr), expr1.Parameters)); 
} 

var myAccounts= context.Accounts 
     .WhereNot(IsSomethingX); // does compile 

que realmente produce el SQL correcto.

¿Esto parece una buena solución, y hay algo que debo tener en cuenta que pueda causarme problemas en el futuro?

Answer 1

Escribí algunos códigos de prueba utilizando su método de extensión WhereNot y se ve bien. La solución de @Stephan también funciona, pero me gustaría la legibilidad del método de extensión.

Answer 2

var compiled = IsSomethingX.Compile(); 
var myAccounts = context.Accounts.Where(x => !compiled(x));