LINQ basics: filter, project, sort

Query collections declaratively with Where, Select, OrderBy and LINQ's aggregate methods.

Say what you want, not how to loop

Here's a familiar task — the names of adult users, sorted — written with loops:

var result = new List<string>();
foreach (var user in users)
{
    if (user.Age >= 18)
        result.Add(user.Name);
}
result.Sort();

And with LINQ (Language-Integrated Query):

var result = users
    .Where(u => u.Age >= 18)
    .Select(u => u.Name)
    .Order()
    .ToList();

The LINQ version reads like a description of the result. Each method takes a lambda — everything you learned about delegates pays off here. LINQ works on anything that implements IEnumerable<T>: arrays, lists, dictionaries, sets, strings, and (in Track 10) database tables.

For the examples below:

record Product(string Name, string Category, decimal Price, int Stock);
 
var products = new List<Product>
{
    new("Laptop", "Electronics", 999m, 3),
    new("Mouse", "Electronics", 19.99m, 10),
    new("Notebook", "Office", 4.5m, 100),
    new("Pen", "Office", 1.2m, 0),
};

Where: filter

var cheap = products.Where(p => p.Price < 20);                 // Mouse, Notebook, Pen
var inStockOffice = products.Where(p => p.Category == "Office" && p.Stock > 0);

Select: transform each element

var names = products.Select(p => p.Name);                       // "Laptop", "Mouse", ...
var labels = products.Select(p => $"{p.Name} ({p.Price:F2})");
var withTax = products.Select(p => new { p.Name, Total = p.Price * 1.2m });   // anonymous type

Sorting

products.OrderBy(p => p.Price);                     // cheapest first
products.OrderByDescending(p => p.Stock);           // most stock first
products.OrderBy(p => p.Category).ThenBy(p => p.Name);   // tie-breaker with ThenBy
new[] { 3, 1, 2 }.Order();                          // sort simple values by themselves

Picking single elements

Method	Returns	When nothing matches
`First(pred)`	the first match	throws
`FirstOrDefault(pred)`	the first match	`default` (`null` for classes)
`Single(pred)`	the only match	throws (also throws if several match)
`Last(pred)`, `ElementAt(i)`	…	throws
`MaxBy(sel)` / `MinBy(sel)`	element with the largest/smallest key	`null` for empty sequences of classes

var laptop = products.First(p => p.Name == "Laptop");
var garden = products.FirstOrDefault(p => p.Category == "Garden");   // null
var priciest = products.MaxBy(p => p.Price);                         // Laptop

Asking questions

bool anySoldOut = products.Any(p => p.Stock == 0);      // true
bool allCheap = products.All(p => p.Price < 1000);      // true
int officeCount = products.Count(p => p.Category == "Office");   // 2
bool hasPen = products.Select(p => p.Name).Contains("Pen");

Any() with no arguments checks for emptiness — clearer and often faster than Count() > 0.

Aggregates

decimal total = products.Sum(p => p.Price * p.Stock);
decimal average = products.Average(p => p.Price);
decimal cheapest = products.Min(p => p.Price);
int mostStock = products.Max(p => p.Stock);

Paging, distinct and conversion

products.Skip(10).Take(10);                  // page 2 with 10 per page
products.Select(p => p.Category).Distinct(); // "Electronics", "Office"
products.Where(...).ToList();                // materialize into a List<T>
products.ToArray();
products.ToDictionary(p => p.Name);          // key selector → Dictionary<string, Product>

Chaining

Each method returns a new sequence, so you chain them into a pipeline — formatted one call per line:

var report = products
    .Where(p => p.Stock > 0)
    .OrderByDescending(p => p.Price * p.Stock)
    .Take(3)
    .Select(p => $"{p.Name}: {p.Price * p.Stock:F2}");

LINQ never modifies the source

Where, Select, OrderBy… all return new sequences. The original list is untouched — unlike List.Sort() or RemoveAll(), which change the list in place.

Try it

Program.csCtrl + Enter to run

Loading editor…

C# runtime not loaded

Key takeaways

LINQ queries any IEnumerable<T> with chained methods that take lambdas.
Where filters, Select transforms, OrderBy/ThenBy sort.
First/Single throw on no match; the OrDefault versions return default.
Any, All, Count, Sum, Average, Min, Max answer questions about a sequence.