Implementing C# Generic Collections Using Collection<T>, ICollection<T> With IEnumerator<T>

Introduction

This article will demonstrate how to create your own custom collection class using generic Collection<T>. It will also demonstrate how to implement ICollection<T> and IEnumerator<T> in order to create a generic, type-safe, and expandable collection class.

Let's start with a step by step approach to first learn Collection<T> and then ICollection<T> and IEnumerator<T> .

Prerequisites

Learn how to create your own custom collection class with help of System.Collection.Generics and customize your collection to add common type of validation in one place.

Using Collection<T>

Let's have class training with a few properties and then make a collection of that class. The generic Collection<T> is basically derived from ICollection<T> where most of the implementations are taken care of for you and you do not need to worry about addition and removal etc. if you want to customize addition and removal use ICollection<T> directly which is step2 in this article.

public class Training
{
public string Name { get; set; }
public int Cost { get; set; }
}

public class Trainings : Collection<Training>
{
public Training this[string name]
{
get { return this.Items.First(s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase)); }
}
public IEnumerable<string> All => this.Items.Select(s => s.Name);
protected override void InsertItem(int index, Training item)
{
// validation before adding in common place.
if (item.Cost > 0)
{
base.InsertItem(index, item);
}
}
public void ForEach(Action<string> action)
{
foreach (var item in Items)
{
action($"Traning Name {item.Name} and cost {item.Cost}");
}
}
}

You may notice that you have your indexer to get by name and validation before inserting a new item. Let's have a look at how to use this collection in console application.

static void Main(string[] args)
{
var trainings = new Trainings();
trainings.Insert(0, new Training { Name = "C#", Cost = 10 });
trainings.Add(new Training() { Name = "Java", Cost = 10 });
trainings.ForEach(Console.WriteLine);
Console.ReadKey();
}

Using ICollection<T>

The new collection class derived from ICollection<T> is responsible for adding, inserting and removing objects from our collection with our own validation etc, checking the collection for of a given object, and instantiating an IEnumerator<T> object in order to enumerate the collection using a foreach statement. Let's have look at a new collection class which implements from ICollection. ICollection generic collection Interface is derived from IEnumerable, this interface was implemted for a collection based class as mentioned above.

public class TrainingsCollection<T> : ICollection<T> where T : Training
{
public TrainingsCollection()
{
List = new List<T>();
}
protected IList List { get; }
public T this[int index] => (T)List[index];
public int Count => this.List.Count;
public bool IsReadOnly => throw new NotImplementedException();
public void Add(T item)
{
if (!string.IsNullOrEmpty(item.Name))
{
this.List.Add(item);
}
}
public void Clear()
{
this.List.Clear();
}
public bool Contains(T item)
{
return this.List.Contains(item);
}
public IEnumerator<T> GetEnumerator()
{
return new TraningsEnumerator<T>(this);
}
public bool Remove(T item)
{
if (item != null && Contains(item))
{
this.List.Remove(item);
return true;
}
return false;
}
IEnumerator IEnumerable.GetEnumerator()
{
return new TraningsEnumerator<T>(this);
}
public void CopyTo(T[] array, int arrayIndex)
{
this.List.CopyTo(array, arrayIndex);
}
public void ForEach(Action<string> action)
{
foreach (var item in List.OfType<T>())
{
action($"Traning Name {item.Name} and cost {item.Cost}");
}
}
}

These two implementations mentioned above for GetEnumerator are there for foreach loop and this will be calling in order to loop through our custom collection. We have defined our custom generic Enumerator object that will perform the actual looping.

Using IEnumerator<T>

public class TraningsEnumerator<T> : IEnumerator<T> where T : Training
{
private readonly TrainingsCollection<T> collection;
public int Counter = -1;
public TraningsEnumerator(TrainingsCollection<T> collection)
{
this.collection = collection;
}
public object Current => collection[Counter];
T IEnumerator<T>.Current => collection[Counter];
public void Dispose()
{
Counter = -1;
}
public bool MoveNext()
{
++Counter;
if (collection.Count > Counter)
{
return true;
}
return false;
}
public void Reset()
{
Counter = -1;
}
}

Let's have a look at how to use this collection in console application.

static void Main(string[] args)
{
var trainings = new TrainingsCollection<Training>();
trainings.Add(new Training { Name = "C#", Cost = 10 });
trainings.Add(new Training() { Name = "Java", Cost = 10 });
// This loop with trigger to IEnumerator<T> GetEnumerator() from our custom TraningsEnumerator
foreach (var item in trainings)
{
Console.Write($"Traning Name {item.Name} and cost {item.Cost}");
}
Console.ReadKey();
}

Conclusion

Here we learned how to create your own custom generic collection with the help of Collection<T>, ICollection<T> and IEnumerator<T>. This Generic Collection gives you an advantage for your application with type-safe and saves a lot of time, avoiding duplication of code. You could also use of List<T> but there are many ways to implement type-safe generic collections in c#.