convert this LINQ expression into Lambda

To convert a Linq query to it's Lambda equivalent:

1. Download Linqpad and run your query.
2. In the results window, click on the "λ" button in the toolbar. It's right above the Results window
3. Your query will be converted to a Lambda expression equivalent!

You can take a look at 101 LINQ Samples and C# 3.0 QUERY EXPRESSION TRANSLATION CHEAT SHEET

Here's the heuristic that I follow:

Favor LINQ expressions over lambdas when you have joins.

I think that lambdas with joins look messy and are difficult to read.

I usually use ReSharper to help me convert things to method chains and lambda's, which helps me go back and forth fairly easy.

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

And then using ReSharper's option of convert LINQ to method chain equals the following:

        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 => @[email protected](), (@t, joinedFruit) => new {@t, joinedFruit})
                            .SelectMany(@t => @[email protected](),(@t, joinedVegg) =>
                                new
                                    {
                                        @t.@[email protected],
                                        @t.@[email protected],
                                        fname = ((@t.joinedFruit == null) ? string.Empty : @t.joinedFruit.fname),
                                        vname = ((joinedVegg == null) ? string.Empty : joinedVegg.vname)
                                    });

Granted the output is less then desirable, but It at least helps in starting somewhere on understanding the syntax.

Here’s how you might write this query in 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” }
};

Using query expres­sion

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;

Using lambda expres­sions

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

Both approach yields the same result (cus­tomer with com­pany Id “AC” and cus­tomer Id “Customer1”), but as you can see, lambda expres­sion is much harder to write and read!

Hope this helps!

Download LINQPad; it comes with built-in samples for learning LINQ.

Use Reflector .NET :)