YouTipCsharp Generic
****
**Content:**
**Generics** allow you to delay the specification of the data type of programming elements in a class or 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 can write the specification for a class or method using a placeholder parameter for the data type. When the compiler encounters the constructor for the class or the function call for the method, it generates code to handle the specified data type. The following simple example will help you understand this concept:
## Example
```csharp
using System;
using System.Collections.Generic;
namespace GenericApplication
{
public class MyGenericArray
{
private T[] array;
public MyGenericArray(int size)
{
array = new T[size + 1];
}
public T getItem(int index)
{
return array;
}
public void setItem(int index, T value)
{
array = value;
}
}
class Tester
{
static void Main(string[] args)
{
// Declare an integer array
MyGenericArray intArray = new MyGenericArray(5);
// Set values
for (int c = 0; c < 5; c++)
{
intArray.setItem(c, c * 5);
}
// Get values
for (int c = 0; c < 5; c++)
{
Console.Write(intArray.getItem(c) + " ");
}
Console.WriteLine();
// Declare a character array
MyGenericArray charArray = new MyGenericArray(5);
// Set values
for (int c = 0; c < 5; c++)
{
charArray.setItem(c, (char)(c + 97));
}
// Get 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 a b c d e
Using generics is a technique that enhances program functionality, specifically in the following ways:
* It helps you maximize code reuse, protect type safety, and improve 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 can use these generic collection classes to replace the collection classes in _System.Collections_.
* You can create your own generic interfaces, generic classes, generic methods, generic events, and generic delegates.
* You can apply constraints to generic classes to access methods of specific data types.
* Information about the types used in generic data types can be obtained at runtime using reflection.
In the above example, we have used a generic class. We can declare generic methods using type parameters. The following program illustrates this concept:
## Example
```csharp
using System;
using System.Collections.Generic;
namespace GenericMethodAppl
{
class Program
{
static void Swap(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 calling the 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(ref a, ref b);
Swap(ref c, ref d);
// Display values after calling the 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();
}
}
}
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
You can define generic delegates using type parameters. For example:
```csharp
delegate T NumberChanger(T n);
The following example demonstrates the use of delegates:
## Example
```csharp
using System;
using System.Collections.Generic;
delegate T NumberChanger(T n);
namespace GenericDelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
// Create delegate instances
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
// Use delegate object to call methods
nc1(25);
Console.WriteLine("Value of Num: {0}", getNum());
nc2(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
When the above code is compiled and executed, it produces the following result:
Value of Num: 35
Value of Num: 175