Clarify what select does

Question

I haven't been able to find anything on google.

I have this piece of code:

Random r = new Random();
int[] output = Enumerable.Range(0, 11).Select(x => x / 2).OrderBy(x => r.Next()).ToArray();

and I am having trouble actually understanding what each element does.

It generates a range of numbers and elements between 0 and 11. But what does the select(x => x / 2) do ? does it just make pairs of elements,

I know what the whole thing spits out, an array with pairs of numbers, with a single number which has no pair.

but it is a bit above me to fully understand it ?

( is this even okay to ask on here ?? or should I delete the question again ? )

Answer 1

It generates a range of numbers and elements between 0 and 11. But what does the select(x => x / 2) do ? does it just make pairs of elements.

No, Select does what in some programming languages is known as map. It is called on an IEnumerable<T> and has as parameter Func<T,U> a function, and it produces an IEnumerable<U> where each element if the given IEnumerable<T> is processes through the function and the result is emitted in the result.

So in this case, it will take a range from 0 to (excluding) 11, and for each of those integers, perform an integer divsion by two:

csharp> Enumerable.Range(0, 11);
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
csharp> Enumerable.Range(0, 11).Select(x => x/2);
{ 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5 }

Since:

   { 0/2, 1/2, 2/2, 3/2, 4/2, 5/2, 6/2, 7/2, 8/2, 9/2, 10/2 }
== { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5 }

Later then that IEnumerable<int> is reordered (using the OrderBy) by using pseudo-random numbers (so we shuffle them) and converted into a list.

Answer 2

    .Range(0, 11) // generate a sequence of integers starting at 0 and incrementing 11 times (i.e. the values 0 up to and including 10)
    .Select(x => x / 2) // divide each of those values from previous result by 2 and return them
    .OrderBy(x => r.Next()) // then order them randomly using a random number
    .ToArray(); // return the end result as an array

Answer 3

Think of Select as doing a transformation to each element of the IEnumerable.

For example, let's say we have a list like this:

0 1 2 3 4 5 6 7 8 9 10

Then we call .Select(x => x / 2), we are saying that for each element x in the list, do the following transformation:

x / 2

We divide each element in the list by two:

Original    Transformation    Result
0           0 / 2             0
1           1 / 2             0
2           2 / 2             1
3           3 / 2             1
4           4 / 2             2
5           5 / 2             2
6           6 / 2             3
7           7 / 2             3
8           8 / 2             4
9           9 / 2             4
10          10 / 2            5

We get

0 0 1 1 2 2 3 3 4 4 5 5

Answer 4

What Select() does is that it evaluates the given expression for every element of the Enumerable it's called on (the original list), and returns a new Enumerable with the results.

For a list:

[2, 4, 6]

it's going to return:

[2/2, 4/2, 6/2]

where / means "division", so the result of the Select() (not the entire LINQ chain) will be:

[1, 2, 3]

---

Analogously, if your source list is:

words = ["dog", "child", "building"]

And you call:

words.Select(word => word.Length)

you get a list of all the lengths of the strings in the list in order:

[3, 5, 7]