Differences between Array.Length and Array.Count() [duplicate]

Question

Possible Duplicate:
count vs length vs size in a collection
Array.Length vs Array.Count

I declared this array:

int[] misInts = new Int[someNumber];

/* make some happy operations with the elements in misInts */

So I can get the value of SomeNumber with: misInts.Length or misInts.Count()

Arrays in C# inherit from IEnumerable. So if I have:

Func<int> misIntsF = Enumerable.Range(0, someNumber).Select(c=> /* make some happy operations that return Integers */);

I am told that if I make misIntsF.Count() I actually execute the code in the Lambda expression, get the results and count them. But the array misInts doesn't have a Lambda expressión.

Is misInts.Count() more memory consuming than misInts.Length? What are the differences between misInts.Count() and misInts.Length?

Answer 1

array.Count() is actually a call to the Enumerable.Count<T>(IEnumerable<T>) extension method.

Since this method takes an IEnumerable<T> (as opposed to ICollection<T>, which has a Count property), it needs to loop through the entire sequence to figure out how big it is.

However, it actually checks whether the parameter implements ICollection<T> (which arrays do), and, if so, returns Count directly.
Therefore, calling .Count() on an array isn't much slower than .Length, although it will involve an extra typecast.

Answer 2

There is no great difference since Enumerable.Count looks first if it's castable to ICollection<T>.

MSDN:

If the type of source implements ICollection, that implementation is used to obtain the count of elements. Otherwise, this method determines the count.

Source:

ICollection<TSource> collection = source as ICollection<TSource>;
if (collection != null)
{
    return collection.Count;
}

otherwise it will enumerate the sequence to count it:

int num = 0;
using (IEnumerator<TSource> enumerator = source.GetEnumerator())
{
    while (enumerator.MoveNext())
    {
        num++;
    }
}
return num;

(source: ILSpy)