Best way to convert an IEnumerable<T> to an T[]

Question

What is the best way to convert from a generic IEnumerable<T> implementation to an array of T? The current solution I have looks like the following:

IEnumerable<string> foo = getFoo();
string[] bar = new List<string>(foo).ToArray();

The transfer through a List<T> seems unneccesary, but I haven't been able to find a better way to do it.

Note: I'm working in C# 2.0 here.

Answer 1

.NET 3.0 and after:

Call the ToArray extension method on IEnumerable<T>, it does nearly the same as below, performing type sniffing and some other optimizations.

.NET 2.0 and before:

Generally speaking, using a List<T> which will be initialized with the IEnumerable<T> and then calling ToArray is probably the easiest way to do this.

The constructor for List<T> will check the IEnumerable<T> to see if it implements ICollection<T> to get the count of items to properly initialize the capacity of the list. If not, it will expand as normal.

Of course, you might end up creating a number of List<T> instances just for the purpose of transforming IEnumerable<T> to T[]. To that end, you can write your own method, but you would really just be duplicating the code that exists in List<T> already.

Answer 2

Doing a little .NET Reflector it looks like the Linq ToArray extension method basically does the same thing as passing the IEnumerable through a List<>. The Buffer class is an internal, but the behavior seems very similar to List<>.

public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    Buffer<TSource> buffer = new Buffer<TSource>(source);
    return buffer.ToArray();
}