What the heck is Generics?

Class List is a simple Collection class, that stack-up elements of type <Object> (in other words, it accepts technically any data-typed element, as all data types are inherited from the base class <Object>, any way).

Listing 1

Public class List
{
private object[] elements;
private int count;
public void Add(object element)
{
if (count == elements.Length) Resize(count * 2);
elements[count++] = element;
}
public object this[int index]
{
get { return elements[index]; }
set { elements[index] = value; }
}
public int Count
{
get { return count; }
}
}

As illustrated in Listing 2, technically we can add an element of <integer> as well as <String> data type (in other words, it would be a list of bunch of apples and oranges, together). More so, as mentioned earlier, an explicit cast is required to retrieve element from the collection.

Listing 2

List intList = new List();
intList.Add(1); // Argument is boxed
intList.Add(2); // Argument is boxed
intList.Add("Three"); // Should be an error (but it is NOT!)
int i = (int)intList[0]; // Cast required

Solution:

Now, one of the solutions is perhaps to derive a specific data-typed Collection from class List, say ListOfInt as illustrated below, in Listing 3

Listing 3

Public class ListOfInt
{
private int[] elements;
private int count;
public void Add(int element)
{
if (count == elements.Length) Resize(count * 2);
elements[count++] = element;
}
public object this[int index]
{
get { return elements[index]; }
set { elements[index] = value; }
}
public int Count
{
get { return count; }
}
}

Unfortunately, solving the performance and type-safety problems this way introduces a third, and just as serious problem-productivity impact. Writing type-specific data structures are a tedious, repetitive, and error-prone task. When fixing a defect in the data structure, you have to fix it not just in one place, but in as many places as there are type-specific duplicates of what is essentially the same data structure. In addition, there is no way to foresee the use of unknown or yet-undefined future types, so you have to keep an Object-based data structure as well.

The solution to the above mentioned problems is my favorite little monster 'Generics'. Listing 4 below shows the code modification to turn the code as put up in Listing 1, with an objective of creating a type-safe, generic Collection class. (and if you are wondering why 'Generics' is called-so, I am sure, you reckon it by now)