Generics in C# 2.0

Generics are simply placeholders for actual types. Generics are defined with left and right brackets: <T> In other words Generics allow you to define type-safe data structures, without committing to actual data types. .Net 2.0 provides number of generic collection classes for lists, stacks, queues, dictionaries.

Generics Benefits:

Generics in .NET let you reuse code and the effort you put into implementing it. The types and internal data can change without causing code bloat, regardless of whether you are using value or reference types. You can develop, test, and deploy your code once, reuse it with any type, including future types, all with full compiler support and type safety. Because the generic code does not force the boxing and unboxing of value types, or the down casting of reference types, performance is greatly improved. With value types there is typically a 200 percent performance gain, and with reference types you can expect up to a 100 percent performance gain in accessing the type (of course, the application as a whole may or may not experience any performance improvements). The source code available with this article includes a micro-benchmark application, which executes a stack in a tight loop. The application lets you experiment with value and reference types on an Object-based stack and a generic stack, as well as changing the number of loop iterations to see the effect generics have on performance.

Let us create console application to have actual understanding.

In visual studio 2005 create new project >>Console Application Name it as "GenericsLists".

We will add class called as "Customer" to this console application as below:

public class Customer

{

private int custId;

public Customer(int Id)

{

this.custId = Id;

}

public override string ToString()

{

return custId.ToString();

}

}

With any of the console application we will have something called as "Program.cs"

Which will be some thing like this:

public class Program

{

static void Main()

{

//Type safe list (of Customer objects)

List<Customer> custList = new List<Customer>();

//Type safe list (of integers)

List<int> intList = new List<int>();

//Populate the Lists

for (int i = 0; i < 5; i++)