Collection Complexities

• There are two categories of collection-related classes and interfaces: those that support generics and those that don’t.
  • Use collection classes that don’t support generics only when work with earlier versions of the runtime.

IEnumerator<T> and IEnumerable<T>

• A collection within .NET is a class that, at a minimum, implements IEnumerable<T> which supports iterating over the collection.
• With foreach statement we iterate over an array of elements.
  • The runtime does not directly support the foreach statement, however.
  • Instead, the C# compiler transforms the code.
• If you can determine the first, next, and last elements of a collection, knowing the count and supporting retrieval of elements by index is unnecessary.
• The IEnumerator<T> and IEnumerator interfaces are designed to enable the iterator pattern for iterating over collections of elements, rather than the length-index pattern.
• If two loops interleaved each other (one foreach inside another, both using the same collection) the collection must maintain a state indicator of the current element so that when MoveNext() is called, the next element can be determined.
  • The problem is that one interleaving loop can affect the other.
  • The same is true of loops executed by multiple threads.

• To overcome this problem, the collection classes do not support IEnumerator<T> and IEnumerator interfaces directly.
• They implement IEnumerable<T> whose only method is GetEnumerator().
  • The purpose of this method is to return an object that supports IEnumerator<T>.
• Instead of the collection class maintaining the state, a different class, usually a nested class so that it has access to the internals of the collection, will support the IEnumerator<T> and will keep the state of the iteration loop.
• The enumerator is like a “cursor” or a “bookmark” in the sequence.
  • You can have multiple bookmarks, and moving each of them enumerates over the collection independently of the other.

var stack = new Stack<int>();
Stack<int>.Enumerator enumerator = stack.GetEnumerator();
while (enumerator.MoveNext())
{
    int number = enumerator.Current;
    Console.WriteLine(number);
}

• The Range() static method generates a range of integers from a given start value and for a given count.

var numbers = Enumerable.Range(1, 10).ToList();

• The Repeat() static method generates a sequence of repeated occurrences of a given element.

var repeatedValues = Enumerable.Repeat("Hello World!", 5).ToArray();

ICollection<T> and IReadOnlyCollection<T>

• ICollection<T> includes two main members: Count and CopyTo().
• For a collection to iterate through each element using a “for loop”, it needs to support retrieval by index. The ICollection<T> does not include an index.
• The CopyTo() method provides the ability to convert the collection into an array.
  • CopyTo() requires to initialize the target array with sufficient capacity.

interface ICollection<T> : IEnumerable<T>, IEnumerable
{
	int Count { get; }
	bool IsReadOnly { get; }
	void Add(T item);
	void Clear();
	bool Contains(T item);
	void CopyTo(T[] array, int arrayIndex);
	bool Remove(T item);
}
interface IReadOnlyCollection<T> : IEnumerable<T>, IEnumerable
{
	int Count { get; }
}

Collection & Array Initializer

• A collection initializer allows to build a collection with an initial set of members.
• The Add() calls are generated by the compiler rather than explicitly coded.
• The collection type has to implement ICollection<T> or simply have one or more Add() methods exist on a type that implements IEnumerable<T>.
  • The Add() method needs to take parameters that is compatible with the values specified in the collection initializer.
• A different approach to initializing a collection of anonymous types is to use an array initializer.
  • Since it is not possible to specify the data type in the constructor, array initialization syntax allows for anonymous array initializers using new[].

var sevenWorldBlunders = new List<string>()
{
	"Wealth without work",
	"Pleasure without conscience"
};

var items = new [] // new string[]
{
	"Item1",
	"Item2"
};

Array

• The Array class is not part of the System.Collections namespaces.
• However, it is still considered a collection because it is based on the IList interface.

public abstract class Array : ICloneable, System.Collections.IList, 
	System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

• The Array class is the base class for language implementations that support arrays.
  • However, only the system and compilers can derive explicitly from the Array class.
• Unlike the classes in the System.Collections namespaces, Array has a fixed capacity.
  • To increase the capacity, you must create a new Array object with the required capacity, copy the elements and delete the old Array.
• By default, the maximum size of an Array is 2GB.
• Single-dimensional arrays implement the IList<T>, ICollection<T>, IEnumerable<T>, IReadOnlyList<T> and IReadOnlyCollection<T>.
  • The implementations are provided to arrays at run time, and as a result, the generic interfaces do not appear in the declaration syntax for the Array class.