Generics in C#

Generics are new feature provided with version2.0 of the Microsoft.Net framework. Generic classes and methods combinere-usability, type safety and efficiency in a way that therenon-generics counterparts do not/cannot.

In this part some features of ArrayLists andthere shortcomings/limitations will be discussed. The contained in thisarticle has been written in Visual Studio 2005 in C#.

Earlier ArrayLists used to server the purpose,but that in a certain limit. Moreover, using ArrayLists to storedifferent types came as a good performance cost. At the client end itour desired type that we are storing in the ArrayList but internallythere’s much more that goes on.

Sample the code below:-

System.Collections.ArrayList myList = new System.Collections.ArrayList ();
myList.Add (22);
myList.Add ("C# Generics");
myList.Add (22.45);

The usage convenience that is perceived abovecomes at a cost. Any reference or value type that is stored or added inthe ArrayList (myList) is implicitly upcasted to System.Object type.And while retrieval, the reverse happens – downcasting to theappropriate type takes place.

Moreover, there is compromise on the Type Safety front also. Consider the code below:-

int item =0;

//This will cause an InvalidCastException
foreach (int x in myList)
{
Item = item+x;
}

The reason is evident.

In .Net 1.x type-safety was achieved bywriting your own typed ArrayList. But again, in that case re-usabilitywas a major issue. Consider the following code:-

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace ArrayListSample
{
#region Person Class
class Person
{
String Name;
Int32 Age;
String Address;

#region Constructor
public Person() { }
public Person(String Name, Int32 Age, String Address)
{
Name = Name;
Age = Age;
Address = Address;
}

public Person(String Name, Int32 Age)
{
Name = Name;
Age = Age;
Address = String.Empty;
}
public Person(String Name, String Address)
{
Name = Name;
Age = 0;
Address = Address;
}
public Person(String Name)
{
Name = Name;
Age = 0;
Address = String.Empty;
}
#endregion
}
#endregion

#region PeopleCollection Class
class PeopleCollection : System.Collections.IEnumerable
{
private ArrayList arPeople = new ArrayList();

public PeopleCollection()
{

}

#region Methods
public void AddPeople(Person p)
{
arPeople.Add(p);
}

public void ClearPeople()
{
arPeople.Clear();
}

int Count;

public int PeopleCount
{
get { return Count; }
}
#endregion

#region IEnumerable Members

public System.Collections.IEnumerator GetEnumerator()
{
return arPeople.GetEnumerator();
}

#endregion
}
#endregion

class Client
{
public static void Main()
{
PeopleCollection myPeople = new PeopleCollection();
myPeople.AddPeople(new Person("Saurabh",24,"Gurgaon"));
myPeople.AddPeople(new Person("Manu"));

foreach (Person Person in myPeople)
{
Console.WriteLine(Person);
}
Console.ReadLine();
}
}
}

The above code does achieve type safety butthen we will have to write an almost identical custom collection foreach type we wish to contain. Because:-

myPeople.AddPeople(new Car());

would be a compile time error, since thecode/approach above achieves type safety. So at the end of the day itwill be a big nightmare !!

So above we find some of the limitations ofArrayLists. In the next issue we will find how Genrics solve the issuesdiscussed above.