Generic Types in C# 2.0 with Sample


Generic Types

 

Generics are the most powerful feature of C# 2.0. It allows defining type-safe data structures, without committing to actual data types. In C# 1.0 we can either declare reference type or value type. But in most of the application we come across situation where we need type that can hold both reference & value type. In such situation we use generic types.

 

Why Generics?

  1. Generic type doesn't care what the type is. We can specify the type at runtime.
  2. It avoids boxing difficulties. In C# 1.0, if we want to put any object into a List, Stack, or Queue objects, we have to take type as System.Object.
  3. It boosts the performance of the application because we can reuse data processing algorithm without duplicating type-specific code.

How Generic implemented:

(1)    Generic type is instantiated at run-time not compiled time

(2)    Generic type are checked at time of declaration not at instantiation

(3)    It works for both reference type & value type.

 

Let's create simple class "GenericList" using C# 1.0 & 2.0 respectively & compare them.

 

 

Code GenericList Class (C# 1.0)

 

using System;
using System.Collections.Generic;
using System.Text;
public class GenericList

    {

        private  object[] elements;

        private int count; 

        public GenericList()

        {

            elements = new object[10];

        }

        public object this[int index]

        {

            get { return elements[index]; }

            set { elements[index] = value; }

        } 

        public void Add (object parm)

        {

            if (count == elements.Length)

            {

                  // Increase the

                  object[] tmpArray = null ;

                  elements.CopyTo(tmpArray,0);

                  elements = new object[count * 2];

                  elements = tmpArray;                             

            }

            elements[count] = parm;

            count = count + 1;

        }

   }    

 

Main Method:

 

static void Main(string[] args)

        {

            Console.WriteLine("using C# 1.0"); 

            GenericList list = new GenericList();

            list.Add(20);        //Argument is boxed

            list.Add(40);        //Argument is boxed

            list.Add("Sixty");   //Error in retrieving

            Console.WriteLine("Item Added"); 

            int val = (int)list[0]; //Casting required

            Console.WriteLine("Value retrived : " + val); 

        }

 

Memory Consumption

 

In C# 1.0 boxing is necessary evil to make type system work. While working with structures of System.Collection namespace (Stacks,List,Hashtable etc) we face the problem in insertion & retrieval of values. We need to take System.object as type & System.object is reference type, so whenever we access the hashtable, the runtime has to box the values to put into the collection & need to unbox to take it out.

 

list.Add(20);        //Argument is boxed

 

In C# int takes 4 byte but when it boxed it take (4+8) 12 bytes, which is 3 times to normal size.

In C# 2.0 the type is decided at runtime so boxing does not take place.

 

Type Safe

 

When we use the statement

 

list.Add ("Sixty"); or List [3] = "sixty";

 

It compiles successfully but later on if some one pulls value and cast it into integer it fails. The problem is fixed in C# 2.0; we will get compilation error there.

 

 

Code GenericList Class (C# 2.0)

 

public class GenericList<T>

    {

        public GenericList()

        {

            elements = new T[10]; 

        } 

        private T[] elements;

        private int count;        

        public T this[int index]

        {

            get {return elements [index];}

            set {elements [index] = value;}

        }    

        public void Add (T parm)

        {

            if (count == elements.Length)

            {

                T[] tmpArray = null;

                elements.CopyTo(tmpArray, 0);

                elements = new T [count * 2];

                elements = tmpArray; 

            } 

            elements [count] = parm;

            count = count + 1;  

        } 

    }

 

Main Method:

 

static void Main(string[] args)

{
Console.WriteLine("using C# 1.0"); 
GenericList<int> genericList = new GenericList<int>();
genericList.Add (10);          //No boxing
genericList.Add (20);          //No boxing

// genericList.Add("Fifty");   //Compile Time Error
Console.WriteLine("Item Added"); 
int valGeneric = (int)genericList[0]; //No Casting Required
Console.WriteLine("Value retrived : " + valGeneric); 

}

 

Some other Points:

 

(1) Type parameter can be applied to Class, struct, interface & delegates.

 struct Buket<K, V>;
 interface ICompare<T>

(2)    Type parameter can have constraints.

 

Constraint

Description

Public class Books where T: struct

The type argument for class Books must be a value type

Public class Books where T: class

The type argument for class Books must be a reference type

Public class Books where T: new( )

The type argument for class Books must have a public default constructor

Public class Programmer where T: <Employee>

The type argument for class Programmer must be of Employee type.

Up Next
    Ebook Download
    View all
    Learn
    View all