преобразовать это выражение LINQ в лямбду

Question

Ребята, мне сложно преобразовать приведенное ниже выражение linq (реализация в левом соединении) в лямбда-выражение (для обучения).

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

Может кто-нибудь подсказать мне, как это сделать.

И я действительно ценю, если кто-нибудь даст мне отличные учебные ссылки для "C # Lambdas & Linqs"

Answer 1

Чтобы преобразовать запрос Linq в его лямбда-эквивалент:

1. Скачать Linqpad и запустить свой запрос.
2. В окне результатов нажмите на кнопку «λ» на панели инструментов. Это прямо над окном результатов
3. Ваш запрос будет преобразован в Эквивалент лямбда-выражения!

Answer 2

Вы можете взглянуть на 101 Образцы LINQ и C # 3.0. ЗАПРОС ПЕРЕВОДА ВЫРАЖЕНИЯ ВЫВОДА

Answer 3

Вот эвристика, которой я следую:

Любите выражения LINQ над лямбдами, когда у вас есть объединения.

Я думаю, что лямбды с соединениями выглядят грязно и их трудно читать.

Answer 4

Я обычно использую ReSharper, чтобы помочь мне преобразовать вещи в цепочки методов и лямбда-выражения, что помогает мне довольно легко переходить назад и вперед.

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

И затем использование опции ReSharper для преобразования LINQ в цепочку методов равняется следующему:

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

Конечно, вывод менее желателен, но, по крайней мере, помогает начать с понимания синтаксиса.

Answer 5

Вот как вы можете написать этот запрос в лямбда-выражении:

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

Использование выражения запроса

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;

Использование лямбда-выражений

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

Оба подхода дают один и тот же результат (клиент с идентификатором компании «AC» и идентификатором клиента «Customer1»), но, как видите, лямбда-выражение гораздо сложнее писать и читать!

Надеюсь, это поможет!

Answer 6

Используйте Reflector .NET:)

Answer 7

Скачать LINQPad ; поставляется со встроенными образцами для изучения LINQ.