// List of strings
        IList<string> stringList = new List<string>();

        // We can convert it to an Enumerable collection
        IEnumerable<object> Obj= strings;

For this purpose IEnumerable is marked with the Out modifier.

        public interface IEnumerable<out T> : IEnumerable {
            IEnumerator<T> GetEnumerator();
        }

In C# 4.0, Contravariance allows for example, IComparer<X> to be cast to IComparer<Y> even if Y is a derived type of X. To achieve this IComparer should be marked with the In modifier.

        public interface IComparer<in T> {
            public int Compare(T left, T right);
        }

using System;
using System.Collections.Generic;
using System.Text;
 

namespace GenericsSample
{
class Person
{
int _Age;

public int Age
{
get { return _Age; }
set { _Age = value; }
}
String _Name;

public String Name
{
get { return _Name; }
set { _Name = value; }
}
String _Address;

public String Address
{
get { return _Address; }
set { _Address = value; }
}
String _Company;

public String Company
{
get { return _Company; }
set { _Company = value; }
}

public Person() { }
public Person(String Name)
{
this.Name = Name;
this.Age = 0;
this.Address = String.Empty;
this.Company = String.Empty;
}
public Person(String Name, int Age, String Address)
{
this.Name = Name;
this.Age = Age;
this.Address = Address;
}

}

class Program
{
static void Main(string[] args)
{
//Generic List Creation
//List is a Generic Class provided by .Net Framework 2.0
//System.Collections.Generics is the Namespace.

List<person> myPerson = new List<person>();
myPerson.Add(new Person("Saurabh"));
myPerson.Add(new Person("Manu"));
myPerson.Add(new Person("SomeOne", 24, "Gurgaon"));
myPerson.Add(new Person("SomeoneElse", 24, "Gurgaon"));

//myPerson.Add(new Car());// This is A Compile Time Error

foreach (Person p in myPerson)
{
Console.WriteLine(p.Name);
Console.WriteLine(p.Age);
Console.WriteLine(p.Address);
Console.WriteLine(p.Company);
}
Console.ReadLine();
}
}
}

Two classes can be seen in this code. ClassPerson is the class of which we want to create list for, and classProgram is the main class where we actually create the list of personsand operate upon them.

How Generics tackle the issues posed by ArrayLists?

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

In this part some features of ArrayLists andthere shortcomings/limitations will be discussed. The contained in thisarticle has been written in Visual Studio 2005 in C#.

Earlier ArrayLists used to server the purpose,but that in a certain limit. Moreover, using ArrayLists to storedifferent types came as a good performance cost. At the client end itour desired type that we are storing in the ArrayList but internallythere’s much more that goes on.

Sample the code below:-

System.Collections.ArrayList myList = new System.Collections.ArrayList ();
myList.Add (22);
myList.Add ("C# Generics");
myList.Add (22.45);

The usage convenience that is perceived abovecomes at a cost. Any reference or value type that is stored or added inthe ArrayList (myList) is implicitly upcasted to System.Object type.And while retrieval, the reverse happens – downcasting to theappropriate type takes place.

Moreover, there is compromise on the Type Safety front also. Consider the code below:-

int item =0;

//This will cause an InvalidCastException
foreach (int x in myList)
{
Item = item+x;
}

The reason is evident.

In .Net 1.x type-safety was achieved bywriting your own typed ArrayList. But again, in that case re-usabilitywas a major issue. Consider the following code:-

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace ArrayListSample
{
#region Person Class
class Person
{
String Name;
Int32 Age;
String Address;

#region Constructor
public Person() { }
public Person(String Name, Int32 Age, String Address)
{
Name = Name;
Age = Age;
Address = Address;
}

public Person(String Name, Int32 Age)
{
Name = Name;
Age = Age;
Address = String.Empty;
}
public Person(String Name, String Address)
{
Name = Name;
Age = 0;
Address = Address;
}
public Person(String Name)
{
Name = Name;
Age = 0;
Address = String.Empty;
}
#endregion
}
#endregion

#region PeopleCollection Class
class PeopleCollection : System.Collections.IEnumerable
{
private ArrayList arPeople = new ArrayList();

public PeopleCollection()
{

}

#region Methods
public void AddPeople(Person p)
{
arPeople.Add(p);
}

public void ClearPeople()
{
arPeople.Clear();
}

int Count;

public int PeopleCount
{
get { return Count; }
}
#endregion

#region IEnumerable Members

public System.Collections.IEnumerator GetEnumerator()
{
return arPeople.GetEnumerator();
}

#endregion
}
#endregion

class Client
{
public static void Main()
{
PeopleCollection myPeople = new PeopleCollection();
myPeople.AddPeople(new Person("Saurabh",24,"Gurgaon"));
myPeople.AddPeople(new Person("Manu"));

foreach (Person Person in myPeople)
{
Console.WriteLine(Person);
}
Console.ReadLine();
}
}
}

The above code does achieve type safety butthen we will have to write an almost identical custom collection foreach type we wish to contain. Because:-

myPeople.AddPeople(new Car());

would be a compile time error, since thecode/approach above achieves type safety. So at the end of the day itwill be a big nightmare !!

So above we find some of the limitations ofArrayLists. In the next issue we will find how Genrics solve the issuesdiscussed above.

The usage of generics within the data structure adjusts to the different data type of the passed variables. Briefly, a generic is a code template that can be applied to use the same code over and over again. Whenever the generic is used, it can be adapted for different data types without require to rewrite any of the internal code.

A List collection class can be a good example:

List<int> Mylist1 = new List<int>();

// No boxing or casting necessary
list1.Add (5);

