Importance of Generics in C#

using System;  
using System.Collections;  
  
public class ArrayListExample  
{  
    static void ArrayListMethod()  
    {   
        // Creates and initializes a new ArrayList.  
        ArrayList listExample = new ArrayList();  
        listExample.Add("One");  
        listExample.Add("2");  
        listExample.Add(3);          
    }  
}

using System;  
using System.Collections.Generic;  
  
public class GenericList  
{  
    public static void GenericListMethod()  
    {  
       List<int> genericList = new List<int>();  
       // No boxing, no casting:  
       genericList.Add(12);  
       genericList.Add(13);  
       genericList.Add(14);  
       genericList.Add(15);   
    }  
}

using System.Collections;  
   
public class GenericArrayList  
{  
    public static void ListSorting()  
    {  
        int[] intArray = { 8, 10, 2, 6, 3 };   
  
       // Sort your int array  
        Array.Sort(intArray);  
  
        foreach (var i in intArray)  
        {  
            Console.WriteLine(i);  
        }  
  
        // Sort it the other way   
        string[] strArray = { "A", "D", "C", "E", "B" };  
        Array.Sort(strArray);   
  
        foreach (var i in strArray)  
        {  
            Console.WriteLine(i);  
        }  
  
        Console.ReadLine();  
    }  
}

The following shows how to do it using Generics:

using System.Collections.Generic;   
  
public class ArrayList  
{  
    private static object[] Sort<T1>(object[] iInputeArray)  
    {  
        array.Sort(iInputeArray);  
        return iInputeArray;  
    }  
}

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.

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

Benefits

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

class BoxUnbox  
{  
  Static void Main ()  
  {  
     Int i=1;  
     Object o=i;    //boxing  
     Int j = (int) o; //unboxing  
  }  
}

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.

Example

using System.Collections.Generic;  
namespace Generic  
{
    public class ArrayClass<T>  
    {
        object Data;  
        public void Push(object Obj)  
        {  
            Data= Obj;  
        }  
        public object Pop()  
        {  
            return Data;  
        }  
    }  
}

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.

public class SubClass  
{  
    public static void MyClass()  
    {  
        ArrayClass<int> intArray = new ArrayClass<int>();  
        intArray.Push(10);  
        object intReturnValue = intArray.Pop();  
        Console.Write("   {0}", intReturnValue);   
        ArrayClass<string> strArray = new ArrayClass<string>();  
        strArray.Push("Hello word");  
        object strReturnValue = strArray.Pop();  
        Console.Write("   {0}", strReturnValue);  
        Console.ReadLine();  
    }  
}

Generic Methods

Generic methods are a method declared with type parameters.

Examples

using System.Collections.Generic;  
  
public class ArrayList  
{  
    static void Swap<T>(ref T lhs, ref T rhs)  
    {  
        T temp;  
        temp = lhs;  
        lhs = rhs;  
        rhs = temp;  
    }  
}

The following method shows how to call the method above.

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