IEnumerable and string[]

Question

Is there any advantage to using this

 private static IEnumerable<string> GetColumnNames(this IDataReader reader)
        {
             for (int i = 0; i < reader.FieldCount; i++)
                yield return reader.GetName(i);

        }

instead of this

  private static string[] GetColumnNames(this IDataReader reader)
    {
        var columnNames = new string[reader.FieldCount];
        for (int i = 0; i < reader.FieldCount; i++)
             columnNames[i] = reader.GetName(i);

        return columnNames;
    }

Here is how I use this method

    int  orderId = _noOrdinal;
    IEnumerable<string> columnNames = reader.GetColumnNames();
    if (columnNames.Contains("OrderId"))
           orderId = reader.GetOrdinal("OrderId");
     while (reader.Read())
            yield return new BEContractB2CService
                     {
                         //..................
                         Order = new BEOrder
                          {  Id = orderId == _noOrdinal ? 
                                          Guid.Empty : reader.GetGuid(orderId)
                          },
 //............................

http://stackoverflow.com/questions/764748/whats-the-difference-between-ienumerable-and-array-ilist-and-list — Bolu, Jun 03 '11 at 11:48

James Gaunt · Accepted Answer · 2011-06-03T12:00:49.910

6

The two approaches are quite different so it depends on what you are subsequently going to do with the result I would say.

For example:

The first case requires the data reader to remain open until the result is read, the second doesn't. So how long are you going to hold this result for and do you want to leave the data reader open that long.

The first case is less performant if you are definitely going to read the data, but probably more performant if you often don't, particularly if there is a lot of data.

The result from your first case should only be read/iterated/searched once. Then second case can be stored and searched multiple times.

If you have a large amount of data then the first case could be used in such a way that you don't need to bring all that data in to memory in one go. But again that really depends on what you do with the IEnumerable in the calling method.

Edit: Given your use-case the methods are probably pretty much equivalent for any given measure of 'good-ness'. Tables don't tend to have many columns, and your use of .Contains ensures the data will be read every time. Personally I would stick with the array method here if only because it's a more straightforward approach.

What's the next line of the code... is it looking for a different column name? If so the second case is the only way to go.

edited Jun 03 '11 at 12:00

answered Jun 03 '11 at 11:48

James Gaunt

14,631
2
39
57

@James Gaunt, your answer is good. Look at my edit for a next line of the code. – Alexandre Jun 03 '11 at 12:06
Incorrect: IEnumerable.Contains actually ensures that all the data will be read only if the OrderID name is absent from the list or in the last position. – phoog Jun 03 '11 at 12:09
Thanks. So if you're not going to keep reusing the columnNames result I really don't think there is much difference between the two approaches so I'd just use what you're more comfortable with. – James Gaunt Jun 03 '11 at 12:14
@phoog - thanks - but I specifically didn't write the word 'all' in the answer. – James Gaunt Jun 03 '11 at 12:14
@James Gaunt: so maybe I should have written "misleading" instead of "incorrect". I don't understand what you mean by "your use of Contains ensures the data will be read every time" without assuming an implied "all" – phoog Jun 03 '11 at 12:28
@phong... to assume makes an ass out of you and me :) – James Gaunt Jun 03 '11 at 12:30

score 3 · Answer 2 · answered Jun 03 '11 at 11:50

On reason off the top of my head: The array version means you have to spend time building the array first. Most of the code's clients may not necessarily need a specific array. Mostly, i've found, that most code is just going to iterate over it in which case, why waste time building an array (or list as an alternative) you never actually need.

score 2 · Answer 3 · answered Jun 03 '11 at 11:49

The first one is lazy. That is your code is not evaluated until you iterate the enumerable and because you use closures it will run the code until it yields a value then turn control back to the calling code until you iterate to the next value via MoveNext. Additionally with linq you can achieve the second one by calling the first and then calling ToArray. The reason you might want to do this is to make sure you get the data as it is when you make the call versus when you iterate in case the values change in between.

score 2 · Answer 4 · answered Jun 03 '11 at 11:50

One advantage has to do with memory consumption. If FieldCount is say 1 million, then the latter needs to allocate an array with 1 million entries, while the former does not.

This benefit depends on how the method is consumed though. For example, if you are processing a list of files one-by-one, then there is no need to know all the files up front.

IEnumerable and string[]

4 Answers4