Efficiency: Creating an array of doubles incrementally?

Consider the following code:

List<double> l = new List<double>();

//a开发者_StackOverflow社区dd unknown number of values to the list
l.Add(0.1); //assume we don't have these values ahead of time.
l.Add(0.11);
l.Add(0.1);

l.ToArray(); //ultimately we want an array of doubles

Anything wrong with this approach? Is there a more appropriate way to build an array, without knowing the size, or elements ahead of time?

There's nothing wrong with your approach. You are using the correct data type for the purpose.

After some observations you can get a better idea of the total elements in that list. Then you can create a new list with an initial capacity in the constructor:

List<double> l = new List<double>(capacity);

Other than this, it's the proper technique and data structure.

UPDATE:

If you:

• Need only the Add and ToArray functions of the List<T> structure,
• And you can't really predict the total capacity
• And you end up with more than 1K elements
• And better performance is really really (really!) your goal

Then you might want to write your own interface:

public interface IArrayBuilder<T>
{
    void Add(T item);
    T[] ToArray();
}

And then write your own implementation, which might be better than List<T>. Why is that? because List<T> holds a single array internally, and it increases its size when needed. The procedure of increasing the inner array costs, in terms of performance, since it allocates new memory (and perhaps copies the elements from the old array to the new one, I don't remember). However, if all of the conditions described above are true, all you need is to build an array, you don't really need all of the data to be stored in a single array internally.

I know it's a long shot, but I think it's better sharing such thoughts...

As others have already pointed out: This is the correct approach. I'll just add that if you can somehow avoid the array and use List<T> directly or perhaps IEnumerable<T>, you'll avoid copying the array as ToArray actually copies the internal array of the list instance.

Eric Lippert has a great post about arrays, that you may find relevant.

A dynamic data structure like a List is the correct way to implement this. The only real advantage arrays have over a List is the O(1) access performance (compared to O(n) in List). The flexibility more than makes up for this performance loss imho