What's the use of AsEnumerable() on an array?

Question

I was reading a blog by Eric Lippert where he explained why he will almost never use arrays, and the following part got me curious:

If you are writing such an API, wrap the array in a ReadOnlyCollection and return an IEnumerable or an IList or something, but not an array. (And of course, do not simply cast the array to IEnumerable and think you’re done! That is still passing out variables; the caller can simply cast back to array! Only pass out an array if it is wrapped up by a read-only object.)

So I was messing around a bit with collections:

string[] array = new[] { "cat", "dog", "parrot" };
IEnumerable<string> test1 = array.AsEnumerable();
string[] secondArray = (string[])test1;

//array1[0] is now also "whale"
array[0] = "whale";

//11 interfaces
var iArray = array.GetType().GetInterfaces();
//Still 11 interfaces??
var iTest1 = test1.GetType().GetInterfaces();

I initialize an array and then use the AsEnumerable() method on it to convert it to an IEnumerable (or so I thought), but when I cast it back to a new array, and change a value in the original array, the values of test1 and secondArray got changed to. Apparantly I just made 2 new references to the original array, instead of creating a new IEnumerable a bit like ToArray() returns a new array.

When I compare the interfaces of the array and IEnumerable, they both have the same interfaces. Why does array have that method if it doesn't actually do anything at all? I know AsEnumerable() has its uses with Linq-to-entities to get the enumerable methods when you've got an IQueryable, but why would this method be added to an array? Is there any practical use for this method?

Edit: This comment by Tim Schmelter raises a really good point and shouldn't go unnoticed:

"It's not so useless. You can change the actual type without breaking the rest of the code. So you could replace the array with a database query or list or hashset or whatever, but the AsEnumerable always works and the rest of the code after too. So the AsEnumerable is like a contract."

Answer 1

AsEnumerable is just a way of casting the value to IEnumerable<T>. It doesn't create a new object. The implementation of the method is as follows:

public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source)
{
    return source;
}

It's not creating a new object at all.

Reasons it's useful:

1. If an object implements IEnumerable<T> but also has an instance method named Select, Where, etc., you can't use the LINQ method. AsEnumerable lets you cast it to IEnumerable to avoid such overload conflicts.

2. If you want to cast an object to IEnumerable<T> (for whatever reason), but T is an anonymous type, you can't use a cast, you need a generic method that can infer its generic argument to do it.

Answer 2

You have a couple of good answers here; I thought I'd add a few supporting points.

First, FYI, a "do nothing" method like this that always returns its argument is called an "identity", for the obvious reason that the output is identical to the input. Identities seem useless but they actually do come in handy from time to time.

Second, if you do want to turn an array into a read-only sequence that does not have referential identity to the array, you can do an identity projection:

var sequence = from item in array select item;

or equivalently:

var sequence = array.Select(item => item);

Note that the projection here is an identity; I said they were useful.

Normally LINQ would optimize away an identity projection; if you say

from item in array where whatever select item;

then the identity projection at the end is never generated because it is just a waste of time. That is, this means

array.Where(item => whatever)

not

array.Where(item => whatever).Select(item => item)

But the compiler does not suppress the identity projection in the case where the select is the only thing in the query, precisely so that you can make a projection that cannot be cast back to the original array.

Answer 3

The purpose of AsEnumerable is quite clear as described in the Servy's answer and this post for example: Why use .AsEnumerable() rather than casting to IEnumerable<T>?.

The remaining question is: why is it visible on IEnumerable<T>? This is simply the case because the extension method used here uses IEnumerable<T> as the type it is defined on. See it as ToString() on a string. Since string is an object it derives the method ToString(), although useless in the case of a string. Here, the extension method causes this 'useless' availability of the method.