LINQ expression error after upgrading to .Net7 [duplicate] - asp.net-mvc

Question

This question already has an answer here:
How to select top N rows for each group in a Entity Framework GroupBy with EF 3.1
(1 answer)
Closed last month.
After upgrading from .Net2.2 to .Net7, the following LINQ expression fails with this error "LINQ expression could not not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly":
string excludeString = "XX";
string excludeString2 = "XX";
var groupfilter = await _db.UserGroup.Where(q => q.UserName == currUserName && q.IsActive == false && q.WorkGroupName == "BB").ToListAsync();
if (groupfilter.Any())
excludeString = "BB";
groupfilter = await _db.UserGroup.Where(q => q.UserName == currUserName && q.IsActive == false && q.WorkGroupName == "TS").ToListAsync();
if (groupfilter.Any())
excludeString2 = "TS";
DriveListViewModel model = new DriveListViewModel()
{
Drive = await _db.Drive
.Where(m => m.StatusId == 5 || m.StatusId == 1010 || m.StatusId == 1012)
.Where(m => m.LoadingComplete == null)
.Where(m => !m.UnitCode.Contains(excludeString))
.Where(m => !m.UnitCode.Contains(excludeString2))
.Include(s => s.DriveStatus)
.Include(d => d.Location)
.Include(f => f.Item)
.GroupBy(m => m.RegistrationNumber)
.Select(m => m.FirstOrDefault())
.OrderBy(m => m.DriverToLoad)
.ToListAsync(),
machineryList = await _db.Machinery.ToListAsync(),
cleaningList = await _db.Cleaning.ToListAsync(),
};
Disabling these 3 lines removes the error:
.GroupBy(m => m.RegistrationNumber)
.Select(m => m.FirstOrDefault())
.OrderBy(m => m.DriverToLoad)
...however, I need this list to be distinct on "RegistrationNumber", so I need a modified query to obtain the same result.
Any ideas how to solve that in .Net7 ?

Answer 1

The EF Core 2.2 query wasn't working from the start. Instead of warning you though, EF Core silently loaded all matching rows in memory and partitioned them on the client. EF Core 2 was so limited that many important operations like GroupBy couldn't be translated to SQL, so silent client-side evaluation was used. I suspect the application is already logging EF warnings about this.
EF Core 3.0 added support for all important operations so client-side evaluation was disabled by default. Loading 10000 rows when you only wanted the SUM by 10 categories wasn't a very nice experience. Since EF Core 3, expressions that can't be translated to SQL throw an exception.
The original query doesn't do what it seems to do either, and produces somewhat random results. There's no implicit order in a table or query results unless an ORDER BY clause is used. There's no such clause in .Select(m => m.FirstOrDefault()) though, so the first object returned from the database is used, whatever that is.
If the intention is to return the first Driver by DriverToLoad for each RegistrationNumber, the following query should work:
var statuses=new[]{5,1010,1012};
var drives=await _db.Drive
...
.GroupBy(m => m.RegistrationNumber)
.Select(g => g.OrderBy(m=>m.DriverToLoad).Take(1))
.ToListAsync()
The Where clauses can be simplified quite a bit too, and contain some performance problems.
This condition translates to LIKE '%%XX%% which can't use any indexes and can result in a full table scan :
.Where(m => !m.UnitCode.Contains(excludeString))
A prefix search on the other hand can use indexes as it's essentially a range search between the prefix and the next largest string. If possible, use
.Where(m => !m.UnitCode.StartsWith(excludeString))