Difference Between Select and SelectMany

Select many is like cross join operation in SQL where it takes the cross product.
For example if we have

Set A={a,b,c} Set B={x,y} 

Select many can be used to get the following set

{ (x,a) , (x,b) , (x,c) , (y,a) , (y,b) , (y,c) } 

Note that here we take the all the possible combinations that can be made from the elements of set A and set B.

Here is a LINQ example you can try

List<string> animals = new List<string>() { "cat", "dog", "donkey" }; List<int> number = new List<int>() { 10, 20 }; var mix = number.SelectMany(num => animals, (n, a) => new { n, a }); 

the mix will have following elements in flat structure like

{(10,cat), (10,dog), (10,donkey), (20,cat), (20,dog), (20,donkey)} 

var players = db.SoccerTeams.Where(c => c.Country == "Spain") .SelectMany(c => c.players); foreach(var player in players) { Console.WriteLine(player.LastName); } 

1. De Gea
2. Alba
3. Costa
4. Villa
5. Busquets

...

SelectMany() lets you collapse a multidimensional sequence in a way that would otherwise require a second Select() or loop.

More details at this blog post.

There are several overloads to SelectMany. One of them allows you to keep trace of any relationship between parent and children while traversing the hierarchy.

Example: suppose you have the following structure: League -> Teams -> Player.

You can easily return a flat collection of players. However you may lose any reference to the team the player is part of.

Fortunately there is an overload for such purpose:

var teamsAndTheirLeagues = from helper in leagues.SelectMany ( l => l.Teams , ( league, team ) => new { league, team } ) where helper.team.Players.Count > 2 && helper.league.Teams.Count < 10 select new { LeagueID = helper.league.ID , Team = helper.team }; 

The previous example is taken from Dan's IK blog. I strongly recommend you take a look at it.

The SelectMany() method is used to flatten a sequence in which each of the elements of the sequence is a separate.

I have class user same like this

class User { public string UserName { get; set; } public List<string> Roles { get; set; } } 

main:

var users = new List<User> { new User { UserName = "Reza" , Roles = new List<string>{"Superadmin" } }, new User { UserName = "Amin" , Roles = new List<string>{"Guest","Reseption" } }, new User { UserName = "Nima" , Roles = new List<string>{"Nurse","Guest" } }, }; var query = users.SelectMany(user => user.Roles, (user, role) => new { user.UserName, role }); foreach (var obj in query) { Console.WriteLine(obj); } //output //{ UserName = Reza, role = Superadmin } //{ UserName = Amin, role = Guest } //{ UserName = Amin, role = Reseption } //{ UserName = Nima, role = Nurse } //{ UserName = Nima, role = Guest } 

You can use operations on any item of sequence

int[][] numbers = { new[] {1, 2, 3}, new[] {4}, new[] {5, 6 , 6 , 2 , 7, 8}, new[] {12, 14} }; IEnumerable<int> result = numbers .SelectMany(array => array.Distinct()) .OrderBy(x => x); //output //{ 1, 2 , 2 , 3, 4, 5, 6, 7, 8, 12, 14 } 

 List<List<int>> numbers = new List<List<int>> { new List<int> {1, 2, 3}, new List<int> {12}, new List<int> {5, 6, 5, 7}, new List<int> {10, 10, 10, 12} }; IEnumerable<int> result = numbers .SelectMany(list => list) .Distinct() .OrderBy(x=>x); //output // { 1, 2, 3, 5, 6, 7, 10, 12 } 

I understand SelectMany to work like a join shortcut.

So you can:

var orders = customers .Where(c => c.CustomerName == "Acme") .SelectMany(c => c.Orders); 

Select is a simple one-to-one projection from source element to a result element. Select- Many is used when there are multiple from clauses in a query expression: each element in the original sequence is used to generate a new sequence.

The formal description for SelectMany() is:

Projects each element of a sequence to an IEnumerable and flattens the resulting sequences into one sequence.

SelectMany() flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

