Collection in C# - Part Two

In our previous article we discussed about IEnumerator, IEnumerable and their generic counterparts. They are basic building blocks of every collection type in C#. Every collection is implemented from them and from other also. IEnumerable is used when you want to just traverse data without modification. In ICollection you can traverse data as well as count the number of elements. In this article we will discuss about ICollection, IList and their generic parts.

Previous Article

Collection in C# - Part One

ICollection

ICollection belongs to System.Collections namespace.

IEnumerable provides only traversing. We can’t access random element using index and can’t count number of elements. If we try to access IEnumerable element through indexing we will get error “Cannot apply indexing with [] to an expression of type 'IEnumerable' ." Same with ICollection but ICollection is littlemore advanced than IEnumerable. In ICollection we can count element. ICollection implement IEnumerable Interface.

Implementation of ICollection

namespace System.Collections
{
public interface ICollection : IEnumerable
{
int Count { get; }
bool IsSynchronized { get; }
object SyncRoot { get; }
void CopyTo(Array array, int index);
}
}

ICollection implements all members of IEnumerable and above function. It is also a very good example of inheritance. We will discuss Inheritance in another article. As ICollection implements IEnumerable so we can traverse elements of ICollection using foreach loop but we can’t access through index or and can’t access a random variable. We can’t add and remove element in collection.

Description of Methods and Properties

Count- will return number of elements in collection.
CopyTo- Will Be used to copy collection to an array.
IsSynchronized- Indicates whether access to ICollection is synchronized or not to make it thread safe.
IsSynchronized - SyncRoot were dropped from generic version because thread safety is no longer belongs to the collection.

Example

static void Main(string[] args)
{
int[] array = new int[] { 1, 2, 3, 4, 5 };
ICollection collection = array;
int[] copyArray= new int[5];
Console.WriteLine("Total number of Element in collection {0}", collection.Count);
//Traversing Collection
foreach (var item in collection)
{
Console.WriteLine("Item from collection {0}", item);
}
//Copying collection item to array
collection.CopyTo(copyArray, 0);
//Traversing copyArray
foreach (var item in copyArray)
{
Console.WriteLine("Item from Array {0}", item);
}
}

output

ICollection<T>

ICollection<T> belongs to System.Collections.Generic namespace.

ICollection<T> is generic part of ICollection. Generic part has more functions than non-generic parts because generic is added later in c#. It has 4 extra methods Add, Remove, Clear and contains. We will not discuss already discussed method here. In ICollection<T> , more functionality is added but we can’t still access element through index. First we check the implementation then we will discuss every method.

Implementation of ICollection<T>

namespace System.Collections.Generic
{
public 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);
}
}

Description of Methods and Properties

Count – Count gives number of elements in collection.
IsReadOnly – States whether collection is read only or not if collection is read only than add, remove and clear through exception(NotSupportedExcaption).
Add- Add element to collection.
Clear- Removes all elements from collection.
Contains- Check whether an element exits in collection or not (return true or false).
CopyTo- Copy element to an array.
Remove- Removes an element from collection.

Example:

static void Main(string[] args)
{
List<int> list = new List<int>();
//use can also create in following way
//ICollection<int> collection = new List<int>();
ICollection<int> collection = list;
//Adding element to collection
collection.Add(10);
collection.Add(20);
collection.Add(30);
collection.Add(40);
//Traversing Collection
foreach (var item in collection)
{
Console.WriteLine("{0}", item);
}
//Removing Element
collection.Remove(20);
collection.Remove(30);
//Traversing Collection after removing element
Console.WriteLine("Collection after removing item");
foreach (var item in collection)
{
Console.WriteLine("{0}", item);
}
//Checking lement in collection
if (collection.Contains(10))
{
Console.WriteLine("Element Exits");
}
collection.Clear();
Console.WriteLine("Collection after clearing items");
foreach (var item in collection)
{
Console.WriteLine(item);
}
}

output

Note: You can use user defined datatype with generic part like class.

Example:

public class Student
{
public int StudentID { get; set; }
public string StudentName { get; set; }
}
static void Main(string[] args)
{
ICollection<Student> student = new List<Student>();
student.Add(new Student() { StudentID = 1, StudentName = "Devinder Yadav" });
foreach (var item in student)
{
Console.WriteLine("Your Id is {0} and Name is {1}", item.StudentID, item.StudentName);
}
}

output

IList

IList belongs to using System.Collections namespace

IList have more functionally then ICollection. We can access random element, can remove and can access an element through index and more. We will discuss every method and property.

Implementation of IList

namespace System.Collections
{
public interface IList : ICollection, IEnumerable
{
object this[int index] { get; set; }
bool IsFixedSize { get; }
bool IsReadOnly { get; }
int Add(object value);
void Clear();
bool Contains(object value);
int IndexOf(object value);
void Insert(int index, object value);
void Remove(object value);
void RemoveAt(int index);
}
}

Description of Methods and Properties

this- It will return element through indexing.
IsFixedSize –Tells collection is fixed size or not.
IsReadOnly- States whether collection is read only or not if collection is read only than add ,remove and clear through exception(NotSupportedExcaption).
Add- Add element to collection and return index of that element.
Clear- Removes all element from collection
Contains- Check an element in a collection exits or not.
IndexOf- Return index of an element.
Insert- Insert element at a index.
Remove- Remove an element
RemoveAt- Remove element from an index.

In below example I am not covering already discussed method.

Example:

static void Main(string[] args)
{
IList list = new List<int>();
list.Add(10);
list.Add(20);
list.Add(30);
//add method in IList return index of added element.
Console.WriteLine("Element 40 added at index {0}", list.Add(40));
Console.WriteLine("Collection is of fixedtype {0}",list.IsFixedSize);
Console.WriteLine("Index of element 20 is {0}", list.IndexOf(20));
list.RemoveAt(3);
foreach (var item in list)
{
Console.WriteLine(item);
}
}

Output:

output

IList<T>

IList<T> belongs to System.Collections.Generic namespace

Implementation of IList<T>

namespace System.Collections.Generic
{
public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
{
T this[int index] { get; set; }
int IndexOf(T item);
void RemoveAt(int index);
}
}

Description of Methods and Properties

This- It will return element through indexing.
IndexOf- Return index of an element.
RemoveAt-- remove element from an index.

All the above methods are discussed in IList section so I will not give an example.

If we can traverse a collection using foreach loop then it means, it implements IEnumerable interface.

Where to use

Use of IEnumerable, ICollection and there generic counterpart depends upon your requirement. These are basically for traversing element. When you have requirement of that type you can use them.

These collection types can be used to create your own type of collection. You can create your own collection by using them as a base class and add extra functionality according to your requirement. As these are interfaces you have to implement all the methods to use them.

Until now we have discussed all the interfaces of collection types. In the next article we will discuss about List, queue, stack and many others.