LINQKit

LINQKit allows you to compose expressions by having one expression call another using the .Invoke() extension method. To resolve the invocation into a single, clean expression tree, you must use the .Expand() extension method.

• Invoke: An extension method used to call an inner expression within a larger expression.
• Expand: An extension method used to strip away the Invoke calls and flatten the expression tree.

Important: If you are using an invoked expression within a LINQ to SQL or Entity Framework query and have already called .AsExpandable() on the table, you do not need to call .Expand() manually; AsExpandable handles it automatically.

Warning: Avoid recursive expressions (e.g., assigning an expression to itself via Invoke), as they cannot be expanded and will result in the loss of the original predicate.

Expression<Func<Purchase, bool>> criteria1 = p => p.Price > 1000;
Expression<Func<Purchase, bool>> criteria2 = p => criteria1.Invoke(p) || p.Description.Contains("a");

Console.WriteLine (criteria2.Expand().ToString());
// Output: p => ((p.Price > 1000) || p.Description.Contains("a"))

Use PredicateBuilder to construct complex, dynamic AND/OR logic for LINQ queries. This is particularly useful for keyword searches or filtering where the number of conditions is unknown at compile time.

To search for products containing all keywords (AND logic):

var predicate = PredicateBuilder.New<Product>(true);
foreach (string keyword in keywords)
{
  string temp = keyword;
  predicate = predicate.And(p => p.Description.Contains(temp));
}
return dataContext.Products.Where(predicate);

To search for products containing any keywords (OR logic):

var predicate = PredicateBuilder.New<Product>();
foreach (string keyword in keywords)
{
  string temp = keyword;
  predicate = predicate.Or(p => p.Description.Contains(temp));
}
return dataContext.Products.Where(predicate);

Note: When using Entity Framework, you must call .AsExpandable() on your IQueryable to allow LINQKit to expand the invocation expressions into a format EF understands.

LINQKit is distributed via several NuGet packages depending on your target framework and ORM:

• LinqKit.Core: The base package. Supports a wide range of frameworks including .NET 10.0, .NET Standard (1.3, 2.0, 2.1), .NET Framework (3.5, 4.0, 4.5+), and UAP 10.
• LinqKit: For Entity Framework (EF) users. Requires EntityFramework $\ge$ 6.2.0 (net45) or $\ge$ 6.3.0 (netstandard2.1).
• LinqKit.EntityFramework: Specifically for Entity Framework users.
• LinqKit.Microsoft.EntityFrameworkCore: Multiple versions are available to match your EF Core version:
  • v1.3.6 for EF Core $\ge$ 1.1.1
  • v2.1.6 for EF Core $\ge$ 2.0.1
  • v3.1.6 for EF Core $\ge$ 3.0.1
  • v5.1.6 for EF Core $\ge$ 5.0.0
  • v6.1.6 for EF Core $\ge$ 6.0.0
  • v7.1.6 for EF Core $\ge$ 7.0.0
  • v8.1.6 for EF Core $\ge$ 8.0.0
  • v9.0.6 for EF Core $\ge$ 9.0.0
  • v10.0.0 for EF Core $\ge$ 10.0.0
• LinqKit.Z.EntityFramework.Classic: For Z.EntityFramework.Classic $\ge$ 7.2.36.

You can create reusable, generic expressions by defining an interface for common properties and using that interface as a constraint in a generic method. This allows you to apply the same logic (e.g., checking if a record is 'current' based on date ranges) across multiple different entity types without duplicating code.

1. Define an interface with the required properties.
2. Create a static generic method that returns an Expression<Func<TEntity, bool>> constrained to that interface.
3. Implement the interface in your entity classes (using partial classes if using generated code).

public interface IValidFromTo
{
   DateTime? ValidFrom { get; }
   DateTime? ValidTo   { get; }
}

public static Expression<Func<TEntity, bool>> IsCurrent<TEntity>()
   where TEntity : IValidFromTo
{
   return e => (e.ValidFrom == null || e.ValidFrom <= DateTime.Now) &&
               (e.ValidTo   == null || e.ValidTo   >= DateTime.Now);
}

public partial class PriceList : IValidFromTo { }

When using LINQ to SQL or Entity Framework, association properties like Customer.Purchases often return EntitySet<T> or EntityCollection<T>, which do not implement IQueryable<T>. This prevents you from passing an Expression<Func<T, bool>> directly into methods like .Any().

To solve this, you must:

1. Call .AsExpandable() on the root Table<T> or DbSet<T> object.
2. Call .Compile() on the expression variable when using it inside the association property.

Note: .Compile() does not actually execute the delegate; instead, the AsExpandable wrapper intercepts the call and substitutes the expression tree back in, allowing the ORM to translate it to SQL.

static string[] QueryCustomers (Expression<Func<Purchase, bool>> purchaseCriteria)
{
  var data = new MyDataContext();

  var query =
    from c in data.Customers.AsExpandable()
    where c.Purchases.Any (purchaseCriteria.Compile())
    select c.Name;

  return query.ToArray();
}