convierta esta expresión LINQ en Lambda

Question

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 si alguien me da las excelentes conexiones de tutorial para "C# lambdas & Linqs"

Answer 1

Puede echar un vistazo a 101 LINQ Samples y C# 3.0 QUERY EXPRESSION TRANSLATION CHEAT SHEET

Answer 2

Descargar LINQPad; viene con muestras incorporadas para aprender LINQ.

Answer 3

utilizar el reflector .NET :)

Answer 4

Ésta es la heurística que seguir: expresiones

favor LINQ sobre lambdas cuando se tiene une.

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

Answer 5

Normalmente utilizo 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 a continuación, utilizando la opción de convertir LINQ a la cadena método de ReSharper es igual a lo siguiente:

 var result =grocery .GroupJoin(fruit, g => g.fruitId, f => f.fruitId, (g, tempFruit) => new {g, tempFruit}) 
          .GroupJoin(veggie, @t => @t.g.vegid, 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.@t.g.fruitId, 
             @t.@t.@t.g.vegid, 
             fname = ((@t.joinedFruit == null) ? string.Empty : @t.joinedFruit.fname), 
             vname = ((joinedVegg == null) ? string.Empty : joinedVegg.vname) 
            }); 

Por supuesto, la salida es menos deseable, pero al menos ayuda a comenzar en alguna parte de la comprensión de la sintaxis.

Answer 6

convertir una consulta de LINQ a que es equivalente Lambda:

1. Descargar Linqpad y ejecutar la consulta .
2. En la ventana de resultados, haga clic en en el botón "λ" en la barra de herramientas. Está justo encima de la ventana Resultados
3. Su consulta se convertirá en una expresión Lambda equivalente!

Answer 7

Así es como se podría escribir esta consulta en lambda:

var cus­tomers = new List { 
new Cus­tomer { Com­pa­nyId = “AC”, Cus­tomerId = “Customer1” }, 
new Cus­tomer { Com­pa­nyId = “not-AC”, Cus­tomerId = “Customer2” }, 
}; 

var user­Cus­tomers = new List { 
new User­Cus­tomer { Com­pa­nyId = “AC”, Cus­tomerId = “Customer1”, User = “not-admin” }, 
new User­Cus­tomer { Com­pa­nyId = “AC”, Cus­tomerId = “Customer1”, User = “admin” }, 
new User­Cus­tomer { Com­pa­nyId = “AC”, Cus­tomerId = “Customer2”, User = “not-admin” }, 
new User­Cus­tomer { Com­pa­nyId = “AC”, Cus­tomerId = “Customer2”, User = “admin” }, 
new User­Cus­tomer { Com­pa­nyId = “not-AC”, Cus­tomerId = “Customer1”, User = “not-admin”  }, 
new User­Cus­tomer { Com­pa­nyId = “not-AC”, Cus­tomerId = “Customer1”, User = “admin” }, 
new User­Cus­tomer { Com­pa­nyId = “not-AC”, Cus­tomerId = “Customer2”, User = “not-admin” }, 
new User­Cus­tomer { Com­pa­nyId = “not-AC”, Cus­tomerId = “Customer2”, User = “admin” } 
}; 

Usando la expresión de consulta

var query = 
from c in cus­tomers 
join uc in user­Cus­tomers on 
new { c.CompanyId, c.CustomerId } equals new { uc.CompanyId, uc.CustomerId } 
where c.CompanyId == “AC” && uc.User == “admin“ 
select c; 

El uso de expresiones lambda

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

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

Espero que esto ayude!