Collection in C# - Part One

C# provides a set of collections. These include Lists, LinkLists, Array, ArrayList, Dictionary and many more. We will discuss all the collection one-by-one in this series.

Enumeration

In C# there are many types of collections, from simple to complex. These collections differ from each other but traversing is a universal need. Traversing is supported by IEnumerable, IEnumerator, and their generic part IEnumerable<T>, IEnumerator<T>. IEnumerable, IEnumerator belongs to System.Collections namespace and IEnumerable<T>, IEnumerator<T>
belongs to System.Collections.Generic namespace.

IEnumerator

IEnumerator interface defines a basic low level protocol by which a collection is traversed in forward-only approach. If you see implementation in visual studio is looks like the following,

public interface IEnumerator
{
object Current
{
get;
}
bool MoveNext();
void Reset();
}

Inthe above definition current gives the current element. MoveNext moves the cursor from current element to next element and if there is no new element it returns false. Reset method moves cursor back to start and the collections are enumerated again.

Example 1:

static void Main(string[] args)
{
int[] number = new int[]
{
1,
2,
3,
4
};
IEnumerator enumerator = number.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine("Number is {0}", enumerator.Current);
}
}

Output:

Number is 1
Number is 2
Number is 3
Number is 4

Example 2:

class Program
{
static void Main(string[] args)
{
string software = "SOFTWARE";
IEnumerator enumerator = software.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current);
}
}
}

Output

S
O
F
T
W
A
R
E

IEnumerable

Collection doesn’t implement IEnumerator directly. IEnumerator is implemented by IEnumerable. If you check in visual studio all the collection is derived from IEnumerable and others. IEnumerable is the most basic interface that collection classes implement.

Implementation of IEnumerable

namespace System.Collections
{
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
}

Example

static void Main(string[] args)
{
string software = "SOFTWARE";
IEnumerable enumerable = software;
foreach(var item in enumerable)
{
Console.WriteLine(item);
}
}

Output

S
O
F
T
W
A
R
E

Now you are thinking we can traverse string without converting to IEnumerable. Yes we can traverse because string also implements IEnumerable. Above is just an example to show you.

IEnumerator<T>

IEnumerator<T> is a generic part of IEnumerator. IEnumerator<T> is in System.Collections.Generic namespace and it implements IDisposable, IEnumerator interface.

IEnumerator inherits from IDisposable that means resources are released when enumeration is completed.

Implementation of IEnumerator

namespace System.Collections.Generic
{
public interface IEnumerator < out T >: IDisposable, IEnumerator
{
T Current
{
get;
}
}
}

IEnumerable<T>

IEnumerable <T> is a generic part of IEnumerable. IEnumerable <T> is in System.Collections.Generic namespace and it implements IEnumerable interface.

Implementation of IEnumerable<T>

namespace System.Collections.Generic
{
public interface IEnumerable < out T >: IEnumerable
{
IEnumerator < T > GetEnumerator();
}
}

Generic strengthens type safety and reduces the overhead of boxing.