LINQ & collections

#Choose the collection contract you need

A method that only iterates should not require callers to supply a List. Choose an interface by the operations needed, without promising immutability that the interface does not enforce.

IEnumerable<T>
  +-- ICollection<T>       Count, Add, Remove, IsReadOnly
  |     +-- IList<T>      indexed get/set, Insert, RemoveAt
  |     +-- ISet<T>       set operations
  +-- IReadOnlyCollection<T>   Count
  |     +-- IReadOnlyList<T>   indexed get
  +-- IQueryable<T>       Expression, Provider, ElementType

IReadOnlyList<T> does not inherit IList<T>.

static decimal Total(IEnumerable<decimal> prices) => prices.Sum();

var mutable = new List<int> { 1, 2 };
IReadOnlyList<int> view = mutable;  // (1)
mutable.Add(3);
Console.WriteLine(view.Count);     // (2) 3

IEnumerable does not guarantee lazy, cheap or repeatable enumeration. An ICollection implementation may be fixed-size or read-only, making mutation throw NotSupportedException. Avoid changing a List during foreach; use RemoveAll or a deliberate iteration strategy.

#Array, List and LinkedList costs

Choosing a collection because “insertion is faster” is incomplete without specifying the position and the cost of finding it.

var ids = new List<int>(capacity: 1000); // (1)
ids.Add(10);
ids.Add(20);
ids.RemoveAll(id => id < 15);           // (2)

var queue = new LinkedList<int>();
var node = queue.AddLast(20);
queue.AddBefore(node, 10);              // (3)

Start with List for general use. Queue and Stack express FIFO or LIFO requirements more directly than LinkedList.

#Dictionary and HashSet: index repeated lookups

foreach (var line in lines)
{
    var product = products.First(p => p.Id == line.ProductId);
    Console.WriteLine(product.Name);
}

var byId = products.ToDictionary(p => p.Id);        // (1)
foreach (var line in lines)
{
    if (byId.TryGetValue(line.ProductId, out var p)) // (2)
        Console.WriteLine(p.Name);
}

var emails = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
bool added = emails.Add("buyer@example.com");
bool duplicate = emails.Add("BUYER@example.com"); // false

Collisions can degrade hash operations to O(n) in the worst case. List.Contains is O(n); SortedDictionary provides O(log n) operations with key ordering. Equal keys must have equal hashes. Do not mutate hash-participating fields while a key is stored, or rely on Dictionary enumeration order as a contract.

#IEnumerable, IQueryable and generated SQL

With EF Core, IQueryable is a request sent to the store: “return these columns for large orders.” IEnumerable describes iteration; Enumerable operators after the boundary run .NET code over returned elements.

var big = db.Orders
    .AsEnumerable()                         // (1)
    .Where(o => o.Total > 1000m)
    .Select(o => new { o.Id, o.Total })
    .ToList();

var query = db.Orders
    .Where(o => o.Total > 1000m)             // (2)
    .Select(o => new { o.Id, o.Total });
Console.WriteLine(query.ToQueryString());    // (3)
var big = await query.ToListAsync(ct);

-- Representative SQL Server output; aliases vary by provider/version.
-- Before: all mapped order columns, no Total predicate.
SELECT [o].[Id], [o].[CustomerId], [o].[Total], [o].[Status]
FROM [Orders] AS [o];

-- After:
SELECT [o].[Id], [o].[Total]
FROM [Orders] AS [o]
WHERE [o].[Total] > 1000.0;

Not every IQueryable is SQL-backed, and not every expression translates. Modern EF Core generally rejects untranslatable Where expressions; top-level projection can use client evaluation. Keep query composition within the DbContext lifetime, inspect SQL and examine the execution plan.

#Deferred execution and repeated enumeration

A query is a recipe, not a finished meal. Where and Select are deferred and streaming. In LINQ-to-Objects, OrderBy and GroupBy are deferred but need buffering before yielding their first result.

var ids = new List<int> { 1, 2, 3 };
var query = ids.Where(id => id > 1);        // (1)
ids.Add(4);
Console.WriteLine(query.Count());           // (2) 3
var snapshot = query.ToArray();             // (3)
ids.Add(5);
Console.WriteLine(snapshot.Length);         // 3

var paid = db.Orders.Where(o => o.Status == "Paid");
bool exists = await paid.AnyAsync(ct);      // (4) query one
decimal total = await paid.SumAsync(o => o.Total, ct); // query two

Materialize once when reusing a reasonably sized result. If only a total is needed, remove the Any call and aggregate in the database instead of loading rows. IEnumerable does not guarantee that a file or network source can be read twice. Immediate operators include ToList, ToDictionary, First, Any and Sum.

#Projection, flattening and grouping

Decide the result shape first: one result per order, all lines in one sequence, or a total per customer. These are different transformations.

var totals = orders.Select(o => o.Total);                 // (1)
var lines = orders.SelectMany(o => o.Lines);             // (2)
var detail = orders.SelectMany(o => o.Lines,
    (o, line) => new { OrderId = o.Id, line.ProductId });

