Linq

By the end of this lesson you'll be able to query any collection in C# the way you'd ask a question in plain English — filtering, sorting, reshaping, and summarising data with short, readable chains instead of hand-written loops. This is the single most-used feature in everyday C#.

Part of the free C# course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

💡 Real-World Analogy

LINQ is like having a personal assistant for your data. Without it, finding the right records means opening a filing cabinet and flicking through every folder by hand (a for loop). With LINQ you just say: "give me all invoices over £500, newest first, and only the customer names." The assistant does the searching ( Where ), the sorting ( OrderBy ), and the tidying-up ( Select ) — and hands you exactly what you asked for, in one clean sentence. LINQ stands for Language Integrated Query : a query language baked right into C#.

📊 The LINQ Operators You'll Use Daily

Operator

What it does

Example

Returns

Where

Keep matching items

.Where(n => n > 5)

a sequence

Select

Transform each item

.Select(n => n * 2)

OrderBy

Sort ascending

.OrderBy(p => p.Price)

GroupBy

Bucket by a key

.GroupBy(p => p.Cat)

groups

First / FirstOrDefault

Get the first match

.First(x => x.Ok)

one item

Any / All

Test the sequence

.Any(x => x < 0)

bool

Count / Sum / Average

Reduce to one number

.Sum(o => o.Total)

a number

ToList

Run now & snapshot

.ToList()

List < T >

Everything in LINQ works on IEnumerable < T > — the common interface every list, array, and most collections implement. That's why one set of operators works on all of them.

Running C# locally: install the .NET SDK or use dotnetfiddle.net . Remember using System.Linq; at the top of every file that queries.

1. Filtering & Transforming — Where and Select

The two workhorses of LINQ are Where and Select . Where filters : you give it a test (a lambda that returns true or false ) and it keeps only the items that pass. Select transforms : it runs a lambda on each item and gives you back the results — a process called projection . A lambda like n => n > 5 is just a tiny inline function: read => as "goes to". Read this worked example, run it, then you'll write your own.

Your turn. The program below is almost complete — fill in the blank in the Where lambda so it keeps scores greater than 5, then run it and check the output.

2. Sorting & Projecting — OrderBy + Select

OrderBy sorts a sequence using the key its lambda returns — OrderBy(p => p.Price) sorts by price, smallest first; OrderByDescending reverses it. You'll almost always pair sorting with a Select projection to reshape each item into the form you want to show — a label, a summary, or a new object. Now you try: sort the prices, then project each into a tidy label.

3. Querying Collections of Objects

