Generics in C#
In my last article I focused on issues of typesafety and reusability when using ArrayLists.In this article we shall focus on how these issues of type safety andreusability are very nicely handled by Generics. All with the help ofcode again :
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:-
//List of Ints
List<int> myInts = new List<int>();
myInts.Add(5);
myInts.Add(10);
myInts.Add(20);
foreach (int x in myInts)
{
Console.WriteLine(x);
}
Console.ReadLine();
</int></int>
The above code snippet indicates that the sameList class can be used to contain any datatype at any point of time,without requiring any kind of extra effort from the programmer’s side.
The syntax for using any kind of Generic Class is as under :-
GenericClass<t> objT = new GenericClass<t>(); </t></t>
Where T is the datatype that’ want to list,and GenericClass is the Generic Class which will wrap our desireddatatype (that’s the reason ,”contains” ,above has been marked in thedouble quotes and is marked bold
. This Generic Class can be our owncustom Generic Class or the ones provided by the .Net Framework.
So technically, T gets replaced by thedatatype at compile type. And that’s the reaosn why a compile timeerror occurs when castinig is not done properly, it will be anInvalidCast Exception while using ArrayLists. Thus Generics enforcetype checking at complie time only, making life less difficult.
Performance is another area where Genericsmake it sweet when compared to ArrayLists. Since T is “replaced” by ourdatatype at comile time only so, no time and resources are wasted inboxing and unboxing the objects.
Thus Generics are a very powerful and nicefeature provided with .Net 2.0. Generics types are found sprinkledthroughout the .Net2.0 BCLs; however System.Collections.Genericsnamespace is chock full of them.












No comments yet... Be the first to leave a reply!