Collections in C#

Here we will study Collections in C# and their use. First its important to note here that Collections play an important role in LINQ.

So let's start with the topic of Collections.

First of all let us try to understand why Collections were introduced in the .NET framework.

Let us consider an array of string data as in the following:

static void Main(string[] args)
{
   //Make an array of string data.
   string[] strArray= {"first","Second","Third"};

   //Show no. of items in array using length property.
   Console.Writeline("This array has {0} items.",strArray.Length);
   Console.Writeline();

   //Display contents using enumerator.
   foreach(string s in strArray)
   {
      Console.Writeline("Array Entry: {0}",s);
   }
   Console.Writeline();  }

Now as you see I have made an array of three items. Now suppose I want to add a new item at the end of the array at the index[3].

So what will happen here is it will give a run time exception because arrays are fixed size containers. So here we require a more flexible data container that can dynamically resize our structure as we insert or remove items. Here Collections are useful.

The following four points will make Collections more clear.

1. Collections resize the structure so that the previous data is not lost.
2. They don't take contiguous memory.
3. Dynamic Collection
4. Every class whose parent is IEnumerable and implements the IEnumerator interface comes under the category of Collection classes.

Now the Collection classes are divided into the following two major categories:

1. Non-generic
2. Generic

Non-Generic

These classes are in the namespace System.Collections. They may contain N number of elements and a heterogeneous collection of elements because the type of any non-generic collection is fixed, in other words System.Object. So whatever data type we use will be implicitly type cast it into System.Object.

Generic

Generic Collections are in the namespace System.Collections.Generic. They also behave as a Collection but unlike non-generic Collections they do not have a pre-defined data type. So we need to define at run time an object declaration of a Generic Collection class with angular braces. So it may contain a collection of homogeneous elements and will return the same data type that is assigned to the object Collection.

Now let us talk about the IEnumerable class and IEnumerator interface. Note the class whose parent is an IEnumerable class and implements the IEnumerator interface will act as a Collection class and the object of that class can use a Foreach loop.

Now for the the golden rule for the Collection class. Whenever a collection class is in a Foreach loop the .Net Framework will check the following two things:

1. Whether the class is implementing an IEnumerator interface.
2. Secondly it will ask for the number of items in the IEnumerable class.

Class program
{
   static void Main(string[] args)
   {
      var school= new school();
      foreach(var student in school)
   {
}

In the preceding code, as soon as the .Net framework finds the school class in the foreach loop, it will check if the school class is deriving from an IEnumerable class and secondly it will ask for the IEnumerator interface of the school class that will declare the contents of the school class.

Class school :IEnumerable
internal class StudentEnumerator: IEnumerator

Note that the IEnumerable class acts as the Counter class and it should have the individual existence.

In the preceding two lines of code I have simply declared an IEnumerable class and an StudentEnumerator interface.

Now I will return an instance of the StudentEnumerator interface in the GetEnumerator method.

public IEnumerator GetEnumerator()
{
   return new StudentEnumerator();
}

Also note that one instance of the Enumerator class should be a forward-only cursor and it cannot reset itself. Moreover it cannot tell the length of the data.

As soon as we return an instance of the Enumerator class it will be asked using a method named "Move Next" do you have the data and after the .Net Framework gets the call from the IEnumerator by the property called "Current". the IEnumerator will take the current data and pass it to the .Net Framework by returning the address of the data.

So basically the chain goes like:

Move Next -> Yes > Current-> Address.

Note that the Enumerator is a read-only interface. It just returns the address of the data.

To avoid the threads we can add the namespace System.Collections.Synchronization.

Now note in the preceding code the StudentEnumerator class does not have an object of the school class.

We will use here constructors to do this.

public StudentEnumerator(Student ram,Student suresh,Student ashok)
{
   _ram=ram;
   _suresh=suresh;
   _ashok=ashok;
}

private Student current= null;
private bool_iterationcomplete= true;
public object current
{
   get
   {
      return_ current;
   }
}
public bool MoveNext()
{
   if(_iterationComplete==true)
   if(_current== null)
   return false;
   {
      _current=_ram;
      return true;
   }
   else if(_current==_ram)
   {
      _current=_suresh;
      return true;
   }
   else if(_current==_suresh)
   {
      _current=_ashok;
      return true;
   }
   else if (_current==_ashok)
   {
      _current=null;
      return false;
   }
}

Now update the main method as follows:

static void Main(string[] args)
{
   var school= new school();
   for each(var student in school)
   {
      var enumerator=school.GetEnumerator();
      while(Enumerator.MoveNext)
      {
         Student student=(Student)Enumerator.Current;
         Console.Writeline(Student.Name);
      }
   }
}

I have tried my best to describe Collections in C#. Still if anyone has queries regarding the article then do provide your valuable comments.