Iterating an array with foreach backwards without using extension method

if there was any way to reverse foreach iteration order, to start from length-1 down to 0

Not for a List<T>. The implementation of GetEnumerator() returns an enumerator that enumerates from beginning to end - there's no way to override that.

With a custom collection, then you'd just have to use a different enumerator that could go backwards, but there's no way to override the implementation that List<T> uses.

The Reverse method will copy the list first:

public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source) {
    if (source == null) throw Error.ArgumentNull("source"); 
    return ReverseIterator<TSource>(source);
}

static IEnumerable<TSource> ReverseIterator<TSource>(IEnumerable<TSource> source) { 
    Buffer<TSource> buffer = new Buffer<TSource>(source);
    for (int i = buffer.count - 1; i >= 0; i--) yield return buffer.items[i]; 
} 

But you can do an extension method yourself:

public static IEnumerable<TSource> Backwards<TSource>(this IList<TSource> source) {
    for (var i = source.Count - 1; i >= 0; --i)
        yield return source[i];
}

And then use it like that:

foreach (var item in array.Backwards())
    Console.WriteLine(item); // Or whatever else

Or, of course, you could just do the equivalent:

for (var i = array.Length - 1; i >= 0; --i)
    Console.WriteLine(array[i]); // Or whatever else

You can implement an enumerator that iterates though a list backwards. That way you can use foreach without changing the original list or creating a copy of it.

public class ReverseEnumerator<T> : IEnumerator<T> {

  private IList<T> _list;
  private int _index;
  private T _current;

  public ReverseEnumerator(IList<T> list) {
    _list = list;
    Reset();
  }

  public IEnumerator<T> GetEnumerator() {
    return this;
  }

  public T Current {
    get {
      if (_index < 0 && _index >= _list.Count) throw new InvalidOperationException("Enumeration has not started. Call MoveNext.");
      return _current;
    }
  }

  public void Dispose() { }

  object IEnumerator.Current { get { return Current; } }

  public bool MoveNext() {
    bool ok = --_index >= 0;
    if (ok) _current = _list[_index];
    return ok;
  }

  public void Reset() {
    _index = _list.Count;
  }

}

Usage example:

int[] a = { 1, 2, 3, 4, 5 };

foreach (int x in new ReverseEnumerator<int>(a)) {
  Console.WriteLine(x);
}