Den stora fördelen med Entity Framework är LINQ to Entities. Det är extremt enkelt att modulärt bygga på IQueryable vid behov. Till exempel så är det inte ovanligt att vilja läsa in refererade entities direkt (Eagerly Load) som normalt laddas in vid behov (Lazy Load). För att göra detta i Entity Framework så används Include-funktionen

    Context.Customers.Include(x => x.Orders)

I detta enkla scenario är det inte svårt att förstå vad som ska hända, men i ett mer krångligt scenario så blir koden mindre uppenbar

    // För att automatiskt läsa in ett länkat objekts 
    // egna länkade object så använd Select inne i Include
    Context.Customers.Include(x => x.Orders.Select(x => x.Rows)).Include(x => x.People)

Vad jag då hellre ser är en förklarade text för vad jag vill göra.

    Context.Customers.EagerlyLoadOrdersRowsAndPeople()

Detta är busenkelt med en eller flera Extension Methods.

public static class CustomerExtensions
{
    public static IQueryable<Customer> EagerlyLoadOrdersRowsAndPeople(this IQueryable<Customer> s)
    {
        var customers = (DbSet<Customer>)s;
        return customers.Include(x => x.Orders.Select(x => x.Rows)).Include(x => x.People);
    }
}

Det går även bra attt bygga upp dessa av varandra

public static class CustomerExtensions
{
    public static IQueryable<Customer> EagarlyLoadOrdersRowsAndPeople(this IQueryable<Customer> s)
    {
        return s.EagarlyLoadOrdersAndRows().EagarlyLoadPeople();
    }
    
    public static IQueryable<Customer> EagarlyLoadOrdersAndRows(this IQueryable<Customer> s)
    {
        var customers = (DbSet<Customer>)s;
        return customers.Include(x => x.Orders.Select(x => x.Rows));
    }
    
    public static IQueryable<Customer> EagarlyLoadPeople(this IQueryable<Customer> s)
    {
        var customers = (DbSet<Customer>)s;
        return customers.Include(x => x.People);
    }
}