I can perform a join using a navigation property, which to me is more DRY because I'm not repeating the join criteria everywhere:

```
(from c in db.Companies
from e in c.Employees
select new { Employee = e, Company = c}).ToList();

```

Because the ORM knows how Companies is related to Employees, the `c.Employees` navigation property is used to infer the FK criteria for the join.

**What is the direct translation to extension/lambda syntax of a multiple from clause via navigation property?**

I know there is a Join extension method, but requires you explicitly name the FK's being compared, rather than it imply that criteria by the navigation property. This is non-working but hopefully expresses my intent:

```
db.Companies
  .Join(c.Employees, /* don't want to explicitly name FKs*/)
  .Select(x => new { Employee = x.e, Company = x.c}).ToList();

```

Of course `Join(c.Employees` doesn't work because there is no `c` in this context, but idea being somehow use the Companies.Employees navigation property to imply the join criteria. 

I know I can do:

```
db.Companies.Select(c => new { Employees = c.Employees, Company = c })

```

but that is a different result set, as it returns one record per company, and then the list of employees as a nested property. Rather than the first which is a join, thus there is a record for every related combination, and the result has a `Employee` property instead of a `Employees` collection.

I'm not sure, but guessing `.SelectMany` is the direct translation. You don't get a `c` reference to the parent, so if you do multiple of these:

```
db.Companies.SelectMany(c=>c.Employees).SelectMany(e=>e.VacationDays).Select(v => new { VacationDay = v, Employee = v.Employee, Company = v.Employee.Company })

```

You have to walk backwards across the relationships to flatten out the join. In linq it's much simpler because you would have `c`, `e` and `v` all in the context of the select. I don't know if you can express the same thing in extension methods, such that all three alias/references are passed down. Maybe just a consequence of the extension method syntax, but hoping someone will provide a better equivalent.