In EF Core, you can easily filter to a list of known values using LINQ:

int[] ids = { 1, 3, 7 };
myContext.Posts.Where(s => ids.Contains(s.Id));

But what if the list of values includes composite keys, like Type and Name?

var filterBy = new[] { (PostTypes.Blog, "First"), (PostTypes.KnowledgeBase, "Last") };
myContext.Posts.Where(s => filterBy.Contains((s.Type, s.Name))); // But how?

There’s no direct Contains() support for tuples or composite keys in EF Core. A Stack Overflow post outlines several options. Here, I’ll focus on Option 6 — building an expression tree to generate a SQL query like:

SELECT * FROM Posts WHERE (Type = 1 AND Name = 'First') OR (Type = 2 AND Name = 'Last');

It’s All Expressions

The code is available on GitHub.

Let’s replicate the following filter:

context.Posts.Where(post =>
    (post.Author == "Mike" && post.Title == "Intro to mysql") ||
    (post.Author == "Mike" && post.Title == "How the world works"))

We construct an expression tree manually:

ParameterExpression postArgument = Expression.Parameter(typeof(BlogPost), "post");
MemberExpression propertyAuthor = Expression.Property(postArgument, nameof(BlogPost.Author));
MemberExpression propertyTitle = Expression.Property(postArgument, nameof(BlogPost.Title));

ConstantExpression constantAuthor = Expression.Constant("Mike");
ConstantExpression constantTitle = Expression.Constant("Intro to mysql");

BinaryExpression andExpr = Expression.AndAlso(
    Expression.Equal(propertyAuthor, constantAuthor),
    Expression.Equal(propertyTitle, constantTitle));

Combine multiple AND conditions using OR:

BinaryExpression orExpression = Expression.OrElse(firstAnd, secondAnd);
orExpression = Expression.OrElse(orExpression, thirdAnd);

Wrap it in a lambda:

Type delegateFunc = typeof(Func<,>).MakeGenericType(typeof(BlogPost), typeof(bool));
Expression<Func<BlogPost, bool>> lambda =
    (Expression<Func<BlogPost, bool>>)Expression.Lambda(delegateFunc, orExpression, postArgument);

Use it in your query:

context.Posts.Where(lambda);

Result

The query now supports filtering on multiple composite key pairs, and translates correctly to SQL.

Be sure to check out the working example on GitHub — it also prints out the SQL, so you can verify what’s happening behind the scenes.