LINQ select 如何在一个列表中存在但在另一个列表中不存在的ID

Question

I have two models like this:

public class Process
{
        public int Id { get; set; }
        public int PaletID { get; set; }
        public Palet Palet { get; set; }
        public DateTime Start { get; set; }
        public DateTime? End { get; set; }
}

public class Palet
    {
        public int Id { get; set; }     
        public int DeliveryNoteID { get; set; }          
        public DateTime Date { get; set; }
        public string Type { get; set; }
        public int Length { get; set; }
        public int Width { get; set; }
        public int Height { get; set; }
        public int? Nrpcs { get; set; }
        public double Volume { get; private set; }                       
        public Status Status { get; set; }        
        public DeliveryNote DeliveryNote { get; set; }        
    }

What I need to do is select (for autocomplete), Ids that exist in Palet, but do not exist in Process and that begin with the keyword.

I would like to access data in this way:

string keyword;
var Data = await _context.Process
                     .Include(p => p.Palet)                  
                     .OrderBy(p => p.PaletID)
                     .Take(dm.Take)
                     .ToListAsync(); 

The return should be an int or even better object Processes How can I do this?

Answer 1

What I need to do is select (for autocomplete), Ids that exist in Palet, but do not exist in Process.

listOfPalet.Select(p => p.Id).Except(listOfProcess.Select(p => p.Id))

Note that the operation will also deduplicate the list of Palet IDs. The output is a list of just the IDs. If you want the whole Palet object, let me know and I'll make a revision

Answer 2

Sounds like a job for .GroupJoin() . Maybe something like this:

IReadOnlyList<Palet> palets = LoadPalets();
IReadOnlyList<Process> processes = LoadProcesses();

var paletsWithoutProcess = palets
    .GroupJoin(
        processes,
        palet => palet.Id,
        process => process.PaletId,
        (palet, processes) => processes.Any() ? null : palet)
    .Where(palet => palet != null)
    .ToList();

Answer 3

thank you for your hints. The IEnumerable.Except() did the trick. The final solution look like that:

var Data = await _context.Paleta
                    .Select(p => p.Id)
                    .Except(_context.Process.Select(p => p.PaletaID))
                    .Where(p => p.ToString().Contains(keyword))
                    .OrderBy(i=>i)
                    .Take(20)
                    .ToListAsync();