通过泛型，你重新获得了链接列表的代码通用(对于所有类型只用实现一次)，而当你初始化链表的时候你告诉链表所能接受的类型。这个实现是非常简单的，让我们重新回到Node类：

public class Node{  
    Object data;  
    ... 

注意到 data 的类型是Object，(在EmployeeNode中，它是Employee)。我们将把它变成一个泛型(通常，由一个大写的T代表)。我们同样定义Node类，表示它可以被泛型化，以接受一个T类型。

public class Node < T>{  
    T data;  
    ... 

读作：T类型的Node。T代表了当Node被初始化时，Node所接受的类型。T可以是Object，也可能是整型或者是Employee。这个在Node被初始化的时候才能确定。

注意：使用T作为标识只是一种约定俗成，你可以使用其他的字母组合来代替，比如这样：

public class Node < UnknownType>{  
    UnknownType data;  
    ... 

通过使用T作为未知类型，next字段(下一个结点的引用)必须被声明为T类型的Node(意思是说接受一个T类型的泛型化Node)。

    Node< T> next;

构造函数接受一个T类型的简单参数：

public Node(T data)  
{  
    this.data = data;  
    this.next = null;  
} 

Node 类的其余部分是很简单的，所有你需要使用Object的地方，你现在都需要使用T。LinkedList 类现在接受一个T类型的Node，而不是一个简单的Node作为头结点。

public class LinkedList< T>{  
    Node< T> headNode = null; 

再来一遍，转换是很直白的。任何地方你需要使用Object的，现在改做T，任何需要使用Node的地方，现在改做 Node< T>。下面的代码初始化了两个链接表。一个是整型的。

LinkedList< int> ll = new LinkedList< int>(); 

另一个是Employee类型的：

LinkedList< Employee> employees = new LinkedList< Employee>(); 

剩下的代码与***个版本没有区别，除了没有装箱、拆箱，而且也不可能将错误的类型保存到集合中。

LinkedList< int> ll = new LinkedList< int>();  
for ( int i = 0; i <  10; i ++ )  
{  
    ll.Add(i);  
}  
 
Console.WriteLine(ll);  
Console.WriteLine("  Done.");  
 
LinkedList< Employee> employees = new LinkedList< Employee>();  
employees.Add(new Employee("John"));  
employees.Add(new Employee("Paul"));  
employees.Add(new Employee("George"));  
employees.Add(new Employee("Ringo"));  
 
Console.WriteLine(employees);   
Console.WriteLine("  Done.");  
Console.WriteLine("The fourth integer is " + ll[3]);  
Employee d = employees[1];  
Console.WriteLine("The second Employee is " + d); 

泛型允许你不用复制/粘贴冗长的代码就实现类型安全的集合。而且，因为，使用泛型运行时才被扩展成特殊类型。Just In Time编译器可以在不同的实例之间共享代码，***，它显著地减少了你需要编写的代码。

这样，使用泛型就达到了代码重用的目的。

【编辑推荐】

1. C# winForm自定义鼠标样式的两种方法
2. C#自定义消息框的设置图解
3. 掌握C#自定义泛型类：从初始化说起
4. C#存储过程的循序渐进
5. 存储过程的优势及其调用方法介绍