Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

C# LINQ Select: Syntax, Examples, and Pitfalls

Learn how to use C# LINQ Select to project data, including syntax, index usage, deferred execution, and common pitfalls.

~5 min readC#
#LINQ#C##Select#Projection
Diagram showing LINQ Select transforming a sequence of objects into a projected output sequence.

C# LINQ Select projects each element of a source sequence into a new form. The examples below cover the core syntax, index-based projections, deferred execution, and common mistakes.

Select is the projection operator in C# LINQ. It takes each element from a source sequence, applies a transformation function, and returns a new sequence of the transformed values. This method is the backbone of most LINQ queries because it lets you shape data into the exact form your application needs.

The Role of Select in LINQ

In LINQ, Select is used to transform the elements of a sequence. The transformation is defined by a lambda expression that receives each element and returns a new value. The source sequence can be any IEnumerable<T>, including arrays, lists, or the results of other LINQ methods. The output sequence is of type IEnumerable<TResult>, where TResult is the return type of the lambda.

The method signature is:

csharp
public static IEnumerable<TResult> Select<TSource, TResult>( this IEnumerable<TSource> source, Func<TSource, TResult> selector)

There is also an overload that provides the index of each element:

csharp
public static IEnumerable<TResult> Select<TSource, TResult>( this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)

The first overload is the most common. It is used in both method syntax and query syntax. In query syntax, select is a keyword that maps to Select. For example:

csharp
var names = new[] { "Alice", "Bob", "Charlie" }; var lengths = names.Select(name => name.Length);

The query syntax equivalent is:

csharp
var lengthsQuery = from name in names select name.Length;

In both cases, lengths (or lengthsQuery) contains the integer lengths of each string. The lambda name => name.Length is the selector.

Basic Projection Examples

Projection often involves creating anonymous types to combine multiple properties or to reshape objects. Consider a Person class with FirstName and LastName properties:

csharp
public class Person { public string FirstName { get; set; } public string LastName { get; set; } public int Age { get; set; } }

You can project to a new anonymous type that includes only the full name and age:

csharp
var people = new List<Person> { new Person { FirstName = "John", LastName = "Doe", Age = 30 }, new Person { FirstName = "Jane", LastName = "Smith", Age = 25 } }; var summaries = people.Select(p => new { FullName = $"{p.FirstName} {p.LastName}", p.Age });

The summaries sequence contains objects with FullName and Age properties. This is useful for passing only the required data to a view or an API response.

You can also use Select to convert types. For example, converting a list of integers to their string representations:

csharp
var numbers = new[] { 1, 2, 3 }; var strings = numbers.Select(n => n.ToString());

The result is IEnumerable<string>.

Projecting with the Element Index

The overload that includes the index is helpful when you need to know the position of each element in the source sequence. The index is zero-based. This is often used to add a sequence number to the output.

csharp
var fruits = new[] { "apple", "banana", "cherry" }; var numbered = fruits.Select((fruit, index) => $"{index + 1}. {fruit}");

Here, numbered contains strings like "1. apple", "2. banana", and "3. cherry". The index parameter is useful when you need to preserve order information or when you are building a report that requires line numbers.

Be aware that the index reflects the position in the source sequence as it is enumerated. If the source is filtered before Select, the index corresponds to the filtered sequence, not the original collection. For example:

csharp
var filtered = fruits.Where(f => f.Length > 5).Select((f, i) => $"{i}: {f}");

The index i is based on the elements that passed the Where filter, not on the original array.

Select vs SelectMany: When to Flatten

Select produces one output element for each input element. If your selector returns a sequence (such as an array or another IEnumerable), Select will produce a sequence of sequences. SelectMany flattens that result into a single sequence.

Consider a list of orders, where each order contains a list of items:

csharp
var orders = new[] { new Order { Id = 1, Items = new[] { "pen", "paper" } }, new Order { Id = 2, Items = new[] { "book", "ruler" } } };

Using Select gives you a sequence of arrays:

csharp
var allItemArrays = orders.Select(o => o.Items);

allItemArrays is of type IEnumerable<string[]>. To get a flat sequence of all items, use SelectMany:

csharp
var allItems = orders.SelectMany(o => o.Items);

Now allItems is IEnumerable<string> containing "pen", "paper", "book", "ruler".

The choice between Select and SelectMany depends on whether the selector returns a scalar value or a collection. If it returns a collection and you want to combine all those collections, use SelectMany. If you need to preserve the grouping, use Select.

Deferred Execution and Materialization

Select uses deferred execution. The transformation is not performed when the method is called. Instead, the resulting sequence is an iterator that applies the selector each time it is enumerated. This means that if the source sequence changes between the call to Select and the enumeration, the changes are reflected.

csharp
var numbers = new List<int> { 1, 2, 3 }; var doubled = numbers.Select(n => n * 2); numbers.Add(4); foreach (var d in doubled) { Console.WriteLine(d); // prints 2, 4, 6, 8 }

Because doubled is lazily evaluated, the new element 4 is included when the sequence is enumerated.

This behavior is efficient for single-pass operations, but it can cause unexpected results if the source is modified between calls. To force immediate evaluation, use materialization methods like ToList() or ToArray():

csharp
var doubledList = numbers.Select(n => n * 2).ToList();

Now doubledList is a snapshot of the transformed values at the time ToList is called. This is important when you need to store the result for later use or when the source is a database query that should be executed only once.

Performance Considerations

Select itself adds minimal overhead compared with a hand-written loop. The main overhead is the delegate invocation per element and the allocation of the iterator state machine. For most collections, this overhead is negligible. However, there are scenarios where you should consider the performance implications.

Chaining LINQ methods composes multiple iterator objects. For example, source.Where(...).Select(...).OrderBy(...) creates multiple iterator objects, and OrderBy also buffers its input. This can increase memory allocations and reduce cache locality compared with a single loop that performs all operations in one pass. For large sequences, this can matter.

If performance is critical, you can replace a chain with a manual foreach loop. For instance, instead of:

csharp
var result = data.Where(x => x.IsActive).Select(x => x.Name).ToList();

you could write:

csharp
var result = new List<string>(); foreach (var x in data) { if (x.IsActive) { result.Add(x.Name); } }

The manual loop avoids the delegate calls and the intermediate iterators. The difference is usually small, but it can be significant for millions of elements or in tight loops.

Another consideration is the creation of anonymous types. Each projection to an anonymous type allocates a new object. If you are projecting a large collection, this can increase garbage collection pressure. If the projected type is used only for a short time, it may be better to use a custom class or struct.

Common Mistakes and Edge Cases

One common mistake is assuming that Select modifies the source collection. It does not. Select returns a new sequence and leaves the original unchanged. If you need to update the original elements, you must iterate and assign explicitly.

Another issue is side effects in the selector. The selector should be a pure function that does not modify external state. If you write:

csharp
var counter = 0; var items = data.Select(x => { counter++; return x.Name; });

The selector has a side effect. This is problematic because the selector may be executed multiple times if the sequence is enumerated more than once. It also makes the code harder to reason about. Prefer a foreach loop if you need to count or accumulate state.

Null handling is also important. If the source sequence contains null elements, the selector must handle them. For example:

csharp
var names = new string[] { "Alice", null, "Bob" }; var lengths = names.Select(n => n.Length); // throws NullReferenceException

You need to check for null inside the selector or filter them out beforehand:

csharp
var validLengths = names.Where(n => n != null).Select(n => n.Length);

Finally, remember that Select is not the same as SelectMany. Using Select when you meant SelectMany can lead to nested sequences that are difficult to work with. Always check the type of the selector's return value.

Try matching browser tools

All tools

Small utilities that fit C# work — they run entirely in this browser tab, so nothing you paste leaves your device.

All C# guides

More in C#

All C# guides

The guides filed next to this one in C#, in library order.