LINQ truly shines on lists of objects. You filter by a property ( s => s.GPA > 3.6 ), sort by another, then project into exactly the shape you need. The single-item operators earn their keep here too: First grabs the first match (and throws if there isn't one), while Any and All answer yes/no questions about the whole sequence. Aggregates like Average(s => s.GPA) take a selector so they know which number to crunch.

4. Deferred vs Immediate Execution

This is the LINQ behaviour that surprises everyone once. A LINQ query is deferred (lazy): defining it doesn't run anything — it just stores the recipe . The work happens later, the moment you enumerate it (a foreach , string.Join , Count() , etc.). So if the source list changes between defining and running the query, the query sees the change. Calling ToList() (or ToArray() ) runs it immediately and snapshots the result, freezing it. Watch both happen.

🔎 Deep Dive: First , FirstOrDefault and Single

These four operators all return one item, but they fail very differently — and choosing the wrong one is a classic source of crashes.

Rule of thumb: use FirstOrDefault when "no match" is normal and you'll check for null ; use First only when you're certain a match exists; reach for Single when a value must be unique (like a lookup by primary key) and you want it to blow up loudly if it isn't.

5. Query Syntax vs Method Syntax

C# gives you two ways to write the same query. Method syntax uses the extension methods and lambdas you've used so far ( .Where(...).OrderBy(...).Select(...) ) — it's the most common in production code and composes freely. Query syntax ( from ... where ... orderby ... select ) reads like SQL and can be clearer for joins and grouping. They compile to the same thing, so pick whichever is more readable. This example shows both, plus GroupBy to bucket items by a key.

Putting It Together: an Orders Report

Here's a small but real program that uses everything from this lesson at once — a Where filter with two conditions, an OrderByDescending sort, a Select projection into a formatted line, and a couple of one-line aggregates straight off the source list. You understand every part now.

Notice the report and the two summary lines each enumerate the list independently — that's deferred execution at work. For a handful of orders that's fine; for a huge or expensive source, call ToList() once and reuse the result.

Pro Tips

• 💡 LINQ is lazy: nothing runs until you enumerate. If you'll iterate a query more than once — or the source might change — call .ToList() once and reuse it.
• 💡 Prefer FirstOrDefault over First whenever "no match" is a real possibility; then check the result for null instead of catching an exception.
• 💡 Chain reads like a sentence: .Where().OrderBy().Select() — filter, then sort, then reshape. Keep that order and your queries stay readable.
• 💡 Use the right aggregate: Count(x => ...) , Sum(x => ...) , and Average(x => ...) take a selector, so you rarely need a manual loop with a running total.
• 💡 Method syntax wins in production — it's more concise and composable — but use query syntax when a join or group genuinely reads more clearly that way.

Common Errors (and the fix)

• "CS1061: 'List < int > ' does not contain a definition for 'Where'": you forgot using System.Linq; at the top. The LINQ methods are extension methods that only appear once that namespace is imported.
• "System.InvalidOperationException: Sequence contains no elements": you called First() (or Single() , Average() ) on an empty result. Use FirstOrDefault() and check for null , or test with .Any() first.
• "Sequence contains more than one matching element": Single(...) found two or more matches. Use First(...) if you only want the first, or fix the data so the value really is unique.
• Deferred-execution surprise: your query "changed" after you defined it. It didn't — it just ran later and saw the updated source. Add .ToList() to snapshot the result at the point you define it.
• "System.NullReferenceException" inside a Select : a lambda touched a property on a null item, e.g. .Select(s => s.Name.ToUpper()) when an s is null. Filter first ( .Where(s => s != null) ) or use the null-conditional s?.Name .

📋 Quick Reference

Task

Code

Result

Filter

nums.Where(n => n > 5)

matching items

Transform

nums.Select(n => n * 2)

new items

Sort

items.OrderBy(x => x.Key)

ascending

Group

items.GroupBy(x => x.Cat)

groups by key

First match

items.FirstOrDefault(p)

item or null

items.Any(x => x.Ok)

true / false

Sum / Count

items.Sum(x => x.Total)

Run now

query.ToList()

snapshot list

Frequently Asked Questions

Q: My query "re-ran" and gave different results — is that a bug?

No, that's deferred execution . A LINQ query is a recipe that runs each time you enumerate it, so it always reflects the source at that moment . If you want a fixed result, call .ToList() to run it once and snapshot it.

Q: When should I use First versus FirstOrDefault ?

Use FirstOrDefault when "no match" is a normal outcome — it returns null (or 0 for numbers) instead of throwing. Use First only when you're certain a match exists and an empty result genuinely is a bug.

Q: Is query syntax or method syntax "better"?

Neither — they compile to the same code. Method syntax is more common and composes more freely, so most teams default to it. Query syntax can read more clearly for joins and grouping. Pick whichever is easier to read for the query at hand.

Q: What is IEnumerable < T > and why do I keep seeing it?

It's the interface that means "a sequence you can iterate one item at a time." Lists, arrays, and most collections implement it, and LINQ operators both take and return it — which is exactly why the same Where / Select work on all of them, and why a chain stays lazy until you enumerate.

Mini-Challenge: Premium Products

No blanks this time — just a brief and an outline to keep you on track. Starting from the list of products, chain Where + OrderBy + Select to build a list of premium products (over £50), cheapest first, formatted as "Name — £Price" , then print each line. Run it and check your output against the expected lines in the comments.

🎉 Lesson Complete

• ✅ Where filters, Select transforms (projects) — the two LINQ workhorses
• ✅ OrderBy / OrderByDescending sort; GroupBy buckets items by a key
• ✅ Sum , Count , Average , Any , All reduce a sequence to one value
• ✅ FirstOrDefault is safe on empty; First / Single throw — choose deliberately
• ✅ Queries are deferred (lazy) until enumerated; ToList() runs & snapshots them
• ✅ Method syntax and query syntax compile to the same thing; both work on IEnumerable < T >
• ✅ Next lesson: Async & Await — writing non-blocking code that doesn't freeze your app

Practice quiz

Continue this course

• Previous: Exception Handling
• Next: Async & Await