Come utilizzare variabili locali in un'espressione lambda

Question

Ho 2 lista oggetto di tipo di una classe,

class person 
    { 
     public string id { get; set; } 
     public string name { get; set; } 
    } 

List<person> pr = new List<person>(); 
pr.Add(new person { id = "2", name = "rezoan" }); 
pr.Add(new person { id = "5", name = "marman" }); 
pr.Add(new person { id = "3", name = "prithibi" }); 

List<person> tem = new List<person>(); 
tem.Add(new person { id = "1", name = "rezoan" }); 
tem.Add(new person { id = "2", name = "marman" }); 
tem.Add(new person { id = "1", name = "reja" }); 
tem.Add(new person { id = "3", name = "prithibi" }); 
tem.Add(new person { id = "3", name = "prithibi" }); 

ora devo ottenere tutti gli ID da "pr" ListObject che non ha alcuna voce o numero dispari di voci nel "tem" ListObejct. usando lamda.

Per fare questo ho usato,

HashSet<string> inconsistantIDs = new HashSet<string>(pr.Select(p => p.id).Where(p => tem.FindAll(t => t.id == p).Count == 0 || tem.FindAll(t => t.id == p).Count % 2 != 0)); 

e funziona benissimo.

ma si può vedere dal codice ho usato tem.FindAll (t => t.id == p) Count due volte per comapre con == 0 e % 2! = 0.

C'è un modo per utilizzare tem.FindAll (t => t.id == p) Count una sola volta e salvarlo a una variabile temporanea e quindi confrontare questa variabile con == 0 e % 2! = 0.

Più semplicemente voglio solo usarlo una volta per due condizioni qui.

Answer 1

Use a statement lambda instead of an expression lambda

var inconsistantIDs = new HashSet<string>(
      pr.Select(p => p.id).Where(p => 
        { 
        var count = tem.FindAll(t => t.id == p).Count; 
        return count == 0 || count % 2 != 0; 
        } 
      )); 

Answer 2

HashSet<string> inconsistantIDs = new HashSet<string>(
    pr.Select(p => new { Id = p.id, Cnt = tem.FindAll(t => t.id == p.id).Count() }) 
     .Where(p => p.Cnt == 0 || p.Cnt % 2 != 0) 
     .Select(p => p.Id); 

Answer 3

Forse semplicemente:

var query = pr.Where(p => { int c = tem.Count(p2 => p.id == p2.id); return c == 0 || c % 2 != 0; }); 

restituisce due persone:

2 "rezoan" 
5 "marman" 

Answer 4

Su un lato nota, rigorosamente Per quanto riguarda le prestazioni, si otterrebbero prestazioni migliori se si creava una mappatura hash di ciascun ID al suo conteggio e quindi la si cerca in un ciclo.

In questo momento si ha un algoritmo O(n*m), che sarebbe ridotto a O(n+m):

// create a map (id -> count), O(m) operation 
var dictionary = new Dictionary<string, int>(); 
foreach (var p in tem) 
{ 
    var counter = 0; 
    dictionary.TryGetValue(p.id, out counter); 
    counter++; 
    dictionary[p.id] = counter; 
} 

// search the map, O(n) operation 
var results = new HashSet<string>(); 
foreach (var p in pr) 
{ 
    var counter = 0; 
    dictionary.TryGetValue(p.id, out counter); 
    if (counter == 0 || counter % 2 != 0) 
     results.Add(p.id); 
} 

Answer 5

Oltre dichiarazione lambda è possibile utilizzare let clause:

HashSet<string> inconsistantIDs = new HashSet<string>(
    from p in pr 
    let count = tem.FindAll(t => t.id == p).Count 
    where count == 0 || count % 2 != 0 
    select p.id 
);