Trying to understand LINQ code using c#

Question

I'm not sure if this is the right place to ask this, I'm sorry if not.

using the same code as in:

string[] digits = { "zero", "one", "two", "three", "four", "five", 
                    "six", "seven", "eight", "nine" };
var shortDigits = digits.Where((digit, index) => digit.Length < index);
foreach (var sD in shortDigits)
{
    Console.WriteLine(sD);
}
// Output:
// five
// six
// seven
// eight
// nine

How does the system know that, digit are the items in digits, and index the position within the array?

nope, it works that way, see: `http://msdn.microsoft.com/en-us/library/bb311046.aspx` — Somebody, Jul 10 '12 at 16:12

score 6 · Accepted Answer · edited Jun 20 '20 at 09:12

That particular overload of the Where extension method is defined to accept a Func where the first parameter is the element and the second parameter is the index of that element. This is mentioned explicitly in the documentation:

predicate

Type: System.Func<TSource, Int32, Boolean>

A function to test each source element for a condition; the second parameter of the function represents the index of the source element.

Emphasis mine.

Justin Pihony · Answer 2 · 2012-07-10T16:20:29.020

This is just a naming thing, you could name digit anything, and index anything. This is just a lambda expression for an anonymous function...it could be rewritten:

(string digit, int index) => digit.Length < index

so, the names are the same as any parameter you normally set up in a method. There is nothing truly special about the names being recognized by the C# engine.

(string index, int digit) => index.Length < digit

The above would work also...it would be confusing, but it would work. It is just to show that the name can be whatever you want

If you are referring how to the signature itself then it is due to an overload of the Where function

public static IEnumerable<TSource> Where<TSource>(
    this IEnumerable<TSource> source,
    Func<TSource, int, bool> predicate
)

So, the TSource in this case is string, making the Func become Func<string, int, bool>. Meaning that the lambda must take a string parameter followed by an int param, and return a bool value

His question was on why the first parameter represented the item in the collection and the second its index... not their names. — Jeff Mercado, Jul 10 '12 at 16:12
I can read it both ways, so will wait for the OP to clarify...meanwhile I will answer for both possibilities — Justin Pihony, Jul 10 '12 at 16:14

score 1 · Answer 3 · answered Jul 10 '12 at 16:22

The overload of Where that you are using is implemented like this:

public static IEnumerable<T> Where<T>(
      this IEnumerable<T> list, Func<T,int,bool> predicate)
{
   int num = -1;
   foreach (T current in list)
   {
      num++;
      if (predicate(current, num))
      {
         yield return current;
      }
   }
   yield break;
}

as you can see, on each iteration, the predicate (i.e. the passed lambda expression) is invoked passing the current element of the list and the current index.

In this way, the code in the lambda expression know both the element and its index.

score 0 · Answer 4 · answered Jul 10 '12 at 16:12

Because there is an overload of where taking as a predicate a function like this:

Func<TSource, int, bool>

the semantic of this predicate ios defined so the second parameter is the index. So if you pass a lambda with two args that version of where is called.

Trying to understand LINQ code using c#

4 Answers4