Ordered enumeration: IEnumerable or Array (in C#)?

Question

Typical context: I make an extension method for a collection which considers that the elements are ordered. The function starts at the beginning, at index 0, and the order has significance. Examples: Grouping by sequence or Indexes of an item.

However, I'm always stumped as to what to extend: IEnumerable<T> or T[]. My rationale was clarity of purpose: An array has a notion of ordering, whereas an IEnumerable is implemented by many generic collections, not all of which have a notion of order:

• Dictionary - unordered
• HashSet - unordered
• LinkedList - ordered
• List - ordered
• Queue - ordered
• SortedDictionary - sorted (not original order)
• SortedList - sorted (not original order)
• SortedSet - sorted (not original order)
• Stack - reversed

As well as any other implementation which might or might not be ordered.

Also, I'm not certain if the enumerator is reset if an enumeration is not completed, so if that's a worry, then who knows at what point the enumeration would start? Enumerating an array would always start at the beginning.

So to me, it makes more sense to extend a T[]. But am I correct in thinking that? Am I worrying too much? What's the proper approach for ensuring "ordered" enumeration?

Answer 1

I'm not certain if the enumerator is reset if an enumeration is not completed, so if that's a worry, then who knows at what point the enumeration would start? Enumerating an array would always start at the beginning.

These two sentences make me think that you have deep misunderstandings about how the enumerable pattern works. Can you explain why you think that an abandoned enumerator has anything whatsoever to do with a later enumeration?

An enumerable is a device which produces enumerators. If an enumerator is abandoned, that does not in any way affect the enumerable. If I sell books, and Bob buys a book and only reads it halfway, that doesn't mean that when I sell a different copy of the book to Alice, she has to start reading where Bob left off.

I'm always stumped as to what to extend: IEnumerable<T> or T[]. My rationale was clarity of purpose: An array has a notion of ordering, whereas an IEnumerable is implemented by many generic collections, not all of which have a notion of order:

Does your extension method need to (1) access the collection out of order? (2) write to the collection?

If so, then extend IList<T> If not, extend IEnumerable<T>.

What about: (3) pass the collection on to a method that expects an array?

Then extend array.

Your question is basically "I don't know whether to extend Animal or Giraffe". If your extension method is not specific to Giraffes, extend Animal. If your extension method is not specific to arrays, extend all lists. If it is not specific to lists, extend all sequences. If it is not specific to sequences, odds are good that an extension method is the wrong mechanism for you; I recommend against extending all objects.

Answer 2

I think that you want to combine 2 different concepts into 1. The data structure and its contents order are 2 separate things.

Ordering is a tricky subject. For example, what does ordering a list of persons mean? Even when order/sort key is defined, it has to have a direction and you have to decide what to do with nulls (if any), date issues, etc.

If data ordering is important to your method, then may be your method should be responsible for the ordering of the data as part of its set up instead of asking data to be ordered by the caller. A similar approach is used by some string match algorithms where a dictionary is built inside the search method from the passed string before the string is searched. I know this is not the exact case, but it is the closest example I could think of.

Answer 3

IEnumerable declares that the collection you have can be enumerated; it doesn't imply anything about the content. This isn't a bad thing -- containers can have additional capabilities and restrictions on top of individual interfaces.

(I don't see how an array is any better here -- it's indexable, as is an IList and other containers, but there is nothing about indexing that implies data order. Your list is kind of odd -- some items are "ordered" in that they preserve insertion order, others are "ordered" as in they are sorted. They are two different things. Other than the SortedSet/SortedList/SortedDictionary, you shouldn't assume the data is in a particular order unless you handle that inside your own code.)

However, IEnumerable provides a LINQ extension that allows you to .OrderBy, so anything that is enumerable can be returned in an IOrderedEnumerable sorted order. That's a LINQ-specific interface though (and not implemented by default by SortedSet/SortedList/SortedDictionary, so it might not make sense to extend that particular interface...)