class PetOwner { public string Name { get; set; } public List<String> Pets { get; set; } } public static void SelectManyEx() { PetOwner[] petOwners = { new PetOwner { Name="Higa, Sidney", Pets = new List<string>{ "Scruffy", "Sam" } }, new PetOwner { Name="Ashkenazi, Ronen", Pets = new List<string>{ "Walker", "Sugar" } }, new PetOwner { Name="Price, Vernette", Pets = new List<string>{ "Scratches", "Diesel" } } }; // Query using SelectMany(). IEnumerable<string> query1 = petOwners.SelectMany(petOwner => petOwner.Pets); Console.WriteLine("Using SelectMany():"); // Only one foreach loop is required to iterate // through the results since it is a // one-dimensional collection. foreach (string pet in query1) { Console.WriteLine(pet); } // This code shows how to use Select() // instead of SelectMany(). IEnumerable<List<String>> query2 = petOwners.Select(petOwner => petOwner.Pets); Console.WriteLine("\nUsing Select():"); // Notice that two foreach loops are required to // iterate through the results // because the query returns a collection of arrays. foreach (List<String> petList in query2) { foreach (string pet in petList) { Console.WriteLine(pet); } Console.WriteLine(); } } /* This code produces the following output: Using SelectMany(): Scruffy Sam Walker Sugar Scratches Diesel Using Select(): Scruffy Sam Walker Sugar Scratches Diesel */ 

The main difference is the result of each method while SelectMany() returns a flattern results; the Select() returns a list of list instead of a flattern result set.

Therefor the result of SelectMany is a list like

{Scruffy, Sam , Walker, Sugar, Scratches , Diesel}

which you can iterate each item by just one foreach. But with the result of select you need an extra foreach loop to iterate through the results because the query returns a collection of arrays.

Some SelectMany may not be necessary. Below 2 queries give the same result.

Customers.Where(c=>c.Name=="Tom").SelectMany(c=>c.Orders) Orders.Where(o=>o.Customer.Name=="Tom") 

For 1-to-Many relationship,

1. if Start from "1", SelectMany is needed, it flattens the many.
2. if Start from "Many", SelectMany is not needed. (still be able to filter from "1", also this is simpler than below standard join query)

from o in Orders join c in Customers on o.CustomerID equals c.ID where c.Name == "Tom" select o 

Just for an alternate view that may help some functional programmers out there:

• Select is map
• SelectMany is bind (or flatMap for your Scala/Kotlin people)

It's more clear when the query return a string (an array of char):

For example if the list 'Fruits' contains 'apple'

'Select' returns the string:

Fruits.Select(s=>s) [0]: "apple" 

'SelectMany' flattens the string:

Fruits.SelectMany(s=>s) [0]: 97 'a' [1]: 112 'p' [2]: 112 'p' [3]: 108 'l' [4]: 101 'e' 

Without getting too technical - database with many Organizations, each with many Users:-

var orgId = "123456789"; var userList1 = db.Organizations .Where(a => a.OrganizationId == orgId) .SelectMany(a => a.Users) .ToList(); var userList2 = db.Users .Where(a => a.OrganizationId == orgId) .ToList(); 

both return the same ApplicationUser list for the selected Organization.

The first "projects" from Organization to Users, the second queries the Users table directly.

Consider this example :

