.NET Framework: Collections and Generics

The original release of the .NET Framework included collections as .NET was introduced to the Microsoft programming world. The .NET Framework 2.0 introduced generics to complement the System.Collections namespace and provide a more efficient and well performing option.

Introduction to Collections

A collection is a container to which objects can be added. This container offers a powerful flexibility and adaptability. Collections often hold data items that are traversed in a loop structure. All of the items stored in the collection are stored as objects. This means that whatever type you are putting in the collection is taken down to its root object form as it is put in the collection and put back to its native form as it is pulled out. The act of taking a static instance of a particular class down to its base object type and back again is referred to as boxing and unboxing. The example below demonstrates filling an ArrayList, which is a type of collection, and getting the items back out. Notice how the items have to be cast as they are retrieved to return them to their native type.

System.Collections.ArrayList testList = new System.Collections.ArrayList();

// Add some numbers to the list
for (int i = 0; i < 20; i++)
{
  // Go ahead and play here.  You can add whatever type you want in here
  // without issue as you add.  Will be an issue for you at runtime as you
  // retrieve items.
  testList.Add(i);
}

foreach (var item in testList)
{
  // Go ahead and try something like item + 1 here without the cast
  // and see what happens!
  Console.Write("{0}", (int)item);
}

C# introduced the object initialization syntax, which allows you to initialize a collection with values at the time of declaration. This makes collections easier to work with, or at least easy to write example code with! The initializer syntax looks very similar to normal declaration syntax, but adds curly brackets that surround the data being initialized. The following sample code demonstrates the syntax.

int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

There is a performance challenge with collections since they store everything as objects. There is overhead as items are added or removed from a collection because they are boxed and unboxed to a specific type. An additional drawback is that you lose compile time type checking to enforce consistent use of the same type within your collection. There is a workaround for the type check, which involves creating a wrapper class of your own that inherits from CollectionBase and limits the specific type that can be added or removed from the collection. However, if your C# programming is collection intensive, that increases the amount of code you need to write and maintain.

Generics

Generics were introduced in the version 2.0 of the Microsoft framework as a solution to the problems with collections mentioned above. Generics offer a combination of type safety, performance, and generality in the type. A generic is a type safe class that is declared without a specific type applied to its definition. The type is specified at the time the object is actually instantiated and used. The .NET Framework includes a number of generic objects in the System.Collections.Generic namespace. It is likely you will find that many of these will meet your needs. In the event they don't, you can always build your own generic classes as well. The C# tutorial code below is a rewrite of our prior example, but using generics this time. You'll see that you get the compile time checking as well as the automatic type recognition as you retrieve.

List testGeneric = new List();
for (int i = 0; i < 20; i++)
{
  // Go ahead and play here.  You'll get a compile time error here 
  // if you try to add anything other than an int.
  testGeneric.Add(i);
}

foreach (int item in testGeneric)
{
  Console.Write("{0}", item);
}

Summary

We have looked at the original collection that was introduced with the .NET Framework. We discussed the challenges in using it, and introduced Generics which offer a solution to the performance issues and lack of compile time check with collections. It is likely that most of the collection types you will use as a .NET developer going forward will be of the generic variety given the advantages.