Is it possible to do a For...Each Loop Backwards?

Question

I don't believe this is possible by conventional methods, but something like this verbose code:

For Each s As String In myStringList Step -1
    //' Do stuff here
Next

I will probably have to invert the myString object before a conventional For..Each Loop, correct?

Answer 1

You'd have to do something like:

For i as integer = myStringList.Count-1 to 0 step -1
    dim s as string = myStringList.Item(i)
    ' Do your stuff with s
Next i

But as far as I know, you can't do a "For...Each" backwards, though that would be nice in a few instances.

Answer 2

Sadly, the MSDN docs on For Each state that the For Each construct is there explicitly for cases where the order of the iteration is unimportant (unordered sets and the like). So there is unfortunately no concept of reversing a For Each, as the order is not defined anyway.

Good luck!

Answer 3

Call the Reverse method. http://msdn.microsoft.com/en-us/library/bb358497.aspx

Answer 4

The reason it can't be done is that, as a basic design feature, For Each can iterate over an enumerable without a last element, or with an as yet unknown last element.

Answer 5

You could convert the String to a Character Array and then reverse the array.

Answer 6

I think the documentation referenced in the answer is extremely misleading. The order of For Each is defined by the collection it's called (i.e. its implementation of IEnumerable/IEnumerable<T>), but that's not the same as saying it shouldn't be used when the order is important. Many collections (such as arrays, List<T> etc) always go in the "natural" order.

Part of the documentation does allude to this:

Traversal Order. When you execute a For Each...Next loop, traversal of the collection is under the control of the enumerator object returned by the GetEnumerator method. The order of traversal is not determined by Visual Basic, but rather by the MoveNext method of the enumerator object. This means that you might not be able to predict which element of the collection is the first to be returned in element, or which is the next to be returned after a given element.

That's not at all the same as saying it can't be relied upon - it can be relied upon if you know that the collection you're iterating over will produce the results in the desired order. It's not like it's going to pick elements at random. The behaviour in terms of IEnumerable/IEnumerable<T> is clearly defined on that page.

The most important exceptions to predictable orderings are dictionaries and sets, which are naturally unordered.

To reverse an IEnumerable<T>, use Enumerable.Reverse - but if you need to iterate in reverse over a collection which is indexed by position (such as an array or List<T>) then it would be more efficient to use a For loop starting at the end and working backwards.

Answer 7

How about use a Queue or First in Last Out collection?

Answer 8

Just a thougth, you can create your own collection that uses a custom enumerator that iteracts that way you expect.