convierte esta expresión LINQ en Lambda

Chicos, me cuesta mucho convertir esta expresión de linq a continuación (implementación de unión izquierda) en expresión lambda (para aprender).

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) }; 

¿Puede alguien sugerirme cómo hacer esto?

Y realmente aprecio que alguien me brinde los excelentes enlaces para “C # Lambdas & Linqs”

Para convertir una consulta Linq en su equivalente Lambda:

  1. Descarga Linqpad y ejecuta tu consulta.
  2. En la ventana de resultados, haga clic en el botón “λ” en la barra de herramientas. Está justo encima de la ventana de resultados
  3. ¡Su consulta se convertirá en una expresión Lambda equivalente!

enter image description here

Puede consultar 101 muestras de LINQ y C # 3.0. HOJA DE CHEAT DE TRADUCCIÓN DE EXPRESIÓN DE CONSULTA

Aquí está la heurística que sigo:

Favorece las expresiones LINQ sobre lambdas cuando tiene uniones.

Creo que las lambdas con combinaciones se ven desordenadas y son difíciles de leer.

Usualmente uso ReSharper para ayudarme a convertir las cosas en cadenas de métodos y lambda, lo que me ayuda a ir y venir bastante fácil.

  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) }; 

Y luego, usar la opción ReSharper de convertir LINQ a la cadena de métodos es igual a lo siguiente:

  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) }); 

De acuerdo, la salida es menos de lo deseable, pero al menos ayuda a comenzar en algún lugar a comprender la syntax.

A continuación, le mostramos cómo puede escribir esta consulta en 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” } }; 

Usando la expresión de consulta

 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 expresiones 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); 

Ambos enfoques producen el mismo resultado (cliente con ID de empresa “AC” e ID de cliente “Cliente1”), pero como puede ver, ¡la expresión lambda es mucho más difícil de escribir y leer!

¡Espero que esto ayude!

Descargar LINQPad ; viene con muestras incorporadas para aprender LINQ.

Use Reflector .NET 🙂