OK;

"n => n % 2 == 1"
expresses a predicate; for any "n" passed in, it returns true if-and-
only-if the argument is odd.

* numbers is an int[], so implements IEnumerable<int>
* the compiler (with "using System.Linq") locates an extension method:
     public static int Count<TSource>(this IEnumerable<TSource>
source, Func<TSource, bool> predicate);

the first "this" arg is automatically numbers; the second is a
predicate - i.e. a test to apply to each element in turn.

Internally, Count is probably something like (with a few null-arg
checks):

       int count = 0;
       foreach (TSource item in source)
       {
           if (predicate(item)) count++;
       }
       return count;

i.e. it simply walks the list and checks each item.

The C# compiler can convert a lambda to either a delegate or an
expression. In this case, it is compiling to a delegate to pass as the
second argument to Count.

Does that make sense?

Marc

No - "numbers" is the sequence. It's an array, implementing
IEnumerable<int>.

If you just call numbers.Count() you'll get 10. The version with the
lambda expression is saying "only count elements which match this
predicate".

It's sort of similar to calling:

numbers.Where(n => n % 2 == 1)
      .Count()

That may help, or it may confuse you more, of course...

For info, the relevant MSDN page:

http://msdn2.microsoft.com/en-us/library/bb535181.aspx

No, it returns true or false depending on whether the number is odd.

A lambda expression is a way of creating a function without giving it a
name.  Suppose you defined:

bool blah(n) { return n%2 == 1; }

That's a function named blah.

(n => n%2 == 1)

is the same function without a name.

The Count method takes a function that tells it which elements to count.
I'm not sure if

numbers.Count(blah)

is valid syntax, but it ought to be; it means "count the ones that return
'true' when given as the argument of 'blah'".

numbers.Count(n => n%2 == 1)

is the same thing without defining it separately giving it a name.

Lambda expressions are the stuff of which Lisp is made.  They are a basic
tool of advanced, abstract computer programming.