LINQ Query Syntax and Advanced Patterns

LINQ has two equivalent syntaxes: method syntax (chained method calls: source.Where(x => ...).Select(x => ...)) and query syntax (SQL-like clauses: from x in source where ... select ...). Both compile to identical IL — the choice is purely stylistic. Query syntax shines for multi-join and let scenarios; method syntax is more concise for simple chains and is needed for operators without a query syntax equivalent (Skip, Take, Distinct, GroupBy with aggregation). Advanced patterns like pagination, chunking, and custom operators complete the LINQ toolkit.

Query Syntax #

var posts = GetPosts();

// ── Method syntax ─────────────────────────────────────────────────────────
var methodResult = posts
    .Where(p => p.IsPublished && p.ViewCount > 500)
    .OrderByDescending(p => p.ViewCount)
    .Select(p => new { p.Title, p.ViewCount });

// ── Equivalent query syntax ───────────────────────────────────────────────
var queryResult =
    from p in posts
    where p.IsPublished && p.ViewCount > 500
    orderby p.ViewCount descending
    select new { p.Title, p.ViewCount };

// Both produce identical results — choose based on readability

// ── Let clause — intermediate variable ───────────────────────────────────
var withSlug =
    from p in posts
    let slug = p.Title.ToLowerInvariant().Replace(" ", "-")
    where p.IsPublished
    select new { p.Title, Slug = slug, p.ViewCount };

// Equivalent in method syntax:
var withSlugMethod = posts
    .Where(p => p.IsPublished)
    .Select(p => new
    {
        p.Title,
        Slug = p.Title.ToLowerInvariant().Replace(" ", "-"),
        p.ViewCount,
    });

// ── Multi-from (cross join / flat join) ───────────────────────────────────
var tags    = new[] { "dotnet", "csharp" };
var authors = new[] { "Alice", "Bob" };

var pairs =
    from tag    in tags
    from author in authors
    select $"{author} writes about {tag}";
// "Alice writes about dotnet", "Alice writes about csharp",
// "Bob writes about dotnet",   "Bob writes about csharp"

Pagination with Skip and Take #

// Pagination — the most common real-world LINQ pattern
int page     = 2;
int pageSize = 10;

var pagedPosts = posts
    .Where(p => p.IsPublished)
    .OrderByDescending(p => p.CreatedAt)
    .Skip((page - 1) * pageSize)   // skip the first (page-1) pages
    .Take(pageSize)                 // take exactly pageSize items
    .ToList();

// Always order before paginating — without OrderBy, page results are non-deterministic
// In EF Core, this translates to: SELECT ... ORDER BY ... OFFSET ... ROWS FETCH NEXT ... ROWS ONLY

Advanced .NET 6+ LINQ Operators #

// Chunk — split a sequence into fixed-size batches
var allPosts = GetAllPosts();
foreach (var batch in allPosts.Chunk(50))
{
    await ProcessBatchAsync(batch);   // batch is Post[] of up to 50 items
}

// DistinctBy, MinBy, MaxBy — operate on a key selector
var uniqueAuthors  = posts.DistinctBy(p => p.AuthorId);
Post latestPost    = posts.MaxBy(p => p.CreatedAt)!;
Post shortestTitle = posts.MinBy(p => p.Title.Length)!;

// ExceptBy, IntersectBy, UnionBy — set operations on a key
var newPosts   = allPosts.ExceptBy(cachedIds, p => p.Id);

// Index — enumerate with index (like Python's enumerate)
foreach ((int i, Post p) in posts.Index())
    Console.WriteLine($"[{i}] {p.Title}");

Custom LINQ Extension Methods #

// Write your own composable LINQ operators
public static class LinqExtensions
{
    // Paginate any sequence
    public static IEnumerable<T> Paginate<T>(
        this IEnumerable<T> source, int page, int pageSize)
        => source.Skip((page - 1) * pageSize).Take(pageSize);

    // Filter out null values and change the type to non-nullable
    public static IEnumerable<T> WhereNotNull<T>(
        this IEnumerable<T?> source) where T : class
        => source.Where(x => x is not null)!;

    // Apply a transformation only if a condition is true
    public static IEnumerable<T> If<T>(
        this IEnumerable<T> source,
        bool condition,
        Func<IEnumerable<T>, IEnumerable<T>> transform)
        => condition ? transform(source) : source;
}

// Usage
var results = posts
    .Where(p => p.IsPublished)
    .If(filterByTag != null, q => q.Where(p => p.Tags.Contains(filterByTag!)))
    .OrderByDescending(p => p.CreatedAt)
    .Paginate(page, pageSize)
    .ToList();

Common Mistakes #

Mistake 1 — Paginating without ordering (non-deterministic results) #

❌ Wrong — page 2 may return different items each call:

posts.Skip(10).Take(10).ToList();   // no OrderBy — order undefined

✅ Correct — always establish a stable order first.

Mistake 2 — Using query syntax for operators that have no query syntax #

❌ Wrong — Skip/Take have no query syntax equivalent, compile error if attempted.

✅ Correct — wrap the query syntax expression in parentheses and chain method syntax: (from p in posts ... select p).Skip(n).Take(m).