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.

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:
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:
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:
var names = new[] { "Alice", "Bob", "Charlie" };
var lengths = names.Select(name => name.Length);The query syntax equivalent is:
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:
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:
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:
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.
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:
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:
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:
var allItemArrays = orders.Select(o => o.Items);allItemArrays is of type IEnumerable<string[]>. To get a flat sequence of all items, use SelectMany:
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.
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():
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:
var result = data.Where(x => x.IsActive).Select(x => x.Name).ToList();you could write:
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:
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:
var names = new string[] { "Alice", null, "Bob" };
var lengths = names.Select(n => n.Length); // throws NullReferenceExceptionYou need to check for null inside the selector or filter them out beforehand:
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 toolsSmall utilities that fit C# work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related C# guides
All C# guidesC# Dispose vs Destructor: Key Differences Explained
c# dispose vs destructor: Understand the difference between Dispose and destructors in C#, when each runs, and how to manage unmanaged resources correctly.
C# Variable Declaration: Syntax and Practical Usage
Learn how to declare variables in C# with explicit types, var, and nullable annotations, and understand how defaults, scope, and readability affect your choices.
C# Primary Constructors for Classes: Syntax and Usage
Learn how to use C# primary constructors for classes: syntax, initialization, dependency injection, and limitations with practical examples.
C# IComparer: Custom Sorting with IComparer<T>
Learn how to implement IComparer<T> in C# to define custom sort order for arrays and lists, handle nulls, and avoid common performance pitfalls.
More in C#
All C# guidesThe guides filed next to this one in C#, in library order.