Generics are the most powerful feature of C# 2.0.

Generics allow you to define type-safe data

structures, without committing to actual data types. This results in a significant performance
boost and higher quality code, because you get to reuse data processing algorithms without
duplicating type-specific code.
Generics allow you to delay the specification of the data type of programming elements in a class or a
method, until it is actually used in the program. In other words, generics allow you to write a class or method
that can work with any data type.
You write the specifications for the class or the method, with substitute parameters for data types. When the
compiler encounters a constructor for the class or a function call for the method, it generates code to handle
the specific data type. A simple example would help understanding the concept:
using System;
using System.Collections.Generic;

namespace GenericApplication
{
public class MyGenericArray<T>
{
private T[] array;
public MyGenericArray(int size)
{
array = new T[size + 1];
}

public T getItem(int index)

{
return array[index];
}

public void setItem(int index, T value)

{
array[index] = value;
}
}

class Tester
{
static void Main(string[] args)
{

//declaring an int array

MyGenericArray<int> intArray = new MyGenericArray<int>(5);

//setting values
for (int c = 0; c < 5; c++)
{
intArray.setItem(c, c*5);
}

//retrieving the values

for (int c = 0; c < 5; c++)
{
Console.Write(intArray.getItem(c) + " ");
}

Console.WriteLine();

//declaring a character array

MyGenericArray<char> charArray = new MyGenericArray<char>(5);

//setting values
for (int c = 0; c < 5; c++)
{
charArray.setItem(c, (char)(c+97));
}

//retrieving the values

for (int c = 0; c< 5; c++)
{
Console.Write(charArray.getItem(c) + " ");
}
Console.WriteLine();

Console.ReadKey();
}
}
}

When the above code is compiled and executed, it produces the following result:
0 5 10 15 20
abcde

Generics is a technique that enriches your programs in the following ways:

It helps you to maximize code reuse, type safety, and performance.

You can create generic collection classes. The .NET Framework class library contains several new
generic collection classes in the System.Collections.Generic namespace. You may use these
generic collection classes instead of the collection classes in the System.Collections namespace.

You can create your own generic interfaces, classes, methods, events, and delegates.

You may create generic classes constrained to enable access to methods on particular data types.

You may get information on the types used in a generic data type at run-time by means of
reflection.

Generic Methods

In the previous example, we have used a generic class; we can declare a generic method with a type
parameter. The following program illustrates the concept:

using System;
using System.Collections.Generic;

namespace GenericMethodAppl
{
class Program
{
static void Swap<T>(ref T lhs, ref T rhs)
{
T temp;
temp = lhs;
lhs = rhs;
rhs = temp;
}
static void Main(string[] args)
{
int a, b;
char c, d;
a = 10;
b = 20;
c = 'I';
d = 'V';
//display values before swap:
Console.WriteLine("Int values before calling swap:");
Console.WriteLine("a = {0}, b = {1}", a, b);
Console.WriteLine("Char values before calling swap:");
Console.WriteLine("c = {0}, d = {1}", c, d);
//call swap
Swap<int>(ref a, ref b);
Swap<char>(ref c, ref d);

When the above code is compiled and executed, it produces the following result:

Int values before calling swap:

a = 10, b = 20

Char values before calling swap:

c = I, d = V

Int values after calling swap:

a = 20, b = 10

Char values after calling swap:

c = V, d = I

Generic Classes

//display values after swap:

Console.WriteLine("Int values after calling swap:");
Console.WriteLine("a = {0}, b = {1}", a, b);
Console.WriteLine("Char values after calling swap:");
Console.WriteLine("c = {0}, d = {1}", c, d);
Console.ReadKey();
}
}

The Generic class can be defined by putting the <T> sign after the class name. It
isn't mandatory to put the "T" word in the Generic type definition. You can use any
word in the TestClass<> class declaration.
public class TestClass<T> { }
The System.Collection.Generic namespace also defines a number of classes that
implement many of these key interfaces. The following table describes the core class
types of this namespace.
Non-Generics
Members

Description

Collection<T>

The basis for a generic collection Comparer compares two generic

objects for equality

Dictionary<TKey,
TValue>

A generic collection of name/value pairs

List<T>

A dynamically resizable list of Items

Queue<T>

A generic implementation of a first-in, first-out (FIFO) list

Stack<T>

A generic implementation of a last-in, first-out (LIFO) list

Simple Example of Dictionary

The following example demonstrates simple dictionary collections using Generics. In this
program, a Dictionary type object is created that accepts an int as the key and a string as
the value. Then we add some string values into the dictionary collection and finally
displaying the dictionary collection elements.
Using System;
using System.Collections.Generic;
namespace GenericApp
{
public class Program
{
static void Main(string[] args)
{
//define Dictionary collection
Dictionary<int,string> dObj = new Dictionary<int,string>(5);
//add elements to Dictionary
dObj.Add(1,1,"Tom");
dObj.Add(2,"John");
dObj.Add(3, "Maria");
dObj.Add(4, "Max");
dObj.Add(5, "Ram");
//print data
for (int i = 1; i <= dObj.Count;i++)
{
Console.WriteLine(dObj[i]);
}
Console.ReadKey();
}
}
}

array of delegates:
using System;
public class MathOperations
{
public static double MultiplyByTwo(double value)
{
return value * 2;
}
public static double Square(double value)
{
return value * value;
}

using System;
delegate double DoubleOp(double x);
class Application
{
static void Main()
{
DoubleOp[] operations =
{
MathOperations.MultiplyByTwo,
MathOperations.Square
};
for (int i = 0; i < operations.Length; i++)
{
Console.WriteLine("Using operations[{0}]:", i);
ProcessAndDisplayNumber(operations[i], 2.0);
ProcessAndDisplayNumber(operations[i], 7.94);
ProcessAndDisplayNumber(operations[i], 1.414);
Console.WriteLine();
}
}
static void ProcessAndDisplayNumber(DoubleOp action, double value)
{
double result = action(value);
Console.WriteLine(
"Value is {0}, result of operation is {1}", value, result);
}
}
Output:
Hide Copy Code

Using operations[0]:
Value is 2, result of operation is 4
Value is 7.94, result of operation is 15.88
Value is 1.414, result of operation is 2.828

Using operations[1]:
Value is 2, result of operation is 4
Value is 7.94, result of operation is 63.0436
Value is 1.414, result of operation is 1.999396