What is the difference between Select and SelectMany in LINQ?

Select and SelectMany are projection operators used in Language Integrated Query (LINQ) to transform data from one form to another. Let’s discuss them one by one.

The Select operator

Each item in a collection (such as a list, array, or query result) can be changed into a different form using the Select command. There is a one-to-one mapping between the input items and the output elements as a result of its operation on a single collection. A new sequence with the same number of elements as the input sequence is produced, with each element having undergone the given projection. It is frequently used when we wish to change every element separately.

Code example

Let’s practice the Select operator with a simple example:

using System.Collections.Generic;
using System.Linq;
class Test
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3, 4 };
        var cubicNumbers = numbers.Select(x => x * x * x) ;
        foreach (int s in cubicNumbers)
        {
          System.Console.Write(s + " ");
        }
    }
}

Explanation

  • Lines 1–2: It imports necessary namespaces for working with collections and LINQ functionality.

  • Line 8: It creates a list of integers named numbers and initialize it with some values.

  • Line 9: It uses the LINQ Select method to transform each element in the numbers list by cubing it (raising it to the power of 3). This results in a new interface IEnumerable<int> containing the cubic values of the original numbers.

  • Lines 10–13: These use a foreach loop to iterate through each element in the cubicNumbers, and then output each cubic number followed by a space " " using System.Console.Write.

Note: IEnumerable is an interface in C# that represents a sequence of elements that can be enumerated (iterated) one at a time. IEnumerable<int> specifies that the sequence being represented is a sequence of integers (int in this case). In other words, cubicNumbers is a collection or sequence of integer values.

The SelectMany operator

When we wish to flatten a collection of collections (such as a series of sequences) into a single sequence, we use the SelectMany operator. When we wish to merge or concatenate elements from several collections into a flat sequence, it might be helpful.

Code example

Let’s practice the SelectMany operator with a simple example:

using System.Collections.Generic;
using System.Linq;
class Test
{
    static void Main()
    {
        var names = new List<List<string>>
        {
            new List<string> { "Johnny", "Luke" },
            new List<string> { "Bella" },
            new List<string> { "Harry", "Ollie", "Amy" }
        };
        var allNames = names.SelectMany(nameList => nameList);
        foreach (string n in allNames)
        {
          System.Console.Write(n + " ");
        }
    }
}

Explanation

  • Lines 1–2: These import necessary namespaces for working with collections and LINQ functionality.

  • Lines 8–13: These declare a variable named names. The var keyword is used for implicit type inference, and in this case, it infers that names is of type List<List<string>>.

    • = new List<List<string>> { ... } initializes the names variable with a list containing lists of strings. Each inner list represents a collection of orders. There are three inner lists in this example, and they contain different numbers of order strings.

  • Line 15: It declares a new variable named allNames. Again, the var keyword is used for type inference, and it infers that allNames will be of some appropriate type based on the right-hand side of the assignment. = orders.SelectMany(orderList => orderList); assigns the result of a LINQ query to the allNames variable. Let’s break down this part:

    • names: This is the collection we defined earlier, which is a list containing lists of strings.

    • .SelectMany(nameList => nameList): Here, we’re using the SelectMany projection operator. It operates on the names collection.

    • nameList => nameList: This is a lambda expression that represents a function. It’s applied to each element of the names collection. In this case, each element is an inner list of strings (e.g., "Johnny", "Luke").

    • SelectMany: This takes these inner lists and flattens them into a single sequence. So, it combines all the inner lists into a single flat list.

  • Lines 16–19: These use a foreach loop to iterate through each element in allNames, and then outputs each name followed by a space using System.Console.Write.

Select vs. SelectMany operators

Select

SelectMany

It produces a one-to-one mapping between the input items and the output elements as a result of its operation on a single collection.

It might be helpful when we wish to merge or concatenate elements from several collections into a flat sequence. It produces a single, flattened sequence as the output.

Does not flatten nested sequences.

Flattens nested sequences.

In conclusion, the primary difference between Select and SelectMany in LINQ is their behavior and output types. SelectMany is designed to flatten nested sequences by combining multiple sequences into a single flattened result, whereas Select transforms each element in a sequence while maintaining a one-to-one mapping. The choice between them is determined by the desired transformation and data structure in a LINQ query.

Free AI Mock Interviews
Coding Interview
Coding PatternsFree Interview
Gain insights and practical experience with coding patterns through targeted MCQs and coding problems, designed to match and challenge your expertise level.
System Design
You TubeFree Interview
Learn to design a video streaming platform like YouTube by tackling functional and non-functional requirements, core components, and high-level to detailed design challenges.

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved