Post
Ask Question

Generics in C# 2.0

In my last article "Limitations of ArrayLists in C#", I focused on issues of type safety and reusability when using ArrayLists.

In this article, we shall focus on how these issues of type safety and reusability are very nicely handled by Generics. All with the help of code again

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. namespace GenericsSample  
  5. {  
  6.     class Person  
  7.     {  
  8.         int _Age;  
  9.         public int Age  
  10.         {  
  11.             get { return _Age; }  
  12.             set { _Age = value; }  
  13.         }  
  14.         String _Name;  
  15.         public String Name  
  16.         {  
  17.             get { return _Name; }  
  18.             set { _Name = value; }  
  19.         }  
  20.         String _Address;  
  21.         public String Address  
  22.         {  
  23.             get { return _Address; }  
  24.             set { _Address = value; }  
  25.         }  
  26.         String _Company;  
  27.         public String Company  
  28.         {  
  29.             get { return _Company; }  
  30.             set { _Company = value; }  
  31.         }  
  32.         public Person() { }  
  33.         public Person(String Name)  
  34.         {  
  35.             this.Name = Name;  
  36.             this.Age = 0;  
  37.             this.Address = String.Empty;  
  38.             this.Company = String.Empty;  
  39.         }  
  40.         public Person(String Name, int Age, String Address)  
  41.         {  
  42.             this.Name = Name;  
  43.             this.Age = Age;  
  44.             this.Address = Address;  
  45.         }  
  46.     }  
  47.     class Program  
  48.     {  
  49.         static void Main(string[] args)  
  50.         {  
  51.             //Generic List Creation  
  52.             //List is a Generic Class provided by .Net Framework 2.0  
  53.             //System.Collections.Generics is the Namespace.  
  54.             List<Person> myPerson = new List<Person>();  
  55.             myPerson.Add(new Person("Saurabh"));  
  56.             myPerson.Add(new Person("Manu"));  
  57.             myPerson.Add(new Person("SomeOne", 24, "Gurgaon"));  
  58.             myPerson.Add(new Person("SomeoneElse", 24, "Gurgaon"));  
  59.             //myPerson.Add(new Car());// This is A Compile Time Error  
  60.             foreach (Person p in myPerson)  
  61.             {  
  62.                 Console.WriteLine(p.Name);  
  63.                 Console.WriteLine(p.Age);  
  64.                 Console.WriteLine(p.Address);  
  65.                 Console.WriteLine(p.Company);  
  66.             }  
  67.             Console.ReadLine();  
  68.         }  
  69.     }  
  70. }  
Two classes can be seen in this code. Class Person is the class of which we want to create list for, and class Program is the main class where we actually create the list of persons and operate upon them.

How Generics tackle the issues posed by ArrayLists?

In the above code example Generic List class has been used to "contain" objects of type Person. At any time we can we can have the Generic List contain any other type, as below:-

  1. //List of Ints  
  2. List<int> myInts = new List<int>();  
  3. myInts.Add(5);  
  4. myInts.Add(10);  
  5. myInts.Add(20);  
  6. foreach (int  x in myInts)  
  7. {  
  8.    Console.WriteLine(x);  
  9. }  
  10. Console.ReadLine();  
The above code snippet indicates that the same List class can be used to contain any datatype at any point of time, without requiring any kind of extra effort from the programmer's side.

The syntax for using any kind of Generic Class is as under

  1. GenericClass<T>  objT = new GenericClass<T>();  
Where T is the datatype that' want to list, and GenericClass is the Generic Class which will wrap our desired datatype (that's the reason, "contains", above has been marked in the double quotes and is marked bold). This Generic Class can be our own custom Generic Class or the ones provided by the .Net Framework.

So technically, T gets replaced by the datatype at compile type. And that's the reasons why a compile time error occurs when casting is not done properly, it will be an InvalidCast Exception while using ArrayLists. Thus Generics enforce type checking at compile time only, making life less difficult.

Performance is another area where Generics make it sweet when compared to ArrayLists. Since T is "replaced" by our datatype at compile time only so, no time and resources are wasted in boxing and unboxing the objects.

Thus Generics are a very powerful and nice feature provided with .Net 2.0. Generics types are found sprinkled throughout the .Net2.0 BCLs; however System.Collections.Generics namespace is chock full of them.


Similar Articles