If we want to expand this code and make it more sensible, we can build
something like this:

using System;
using System.Collections;
using System.Text;

namespace TList
{
public class List<template> : CollectionBase
{
public List(){ }

public Template this[int index]
{
get { return (Template)List[index]; }
set { List[index] = value; }
}

public int Add(Template value)
{
return List.Add(value);
}
}
}
</template></int></int>

If we decide to convert any fields to generic fields, we would just change their types to Template. Continues…

Introduction

Before we starttampering around the code, lets understand why we need a generic type? Well inmost of application development we come across lots of situation where we need atype which can hold both value types and reference type. In this situation weneed a generic type which can do both. Before we start working on generic type,lets understand little about types in .Net as we know there are two fundamentalcategories of types

 1]valuetypes     (example : structures,primitive type,enums)

 2]referencetypes (example : Classes,interface,arrays,strings etc..,)

So when you areusing any one of the above types they are bonded to that particular type. Forexample if we declare a structure it bonds to value type and when we declare aclass it bonds to reference type. Despite the fact that declaration syntax issame for both but semantics are distinct.  Andin terms of memory allocation for value is on stack and where as for referencetype is on run-time heap.

Assignment to a variable of value types createsa copy of the value.

For example:  

//vtyp.cs<o:p></o:p>

using System;
public class valTyp
{
public static void Main()
{
Int32 I=10,J=0;
J=I; 
// this will create a copy value I into J 
I++;
Console.WriteLine( "I value: {0}, J value {1}",I,J);
}
}

Output:

D:\vstudio>vtype
I value: 11, J value 10

The assignment tothe local variable J does not impact the local variable I becauseboth local variables are of a value type (the type Integer) and eachlocal variable of a value type has its own storage.

But Assignment to avariable of a reference type creates a copy of the reference, not a copy of thevalue being referenced let?s see this with an example below.

For example:  

//vref.cs
<o:p></o:p>using System;
public class Cclass
{
public int val = 0;
}
public class refTyp
{
public static void Main()
{
Cclass ref1 = new Cclass();
Cclass ref2=ref1;
ref2.val = 555;
Console.WriteLine( "Before increament Ref1 value: {0}, Ref2 value {1}",ref1.val,ref2.val);
ref2.val++;
Console.WriteLine( "After increament Ref1 value: {0}, Ref2 value {1}",ref1.val,ref2.val);
 }
}
Output:

D:\vstudio>vref
Before increament Ref1 value: 555, Ref2 value 555
After increament Ref1 value: 556, Ref2 value 556

In contrast withvalue type the assignment to reference type variable ref2.val = 555,affects the object that both ref1 and ref2 reference.

From above we seethat value types and reference types are different. So to create a Generictype we need something which neither of them. In .net we have theroot type Object (alias System.Object)is special in that it is neither a reference type nor a value type, and may notbe instantiated. So a variable of type Objectcan either contain a value type or a reference type. Yes there is question,which arises in mind why Object class canhandle both?

The answer is bothreference and value types are derived from the base class Object.So using the concept Boxing and unboxing we can treat any typeas an object. So what does boxing do, So where its necessary for a value type tobehave like a object boxing is done which wrappers the value type to look like areference object (allocated on heap), and the value type?s value is copiedinto it. Then this complete wrapper is marked so that CLR knows that itcontains a value type. Similarly the reverse process is called as unboxing.

Let?s see a sample code using Objectclass as Generic type:

// objapp.cs<o:p></o:p>

usingSystem;

publicclass Myclass

{

  >public stringname="Hello from Myclass";

 public voiddoSomething()

 {

  Console.WriteLine(name);

 }

}

publicclass ObjApp{

 publicstatic void CheckType(object o)

  {

     if(o is string)

      {

        Console.WriteLine ("o isString");

        string s = (string)o;

        Console.WriteLine (s);

      }

      elseif (o is Int32[])

      {

        Console.WriteLine ("o is Int32array");

        Int32[] ins=(Int32[])o;

        for(Int32 i=0;i< ins.Length;i++)

        Console.WriteLine (ins[i]);

      }

      elseif (o is Myclass)

      {

        Console.WriteLine ("o isMyclass");

          Myclass a = (Myclass)o;

          a.doSomething();

        }

  }

  public staticvoid Main(){

      //Create an array of Object references

      Object[]objs = new Object[3];   

      objs[0]= "Some String";        // create a new string

      objs[1]= new Int32[]{1, 2, 4}; // create a new Int32 array

      objs[2]= new Myclass();         // create a newObject instance

      for(Int32ind = 0; ind < 3; ind++)

        {

        Console.WriteLine("Array index{0} refers to {1}",ind, objs[ind]);

        ObjApp.CheckType(objs[ind]);             

         }

 <o:p></o:p>

  }

}

 <o:p></o:p>

Output:

Arrayindex 0 refers to Some String

o isString

SomeString

Arrayindex 1 refers to System.Int32[]

o isInt32 array

1

2

4

Arrayindex 2 refers to Myclass

o isMyclass

Hellofrom Myclass

 <o:p></o:p>

 <o:p></o:p>

Inthe above program if you see Object classcan take any type and in CheckType memberfunction we are sending the generic type (Object)and using is operator we are checking thetype which is passed as parameter to the function , Then using Boxingwe can point to the specific type and use for further processing.

 <o:p></o:p>

 <o:p></o:p>

Furtherreading <o:p></o:p>

1. .Net  More information on .Net technologies

 Aboutthe Author: ChandraHundigam has Master degree is Computer Application, Working on MicrosoftTechnologies for past 5 years. Presently working as consultant for a US basedcompany. His area of interests is Emerging Technologies.