 var array = new string[2] { "I like what I like", "I like what you like" }; //query1 returns two elements sth like this: //fisrt element would be array[5] :[0] = "I" "like" "what" "I" "like" //second element would be array[5] :[1] = "I" "like" "what" "you" "like" IEnumerable<string[]> query1 = array.Select(s => s.Split(' ')).Distinct(); //query2 return back flat result sth like this : // "I" "like" "what" "you" IEnumerable<string> query2 = array.SelectMany(s => s.Split(' ')).Distinct(); 

So as you see duplicate values like "I" or "like" have been removed from query2 because "SelectMany" flattens and projects across multiple sequences. But query1 returns sequence of string arrays. and since there are two different arrays in query1 (first and second element), nothing would be removed.

The SelectMany method knocks down an IEnumerable<IEnumerable<T>> into an IEnumerable<T>, like communism, every element is behaved in the same manner(a stupid guy has same rights of a genious one).

var words = new [] { "a,b,c", "d,e", "f" }; var splitAndCombine = words.SelectMany(x => x.Split(',')); // returns { "a", "b", "c", "d", "e", "f" } 

Suppose you have an array of countries

var countries = new[] { "France", "Italy" }; 

If you perform Select on countries, you will get each element of the array as IEnumerable<T>

IEnumerable<string> selectQuery = countries.Select(country => country); 

In the above code, the country represents a string that refers to each country in the array. now iterate over selectQuery to get countries:

foreach(var country in selectQuery) Console.WriteLine(country); // output // // France // Italy 

If you want to print every character of countries you have to use nested foreach

foreach (var country in selectQuery) { foreach (var charOfCountry in country) { Console.Write(charOfCountry + ", "); } } // output // F, r, a, n, c, e, I, t, a, l, y, 

OK. now try to perform SelectMany on countries. This time SelectMany gets each country as string (as before) and because of string type is a collection of chars, SelectMany tries to divide each country into its constituent parts (chars) and then returns a collection of chars as IEnumerable<T>

IEnumerable<char> selectManyQuery = countries.SelectMany(country => country); 

In the above code, the country represents a string that refers to each country in the array as before, but the return value is the chars of each country

Actually SelectMany likes to fetch two levels inside of collections and flatten the second level as IEnumerable<T>

Now iterate over selectManyQuery to get chars of each country:

foreach(var charOfCountry in selectManyQuery) Console.Write(charOfCountry + ", "); // output // F, r, a, n, c, e, I, t, a, l, y, 

One more example how SelectMany + Select can be used in order to accumulate sub array objects data.

Suppose we have users with they phones:

class Phone { public string BasePart = "555-xxx-xxx"; } class User { public string Name = "Xxxxx"; public List<Phone> Phones; } 

Now we need to select all phones' BaseParts of all users:

var usersArray = new List<User>(); // array of arrays List<string> allBaseParts = usersArray.SelectMany(ua => ua.Phones).Select(p => p.BasePart).ToList(); 

Here is a code example with an initialized small collection for testing:

class Program { static void Main(string[] args) { List<Order> orders = new List<Order> { new Order { OrderID = "orderID1", OrderLines = new List<OrderLine> { new OrderLine { ProductSKU = "SKU1", Quantity = 1 }, new OrderLine { ProductSKU = "SKU2", Quantity = 2 }, new OrderLine { ProductSKU = "SKU3", Quantity = 3 } } }, new Order { OrderID = "orderID2", OrderLines = new List<OrderLine> { new OrderLine { ProductSKU = "SKU4", Quantity = 4 }, new OrderLine { ProductSKU = "SKU5", Quantity = 5 } } } }; //required result is the list of all SKUs in orders List<string> allSKUs = new List<string>(); //With Select case 2 foreach loops are required var flattenedOrdersLinesSelectCase = orders.Select(o => o.OrderLines); foreach (var flattenedOrderLine in flattenedOrdersLinesSelectCase) { foreach (OrderLine orderLine in flattenedOrderLine) { allSKUs.Add(orderLine.ProductSKU); } } //With SelectMany case only one foreach loop is required allSKUs = new List<string>(); var flattenedOrdersLinesSelectManyCase = orders.SelectMany(o => o.OrderLines); foreach (var flattenedOrderLine in flattenedOrdersLinesSelectManyCase) { allSKUs.Add(flattenedOrderLine.ProductSKU); } //If the required result is flattened list which has OrderID, ProductSKU and Quantity, //SelectMany with selector is very helpful to get the required result //and allows avoiding own For loops what according to my experience do code faster when // hundreds of thousands of data rows must be operated List<OrderLineForReport> ordersLinesForReport = (List<OrderLineForReport>)orders.SelectMany(o => o.OrderLines, (o, ol) => new OrderLineForReport { OrderID = o.OrderID, ProductSKU = ol.ProductSKU, Quantity = ol.Quantity }).ToList(); } } class Order { public string OrderID { get; set; } public List<OrderLine> OrderLines { get; set; } } class OrderLine { public string ProductSKU { get; set; } public int Quantity { get; set; } } class OrderLineForReport { public string OrderID { get; set; } public string ProductSKU { get; set; } public int Quantity { get; set; } } 

A select operator is used to select value from a collection and SelectMany operator is used to selecting values from a collection of collection i.e. nested collection.

Example with SelectMany:

using System.Collections.Generic; using System.Linq; public class MyObject { public int Value1 { get; set; } public int Value2 { get; set; } public int Value3 { get; set; } public int Value4 { get; set; } } class Program { static void Main() { // Assuming you have a list of MyObject List<MyObject> objects = new List<MyObject> { // Add your objects here new MyObject { Value1 = 1, Value2 = 2, Value3 = 3, Value4 = 4 }, // ... other objects }; // Use LINQ to concatenate all integer properties into a single list List<int> concatenatedList = objects .SelectMany(obj => new List<int> { obj.Value1, obj.Value2, obj.Value3, obj.Value4 }) .ToList(); // concatenatedList now contains all integer values from all objects } } 

If you use Entity Framework with SelectMany you might encounter an exception like this though:

System.InvalidOperationException: The LINQ expression 'x => new List`1() {Void Add(System.Nullable`1[System.Int32])(x.Value1), Void Add(System.Nullable`1[System.Int32])(x.Value2), Void Add(System.Nullable`1[System.Int32])(x.Value3), Void Add(System.Nullable`1[System.Int32])(x.Value4)} ' could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to 'AsEnumerable', 'AsAsyncEnumerable', 'ToList', or 'ToListAsync'. See https://go.microsoft.com/fwlink/?linkid=2101038 for more information. 

In that case you would have to do it like this:

using System.Collections.Generic; using System.Linq; // ... other using statements ... class Program { static void Main() { // Assuming your DbContext is dbContext and you have a DbSet<MyObject> Objects var objectsQuery = dbContext.Objects.AsEnumerable(); // Switching to in-memory processing // Now perform the SelectMany operation List<int> concatenatedList = objectsQuery .SelectMany(obj => new List<int> { obj.Value1, obj.Value2, obj.Value3, obj.Value4 }) .ToList(); // concatenatedList now contains all integer values from all objects } } 

Keep in mind that AsEnumerable() or ToList() etc will load the entire dataset into memory, which might not be efficient for very large datasets.