C#

IEnumerable<string> files = extensionsForMovies.SelectMany(filter =>
                Directory.GetFiles(currentFolder, filter, SearchOption.TopDirectoryOnly));

http://msdn.microsoft.com/en-us/library/bb534966%28v=vs.110%29.aspx[^]

Type: System.Linq.IOrderedEnumerable(Of TSource)
An IOrderedEnumerable(Of TElement) whose elements are sorted according to a key.

System.Linq.IOrderedEnumerable<KeyValuePair<Int32, Int32>> ioe = System.Linq.Enumerable.OrderBy<KeyValuePair<Int32,Int32>, Int32>
    (randomDictionary, (KeyValuePair<Int32, Int32> x) => x.Key);

Bill said their argument is:

Given that a .NET Dictionary is implemented with the use of Hashes for fast look-up, those who believe it cannot be ordered describe that, and the statements by Microsoft about "no guarantee" of a specific order, as the reasons sorting is not possible

public bool MoveNext()
{
    if (this.version != this.dictionary.version)
    {
        ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
    }
    while (this.index < this.dictionary.count)
    {
        if (this.dictionary.entries[this.index].hashCode >= 0)
        {
            this.current = new KeyValuePair<TKey, TValue>(this.dictionary.entries[this.index].key, this.dictionary.entries[this.index].value);
            this.index++;
            return true;
        }
        this.index++;
    }
    this.index = this.dictionary.count + 1;
    this.current = new KeyValuePair<TKey, TValue>();
    return false;
}

http://msdn.microsoft.com/en-us/library/xfhwa508%28v=vs.110%29.aspx[^]

For purposes of enumeration, each item in the dictionary is treated as a KeyValuePair(Of TKey, TValue) structure representing a value and its key. The order in which the items are returned is undefined.

Quote:

I assume that all Linq methods are static methods that require an IEnumerable to work. Perhaps I am not fully educated ?

Quote:

The distinction between calling the "raw" method, and calling the method "off" IEnumerable, as you show, is not clear to me, but I will study your post carefully.

System.Linq.OrderedEnumerable`2[[System.Collections.Generic.KeyValuePair`2[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

foreach (Person p in peopleList)
    Console.WriteLine(p.firstName + " " + p.lastName);

IEnumerator en = peopleList.GetEnumerator();
Person p;
while (en.MoveNext())
{
    p = (Person)en.Current;
    Console.WriteLine(p.firstName + " " + p.lastName);
}

public class People : IEnumerable
{
    private Person[] _people;
    public People(Person[] pArray)
    {
        _people = new Person[pArray.Length];

        for (int i = 0; i < pArray.Length; i++)
        {
            _people[i] = pArray[i];
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return (IEnumerator)GetEnumerator();
    }

    public PeopleEnum GetEnumerator()
    {
        return new PeopleEnum(_people);
    }
}

public class PeopleEnum : IEnumerator
{
    public Person[] _people;

    // Enumerators are positioned before the first element 
    // until the first MoveNext() call. 
    int position = -1;

    public PeopleEnum(Person[] list)
    {
        _people = list;
    }

    public bool MoveNext()
    {
        position++;
        return (position < _people.Length);
    }

    public void Reset()
    {
        position = -1;
    }

    object IEnumerator.Current
    {
        get
        {
            try
            {
                return _people[position];
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }

}

BillWoodruff wrote:

you agree with the opinion of those that believe you cannot rely on a Generic
Dictionary, sorted via Linq, to be, in fact, sorted.