var revenue = orders.GroupBy(o => o.CustomerId)           // (3)
    .Select(g => new
    {
        CustomerId = g.Key,
        Count = g.Count(),
        Total = g.Sum(o => o.Total)
    });

In memory, GroupBy retains elements in groups. Consider CountBy for counts alone. In EF Core, scalar group aggregates commonly translate to GROUP BY; returning entire groups has a different shape. SelectMany translation depends on the expression and provider.

#Join and .NET 10 LeftJoin

An inner join excludes unmatched rows. A customer report may need customers with no orders; a left join preserves them and allows a missing right-side value.

var matched = customers.Join(orders,                    // (1)
    c => c.Id, o => o.CustomerId,
    (c, o) => new { c.Name, OrderId = o.Id });

var all = customers.LeftJoin(orders,                    // (2) .NET 10
    c => c.Id, o => o.CustomerId,
    (c, o) => new { c.Name, OrderId = o == null ? (int?)null : o.Id });

// Before .NET 10:
var old = from c in customers
          join o in orders on c.Id equals o.CustomerId into matches
          from o in matches.DefaultIfEmpty()           // (3)
          select new { c.Name, OrderId = o == null ? (int?)null : o.Id };

For IQueryable, use EF Core 10 with a compatible provider and inspect SQL. Joins do not remove duplicates. A later WHERE predicate on the right side can remove unmatched rows unless it explicitly permits missing values.

#Element selection and quantifiers

The operator expresses a contract: “the first match” differs from “exactly one match.” Do not hide duplicate-data bugs with First for convenience.

bool hasPaid = orders.Any(o => o.Status == "Paid");       // (1)
bool allPaid = orders.All(o => o.Status == "Paid");       // (2)
bool nonEmptyAndPaid = orders.Count > 0 && allPaid;       // List<Order>
int absent = Array.Empty<int>().FirstOrDefault();         // (3) 0

List.Count is O(1), and Count() may use collection counts; not every Count scans. Single does not replace a database unique constraint. Specify ordering when “first” has business meaning.

#Ordering and pagination: offset versus keyset

Order pages need a deterministic, unique ordering or items can repeat or disappear between pages. OrderBy establishes a new primary ordering; ThenBy adds a tie-breaker.

int pageSize = 20;
var offsetPage = await db.Orders
    .OrderBy(o => o.CreatedAt).ThenBy(o => o.Id)          // (1)
    .Skip((pageNumber - 1) * pageSize).Take(pageSize)
    .Select(o => new { o.Id, o.CreatedAt, o.Total })
    .ToListAsync(ct);

var nextPage = await db.Orders
    .Where(o => o.CreatedAt > lastTime ||                 // (2)
        (o.CreatedAt == lastTime && o.Id > lastId))
    .OrderBy(o => o.CreatedAt).ThenBy(o => o.Id)
    .Take(pageSize).ToListAsync(ct);

Offset supports numbered jumps but deep offsets require more work and rows shift under inserts or deletes. Keyset suits next/previous navigation and avoids traversing earlier pages, but arbitrary jumps are harder. Changes to sort keys can still affect results; a cursor is not a transaction snapshot.

#Batching, deduplication and per-key aggregates

For batches or counts, full groups and nested loops may be unnecessary. These are LINQ-to-Objects examples; an Enumerable operator does not guarantee EF translation.

foreach (var batch in orders.Chunk(100))                  // (1) .NET 6
    Console.WriteLine(batch.Length);

var unique = products.DistinctBy(p => p.Sku,
    StringComparer.OrdinalIgnoreCase);                  // (2) .NET 6

var counts = orders.CountBy(o => o.CustomerId);          // (3) .NET 9
var totals = orders.AggregateBy(o => o.CustomerId,
    seed: 0m, func: (sum, order) => sum + order.Total);   // (4) .NET 9

The older equivalents are GroupBy followed by Count or another aggregate. Chunk after AsEnumerable is not database pagination; materializing the whole table first also loses streaming benefits.

#Frozen, immutable and concurrent collections

A read-heavy, rarely updated catalog can use a suitable snapshot instead of locking readers around a changing dictionary. Define how the new snapshot is safely published.

using System.Collections.Frozen;
using System.Collections.Immutable;

var prices = new Dictionary<int, decimal> { [10] = 120m };
FrozenDictionary<int, decimal> frozen = prices.ToFrozenDictionary(); // (1)

var original = ImmutableDictionary<int, decimal>.Empty.Add(10, 120m);
var changed = original.SetItem(10, 125m);                            // (2)
Console.WriteLine(original[10]); // 120
Console.WriteLine(changed[10]);  // 125

Frozen suits build-once/read-many data; immutable collections suit versioned updates. Neither makes mutable contained values immutable. For shared mutable collections, see ConcurrentDictionary and Channels in topic 04: Async and multithreading. Publishing an immutable snapshot still needs coordination when multiple writers update it.