Importance of Generics in C#


Generics (in  the "System.Collections.Generic" namespace) were introduced in the 2.0 version of .Net and are now widely used. The concept is similar to C++ templates but different in implementation and capabilities. It is a very important feature of .Net programming, allowing a class and methods such as lists, hash tables, queues and so on to be defined with a type T as a parameter.

The type of generic parameter is specified only at the time of declaration. Using this, the programmer will improve the performance of an application. In addition to performance, generics provide type-safety and higher quality code because you get to reuse data processing algorithms without duplicating type-specific code.

Generics are also known as Parametric polymorphism.


You can write a single class of generic type and we can use that generic class just by applying the appropriate datatype. For example I create a class MyClass<T> and we can use it like MyClass<int>, MyClaas<String>, MyClass<double> or MyClass< AnyClass> without the need for casting and unboxing.  For examle, consider a scenario where we need a different kind of queue, like a queue of int, string so we can create a generic type queue and based on our needs we can use that.

Advantages of using generic

ArrayList dynamically resizes. As elements are added, it grows in capacity to accommodate them. It is most often used in older C# programs. It stores a collection of elements of type object. Casting is needed. ArrayList is present in the System.Collections namespace.

Generics provide a solution for the limitation of an ArrayList collection in the Common Language Runtime. We will see the limitations of non-generic collection classes, using the ArrayList collection class.
  1. using System;  
  2. using System.Collections;  
  4. public class ArrayListExample  
  5. {  
  6.     static void ArrayListMethod()  
  7.     {   
  8.         // Creates and initializes a new ArrayList.  
  9.         ArrayList listExample = new ArrayList();  
  10.         listExample.Add("One");  
  11.         listExample.Add("2");  
  12.         listExample.Add(3);          
  13.     }  

In the ArrayList Collection, any reference or value type data added to an ArrayList must be typecast to "System.Object". If the items are value types then they must be boxed when they are added to the list and unboxed when they are retrieved. The casting, boxing, unboxing operation reduce the performance.

In a generic List<T> collection, using the "System.Collections.Generic" namespace, we will see the same operation.

  1. using System;  
  2. using System.Collections.Generic;  
  4. public class GenericList  
  5. {  
  6.     public static void GenericListMethod()  
  7.     {  
  8.        List<int> genericList = new List<int>();  
  9.        // No boxing, no casting:  
  10.        genericList.Add(12);  
  11.        genericList.Add(13);  
  12.        genericList.Add(14);  
  13.        genericList.Add(15);   
  14.     }  

 As compared to ArrayList it would be safer and faster, because in ArrayList we can enter anything since it accepts the value of object type. Here we can only enter type specific data like int, string or double.

  • Code Reusability in generics  (Advantage)

Generics provide type-safe code with re-usability.  

Suppose you need to sort the integer and floating type numbers, let's see how to do it in collections and generics.
The following shows how to do it in a collection:

  1. using System.Collections;  
  3. public class GenericArrayList  
  4. {  
  5.     public static void ListSorting()  
  6.     {  
  7.         int[] intArray = { 8, 10, 2, 6, 3 };   
  9.        // Sort your int array  
  10.         Array.Sort(intArray);  
  12.         foreach (var i in intArray)  
  13.         {  
  14.             Console.WriteLine(i);  
  15.         }  
  17.         // Sort it the other way   
  18.         string[] strArray = { "A""D""C""E""B" };  
  19.         Array.Sort(strArray);   
  21.         foreach (var i in strArray)  
  22.         {  
  23.             Console.WriteLine(i);  
  24.         }  
  26.         Console.ReadLine();  
  27.     }  

The following shows how to do it using Generics:

  1. using System.Collections.Generic;   
  3. public class ArrayList  
  4. {  
  5.     private static object[] Sort<T1>(object[] iInputeArray)  
  6.     {  
  7.         array.Sort(iInputeArray);  
  8.         return iInputeArray;  
  9.     }  

Here T is a type. Once we create this method, we can call it with various data types as follows.
In this way a Generic provides code re-usability.

  1. public  static void SortList()  
  2. {  
  3.     object[] iInputArray = { 3, 5, 8, 6, 10, 6, 2, 1, 12 };  
  4.     iInputArray = Sort<int>(iInputArray);   
  6.     foreach (Object obj in iInputArray)  
  7.     Console.Write("   {0}", obj);   
  9.     object[]strInputArray = { "A" ,"C""T""R""E""D"  };  
  10.     strInputArray = Sort<string>(strInputArray);  
  12.     foreach (Object obj in strInputArray)  
  13.     Console.Write("   {0}", obj);  
  15.     Console.WriteLine();  
  16.     Console.ReadLine();  


The following are the benefits of generics:

  • There is no need for casting for accessing the elements of the data.
  • Code is not duplicated for multiple types of data.
  • Generics can hold the data with the same type and we can decide what type of data that the collection holds.
  • You can create your own generic interface, classes, method, events and delegate.

Why to use Generics

There are mainly two reasons to use generics as in the following:

  1. Performance: Collections that store the objects uses boxing and unboxing on data types. A collection can reduce the performance.
    By using generics it helps to improve the performance and type safety.
  2. Type Safety: there is no strong type information at compile time as to what it is stored in the collection.

When to use Generics

  • When you use various #ff0000 data types, you need to create a generic type.
  • It is easier to write code once and reuse it for multiple types.
  •  If you are working on a value type then for that boxing and unboxing operation will occur, Generics will eliminate the boxing and unboxing operations.

Boxing: Conversion of a value type into a reference type of variable. When the variable of a value type is to be converted to a reference type, the object box is allocated to hold the value and copies the value into a box.

Unboxing: It is just the opposite of boxing.   
Example Boxing/Unboxing

  1. class BoxUnbox  
  2. {  
  3.   Static void Main ()  
  4.   {  
  5.      Int i=1;  
  6.      Object o=i;    //boxing  
  7.      Int j = (int) o; //unboxing  
  8.   }  
  9. }  
Generic Class


The common use of a generic class is with collections like a linked list, hash table, stack, queue and tree. The addition and removal of an item from a collection is basically the same.

  1. using System.Collections.Generic;  
  2. namespace Generic  
  3. {
  4.     public class ArrayClass<T>  
  5.     {
  6.         object Data;  
  7.         public void Push(object Obj)  
  8.         {  
  9.             Data= Obj;  
  10.         }  
  11.         public object Pop()  
  12.         {  
  13.             return Data;  
  14.         }  
  15.     }  

Here T is a type of parameter.  We can pass any data type (int, string and so on) as a parameter.

This class can be used as below.

  1. public class SubClass  
  2. {  
  3.     public static void MyClass()  
  4.     {  
  5.         ArrayClass<int> intArray = new ArrayClass<int>();  
  6.         intArray.Push(10);  
  7.         object intReturnValue = intArray.Pop();  
  8.         Console.Write("   {0}", intReturnValue);   
  9.         ArrayClass<string> strArray = new ArrayClass<string>();  
  10.         strArray.Push("Hello word");  
  11.         object strReturnValue = strArray.Pop();  
  12.         Console.Write("   {0}", strReturnValue);  
  13.         Console.ReadLine();  
  14.     }  

Generic Methods

Generic methods are a method declared with type parameters.

  1. using System.Collections.Generic;  
  3. public class ArrayList  
  4. {  
  5.     static void Swap<T>(ref T lhs, ref T rhs)  
  6.     {  
  7.         T temp;  
  8.         temp = lhs;  
  9.         lhs = rhs;  
  10.         rhs = temp;  
  11.     }  

The following method shows how to call the method above.

  1. public static void TestSwap()  
  2. {  
  3.     int a = 1;  
  4.     int b = 2;  
  5.     Swap<int>(ref a, ref b);  
  6.     System.Console.WriteLine(a + " " + b);  
  7.     Console.ReadLine();  

Recommended Free Ebook
Similar Articles