According to MSDN, "Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code." By using Generics, classes and methods can work uniformly on the values of different types. Generics facilitate type safety, improved performance and reduced code. It promotes the usage of parameterized types on our types and is also known as parametric polymorphism. The Common Language Runtime (CLR) compiles any Generic type to IL and Metadata as it does with the other types; but it stores added information pertaining to the generic types which is used to bind the generic type to a specific type at runtime when the generic type is instantiated. Note that for generic types that are bound to value types, the generic types are instantiated for each value type that it is bound to. Unlike this, for generic types that are bond to reference types, the generic type instance refers to the location in memory of the reference type to which it is bound for all the instances of the generic type. The following code snippet in Listing 1 illustrates how a generic type can be implemented.

Listing 1

public class Test<T> 
{
    public void Display() 
      {
          //Some code
      }
//Other members
}

We may say that the type parameter is an unbound type as it is not bound to any specific type. When we instantiate this class, the generic type has to be bound to a particular type as shown in the code snippet in Listing 2.

Listing 2

Test<int> test = new Test<int>();

Note that in the code snippet above, the resulting type called "test" is a bound type. The code example in Listing 3 shows how we can use a generic method on varied types.

Listing 3: Implementing a generic method

using System;  
using System.Collections.Generic;  
 
   class Test  
   {  
      static void Main( string[] args )  
      {  
        Test t = new Test();
        int[] integerArray = {1,2,3,4,5,6};  
        char[] characterArray = { 'J', 'O', 'Y', 'D', 'I','P' };   
        double[] doubleArray = {0.1,0.2,0.3,0.4,0.5,0.6};  
         Console.WriteLine( "Displaying the contents of the integer array:--" );  
         t.Display(integerArray);
         Console.WriteLine( "Displaying the contents of the character array:--" );
         t.Display(characterArray);
         Console.WriteLine( "Displaying the contents of the double array:--" );
         t.Display(doubleArray);
      }   
     
      public void Display< GenericArray >( GenericArray[] array )  
      {  
         for (int i = 0; i< array.Length; i++)  
            Console.WriteLine(array[i]);  
      }
   }

The following points sum up the basic advantages of using Generics.

·         Code Efficiency

·         Enhanced performance

·         Type Safety and reliability

·         Maintainability of code