在 EF Core 2 中使用 Contains as (NOT) EXIST 不再适用于 EF Core 3.1

Question

After upgrading from EF Core 2.2 to EF Core 3.1 I run into the "LINQ queries are no longer evaluated on the client" issue.
I have the below queries in 2.2 which work fine:

var entQry = await
   (from up in _dbContext.Profiles
    join pa in _dbContext.Access
    on up.ProfileId equals pa.ProfileId
    where (up.IdentityUserId == identityUser.Id)
    select new
    {
        pa.LibraryId
    }).ToListAsync();

var libQry = await
   (from en in _dbContext.Entities
    join pa in _dbContext.Access
    on en.LibraryId equals pa.ObjectId
    where (up.IdentityUserId == identityUser.Id
           && !entQry.Contains(new { en.LibraryId }))
    select new
    {
        Id = en.Id
    }).ToListAsync();

In EF Core 3.1 the second query fails on the Contains method with the "cannot translate" error. After some trial and error I have rewritten this as follows:

var libQry2 = await
       (from en in _dbContext.Entities
        join pa in _dbContext.Access
        on en.LibraryId equals pa.ObjectId
        where (up.IdentityUserId == identityUser.Id)
        select new
        {
            Id = en.Id
        }).ToListAsync();

var libQry = libQry2.Where(w => !entQry.Any(c => c.LibraryId == w.Id));

Now although this works this is not what I want because I want the entire query to be executed on the server. Is that possible?

Can I get the first query (entQry) as a sub query in the second query so that it translates to SQL as:

SELECT en.Id
 FROM Entities en JOIN Access pa ON en.LibraryId equals pa.ObjectId
WHERE x.id NOT IN (SELECT up.LibraryId FROM Profiles up JOIN Access pa ON up.ProfileId = pa.ProfileId)
  AND up.IdentityUserId == @identityUser.Id

Answer 1

Try using Contains with collection of "primitive" types:

var entIds = await
   (from up in _dbContext.Profiles
    join pa in _dbContext.Access
    on up.ProfileId equals pa.ProfileId
    where (up.IdentityUserId == identityUser.Id)
    select pa.LibraryId)
    .ToListAsync(); 

var libQry = await
   (from en in _dbContext.Entities
    join pa in _dbContext.Access
    on en.LibraryId equals pa.ObjectId
    where (up.IdentityUserId == identityUser.Id
           && !entIds.Contains(en.LibraryId))
    select new
    {
        Id = en.Id
    }).ToListAsync();

Also I'm pretty much sure that EF Core 2 previously executed this filtering in-memory - see the automatic silent client side evaluation breaking change :

Old behavior

Before 3.0, when EF Core couldn't convert an expression that was part of a query to either SQL or a parameter, it automatically evaluated the expression on the client. By default, client evaluation of potentially expensive expressions only triggered a warning.

New behavior

Starting with 3.0, EF Core only allows expressions in the top-level projection (the last Select() call in the query) to be evaluated on the client. When expressions in any other part of the query can't be converted to either SQL or a parameter, an exception is thrown.