This is the foundation of the collections namespace and is implemented by all the collection classes. It defines only the most basic collection functionality, as shown in Table 9-1.

The equivalent Java interface is java.util.Collection, containing 15 methods that provide commonality across all collection classes. .NET takes the approach of pushing method definitions down into specialized interfaces for lists and dictionaries.

The IEnumerable interface is very simple but useful. It contains only one method:

IEnumerator.GetEnumerator();

Classes that implement this method must return a class that implements the IEnumerator interface. The IEnumerator interface defines the notion of a cursor that moves over the elements of a collection. It has three members, as described in Table 9-2, for moving the cursor and retrieving elements from the collection.

In common with Java, .NET enumerators are not thread safe, and when implementing IEnumerator, take care to provide a copy of the elements or to ensure that modifications cannot be made to the underlying data while the enumerator is in use.

The following example demonstrates use of IEnumerator and IEnumerable:

using System ;
using System.Collections ;
class EnumExample : IEnumerator {
    private object[] o_arr;
    private int o_cursor;

    public EnumExample(object[] p_arr) {
        o_arr = p_arr;
        o_cursor = -1;
    }

    public object Current {
        get {
            if (o_cursor > -1 && o_cursor < o_arr.Length) {
                return o_arr[o_cursor];
            } else {
                throw new InvalidOperationException();
            }
        }
    }

    public bool MoveNext() {
        o_cursor++;
        return o_cursor < o_arr.Length;
     }

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

Here’s a fragment that demonstrates using the EnumExample class, iterating over a string array:

EnumExample x_example = new EnumExample(
    new string[] {"allen", "jones", "adam", "freeman"});

    while (x_example.MoveNext()) {
        Console.WriteLine("Element: " +
            x_example.Current.ToString());
    }
}

And here’s the output:

Element: allen
Element: jones
Element: adam
Element: freeman

We can use the IEnumerator implementation to provide support for an IEnumerable implementation. In this example, we pass the underlying array into the enumerator.

class Enumerator : IEnumerable {
    private object[] o_array;

    public Enumerator(object[] p_arr) {
        o_array = p_arr;
    }

    public IEnumerator GetEnumerator() {
        return new EnumExample(o_array);
    }
}

To get hold of the enumerator, a call is made to the GetEnumerator method.

Any class that implements the IEnumerable interface can be iterated over using the foreach statement, which provides a clean syntax when iterating over collections. Unfortunately, the foreach statement provides no mechanism to access the index of the element being worked with. If index access is a requirement, we suggest using a for loop.

Like Java, .NET defines two interfaces used to sort collections. One is for classes that will make comparisons and the other for classes that will be compared; these are similar to the Java interfaces for sorting. .NET defines the interface System.IComparable, which is a direct equivalent of java.lang.Comparable. Both the Java and .NET interfaces define a single method that takes an object argument. The return value is an int stating the relative rank of the IComparable to the object argument. The second interface is System.Collections.IComparer, implemented by classes that are able to sort the elements of a collection. The only method in this interface is Compare, which takes two object arguments and returns their rankings.

Most of the fundamental classes implement IComparable, including the struct implementations of all simple value types, making sorting with simple types straightforward. .NET provides two utility classes that can be used to assist with simple sorting. These are System.Collection.Comparer and System.Collection.CaseInsensitiveComparer. These classes are used in conjunction with sorting routines such as those implemented by System.Array. Here’s an example:

string[] x_arr = new string[] {"Allen", "Jones",
                    "Adam", "Freeman"};
Array.Sort(x_arr, Comparer.Default);

foreach (string x_str in x_arr) {
    Console.WriteLine("STR: " + x_str);
}

The output follows:

STR: Adam
STR: Allen
STR: Freeman
STR: Jones

Instances of both comparers are obtained using their static Default field and are not constructed directly. The single instance can be shared between sorting operations in different threads and classes.

Two other collection interfaces are worth noting: IList and IDictionary. These provide the foundation for indexed array collections (such as ArrayList) and key/value collections (such as Hashtable). We’ll discuss the classes that implement these interfaces in the next section.