convertire questa espressione LINQ in Lambda

Ragazzi, ho difficoltà a convertire questo sotto l’espressione linq (implementazione del join sinistro) in espressione lambda (per l’apprendimento).

var result = from g in grocery join f in fruit on g.fruitId equals f.fruitId into tempFruit join v in veggie on g.vegid equals v.vegid into tempVegg from joinedFruit in tempFruit.DefaultIfEmpty() from joinedVegg in tempVegg.DefaultIfEmpty() select new { g.fruitId, g.vegid, fname = ((joinedFruit == null) ? string.Empty : joinedFruit.fname), vname = ((joinedVegg == null) ? string.Empty : joinedVegg.vname) }; 

Qualcuno può suggerirmi come farlo.

E apprezzo molto se qualcuno mi fornisce gli eccellenti collegamenti tutorial per “C # Lambdas & Linqs”

Per convertire una query di Linq al suo equivalente Lambda:

  1. Scarica Linqpad ed esegui la tua query.
  2. Nella finestra dei risultati, fai clic sul pulsante “λ” nella barra degli strumenti. È proprio sopra la finestra dei risultati
  3. La tua query verrà convertita in equivalente espressione Lambda!

inserisci la descrizione dell'immagine qui

Puoi dare un’occhiata a 101 LINQ Samples e C # 3.0 QUERY EXPRESSION TRANSLATION CHEAT SHEET

Ecco l’euristica che seguo:

Esprimi le espressioni LINQ su lambda quando ti unisci.

Penso che i lambda con le unioni siano disordinati e difficili da leggere.

Di solito uso ReSharper per aiutarmi a convertire le cose in catene di metodi e lambda, il che mi aiuta ad andare avanti e indietro abbastanza facilmente.

  var result = from g in grocery join f in fruit on g.fruitId equals f.fruitId into tempFruit join v in veggie on g.vegid equals v.vegid into tempVegg from joinedFruit in tempFruit.DefaultIfEmpty() from joinedVegg in tempVegg.DefaultIfEmpty() select new { g.fruitId, g.vegid, fname = ((joinedFruit == null) ? string.Empty : joinedFruit.fname), vname = ((joinedVegg == null) ? string.Empty : joinedVegg.vname) }; 

E poi usare l’opzione di ReSharper per convertire LINQ in catena di metodi equivale a quanto segue:

  var result =grocery .GroupJoin(fruit, g => g.fruitId, f => f.fruitId, (g, tempFruit) => new {g, tempFruit}) .GroupJoin(veggie, @t => @tgvegid, v => v.vegid, (@t, tempVegg) => new {@t, tempVegg}) .SelectMany(@t => @t.@t.tempFruit.DefaultIfEmpty(), (@t, joinedFruit) => new {@t, joinedFruit}) .SelectMany(@t => @t.@t.tempVegg.DefaultIfEmpty(),(@t, joinedVegg) => new { @t.@t.@tgfruitId, @t.@t.@tgvegid, fname = ((@t.joinedFruit == null) ? string.Empty : @t.joinedFruit.fname), vname = ((joinedVegg == null) ? string.Empty : joinedVegg.vname) }); 

Garantito che l’output è meno desiderabile, ma almeno aiuta ad iniziare da qualche parte a capire la syntax.

Ecco come potresti scrivere questa query in lambda:

 var customers = new List { new Customer { CompanyId = “AC”, CustomerId = “Customer1” }, new Customer { CompanyId = “not-AC”, CustomerId = “Customer2” }, }; var userCustomers = new List { new UserCustomer { CompanyId = “AC”, CustomerId = “Customer1”, User = “not-admin” }, new UserCustomer { CompanyId = “AC”, CustomerId = “Customer1”, User = “admin” }, new UserCustomer { CompanyId = “AC”, CustomerId = “Customer2”, User = “not-admin” }, new UserCustomer { CompanyId = “AC”, CustomerId = “Customer2”, User = “admin” }, new UserCustomer { CompanyId = “not-AC”, CustomerId = “Customer1”, User = “not-admin” }, new UserCustomer { CompanyId = “not-AC”, CustomerId = “Customer1”, User = “admin” }, new UserCustomer { CompanyId = “not-AC”, CustomerId = “Customer2”, User = “not-admin” }, new UserCustomer { CompanyId = “not-AC”, CustomerId = “Customer2”, User = “admin” } }; 

Utilizzando l’espressione di query

 var query = from c in customers join uc in userCustomers on new { c.CompanyId, c.CustomerId } equals new { uc.CompanyId, uc.CustomerId } where c.CompanyId == “AC” && uc.User == “admin“ select c; 

Usando espressioni lambda

 var lambda = customers.Where(c => c.CompanyId == “AC”) // inner sequence .Join(userCustomers.Where(uc => uc.User == “admin”), // outer sequence c => new { c.CompanyId, c.CustomerId }, // inner key selector uc => new { uc.CompanyId, uc.CustomerId }, // outer key selector (c, uc) => c); 

Entrambi gli approcci producono lo stesso risultato (cliente con ID azienda “AC” e ID cliente “Cliente1”), ma come puoi vedere, l’espressione lambda è molto più difficile da scrivere e leggere!

Spero che questo ti aiuti!

Scarica LINQPad ; viene fornito con campioni integrati per l’apprendimento di LINQ.

Usa Reflector .NET 🙂