GenericAllows you to delay writing specifications for data types 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 specifications for classes or methods through alternative parameters to data types. When the compiler encounters a function call to a constructor or method of a class, it generates code to process the specified data type. The following simple example will help you understand this concept:
using System;
using ;
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)
{
// Declare an integer array MyGenericArray<int> intArray = new MyGenericArray<int>(5);
// Set value for (int c = 0; c < 5; c++)
{
(c, c*5);
}
// Get the value for (int c = 0; c < 5; c++)
{
((c) + " ");
}
();
// Declare an array of characters MyGenericArray<char> charArray = new MyGenericArray<char>(5);
// Set value for (int c = 0; c < 5; c++)
{
(c, (char)(c+97));
}
// Get the value for (int c = 0; c < 5; c++)
{
((c) + " ");
}
();
();
}
}
}
When the above code is compiled and executed, it produces the following results:
0 5 10 15 20
a b c d e
Generic features
Using generics is a technology that enhances program functions, which is specifically reflected in the following aspects:
- It helps you maximize code reuse, protect type security, and improve performance.
- You can create generic collection classes. The .NET framework class library contains some new generic collection classes in the namespace. You can use these generic collection classes instead of the collection classes in .
- You can create your own generic interfaces, generic classes, generic methods, generic events, and generic delegates.
- You can constrain generic classes to access methods of a specific data type.
- Information about the types used in generic data types can be obtained at runtime by using reflection.
Generic method
In the example above, we have used generic classes, and we can declare generic methods through type parameters. The following program illustrates this concept:
using System;
using ;
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';
// Show value before swap ("Int values before calling swap:");
("a = {0}, b = {1}", a, b);
("Char values before calling swap:");
("c = {0}, d = {1}", c, d);
// Call swap Swap<int>(ref a, ref b);
Swap<char>(ref c, ref d);
// Show value after swap ("Int values after calling swap:");
("a = {0}, b = {1}", a, b);
("Char values after calling swap:");
("c = {0}, d = {1}", c, d);
();
}
}
}
When the above code is compiled and executed, it produces the following results:
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 Delegation
You can define generic delegates through type parameters. For example:
delegate T NumberChanger<T>(T n);
The following example demonstrates the use of delegates:
using System;
using ;
delegate T NumberChanger<T>(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 a delegate instance NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
// Call method using delegate object nc1(25);
("Value of Num: {0}", getNum());
nc2(5);
("Value of Num: {0}", getNum());
();
}
}
}
When the above code is compiled and executed, it produces the following results:
Value of Num: 35
Value of Num: 175
The above is a detailed content of examples explaining C# generics. For more information about C# generics, please pay attention to my other related articles!