Generic Allows you to defer writing the specification of a data type for a programming element 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 of a class or method through substitution parameters of data types. When the compiler encounters a function call to a class's constructor or method, it generates code to handle the specified data type. The following simple example will help you understand this concept:
Example
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)
{
// 声明一个整型数组
MyGenericArray<int> intArray = new MyGenericArray<int>(5);
// 设置值
for (int c = 0; c < 5; c++)
{
intArray.setItem(c, c*5);
}
// 获取值
for (int c = 0; c < 5; c++)
{
Console.Write(intArray.getItem(c) + " ");
}
Console.WriteLine();
// 声明一个字符数组
MyGenericArray<char> charArray = new MyGenericArray<char>(5);
// 设置值
for (int c = 0; c < 5; c++)
{
charArray.setItem(c, (char)(c+97));
}
// 获取值
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 results:
0 5 10 15 20 a b c d e
Characteristics of Generics
Using generics is a technology that enhances program functionality, specifically in the following aspects:
- It helps you maximize code reuse, protect type safety, and improve performance.
- You can create a generic collection class. The .NET Framework class library includes new generic collection classes in the System.Collections.Generic namespace. You can use these generic collection classes in place of the collection classes in System.Collections .
- You can create your own generic interfaces, generic classes, generic methods, generic events, and generic delegates.
- You can constrain a generic class 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 above example, we have used generic classes and we can declare generic methods through type parameters. The following program illustrates this concept:
Example
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';
// 在交换之前显示值
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);
// 调用 swap
Swap<int>(ref a, ref b);
Swap<char>(ref c, ref d);
// 在交换之后显示值
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 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 delegate
You can define generic delegates via type parameters. For example:
delegate T NumberChanger<T>(T n);
The following example demonstrates the use of delegates:
Example
using System;
using System.Collections.Generic;
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)
{
// 创建委托实例
NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
// 使用委托对象调用方法
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 results:
Value of Num: 35 Value of Num: 175
2 notes Write notes
-
Don’t eat Zi Zi
gav***[email protected]
194
When declaring a generic method/generic class, you can add certain constraints to the generic type to meet some of our specific conditions.
for example:
using System; using System.Web.Caching; namespace Demo.CacheManager { public class CacheHelper<T> where T:new() { } }Generic qualification:
- T: structure (the type parameter must be a value type. Any value type other than Nullable can be specified)
- T: class (type parameters must be reference types, including any class, interface, delegate, or array type)
- T: new() (type parameters must have a parameterless public constructor. When used with other constraints the new() constraint must be specified last)
- T: <base class name> The type parameter must be the specified base class or derived from the specified base class
- T: <Interface name> The type parameter must be the specified interface or implement the specified interface. Multiple interface constraints can be specified. Constraint interfaces can also be generic.
- T：U
Don’t eat Zi Zi
gav***[email protected]
6 years ago (2018-01-17) -
Don’t eat Zi Zi
gav***[email protected]
89
When encapsulating public components, many times our classes/methods do not need to pay attention to "what" the entity passed by the caller is. In this case, generics can be used.
for example:
using System; using System.Web.Caching; namespace Xy.CacheManager { public class CacheHelper<T> { //获取缓存实体 public static T Get(Cache cache,string cacheKey) { //....缓存操作 } //插入缓存 public static void Set(Cache cache T tEntity,string cacheKey) { //....缓存操作 } } }