C#泛型实战：从零构建类型安全的线性链表

public class Employee {
    private string name;
    public Employee(string name) {
        this.name = name;
    }
    public override string ToString() {
        return this.name;
    }
}

// 非泛型节点类
public class Node {
    object data;       // 存储数据的字段
    Node next;         // 指向下一个节点的引用

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

    // 属性访问器
    public object Data {
        get { return this.data; }
        set { data = value; }
    }

    public Node Next {
        get { return this.next; }
        set { this.next = value; }
    }

    /// <summary>
    /// 将新节点追加到链表尾部
    /// </summary>
    public void Append(Node newNode) {
        if (this.next == null) {
            this.next = newNode;
        } else {
            // 递归调用直到找到末尾
            next.Append(newNode);
        }
    }

    /// <summary>
    /// 递归输出链表所有节点内容
    /// </summary>
    public override string ToString() {
        string output = data.ToString();
        if (next != null) {
            output += ", " + next.ToString();
        }
        return output;
    }
}

public class LinkedList {
    Node headNode = null;

    // 添加数据到链表
    public void Add(object data) {
        if (headNode == null) {
            headNode = new Node(data);
        } else {
            headNode.Append(new Node(data));
        }
    }

    // 索引器：允许像数组一样访问元素
    public object this[int index] {
        get {
            int ctr = 0;
            Node node = headNode;
            while (node != null && ctr <= index) {
                if (ctr == index) {
                    return node.Data;
                } else {
                    node = node.Next;
                }
                ctr++;
            }
            return null;
        }
    }

    public override string ToString() {
        if (this.headNode != null) {
            return this.headNode.ToString();
        } else {
            return string.Empty;
        }
    }
}

public void Run() {
    LinkedList ll = new LinkedList();
    
    // 存入整型 -> 触发隐式装箱 (Boxing)
    for (int i = 0; i < 10; i++) {
        ll.Add(i); 
    }
    
    Console.WriteLine(ll);
    Console.WriteLine(" Done. Adding employees...");
    
    // 存入对象
    ll.Add(new Employee("John"));
    ll.Add(new Employee("Paul"));
    // ... 其他员工
    
    // 取回数据 -> 必须显式拆箱 (Unboxing) 和类型转换
    Console.WriteLine("The fourth integer is " + Convert.ToInt32(ll[3]));
    Employee d = (Employee)ll[11]; // 若此处取出的是int，程序将崩溃
    Console.WriteLine("The second Employee is " + d);
}

// T 代表具体的类型，如 int 或 Employee
public class Node<T> {
    T data;      // 现在直接保存 T 类型，无需装箱
    Node<T> next; // 下一个节点也是泛型化的

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

    public T Data {
        get { return this.data; }
        set { data = value; }
    }

    public Node<T> Next {
        get { return this.next; }
        set { this.next = value; }
    }

    public void Append(Node<T> newNode) {
        if (this.next == null) {
            this.next = newNode;
        } else {
            next.Append(newNode);
        }
    }

    public override string ToString() {
        string output = data.ToString();
        if (next != null) {
            output += ", " + next.ToString();
        }
        return output;
    }
}

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

    public void Add(T data) {
        if (headNode == null) {
            headNode = new Node<T>(data);
        } else {
            headNode.Append(new Node<T>(data));
        }
    }

    public T this[int index] {
        get {
            int ctr = 0;
            Node<T> node = headNode;
            while (node != null && ctr <= index) {
                if (ctr == index) {
                    return node.Data;
                } else {
                    node = node.Next;
                }
                ctr++;
            }
            return default(T); // 更安全地处理越界
        }
    }

    public override string ToString() {
        if (this.headNode != null) {
            return this.headNode.ToString();
        } else {
            return string.Empty;
        }
    }
}

// 声明一个整数链表，自动绑定类型为 int
LinkedList<int> ll = new LinkedList<int>();
for (int i = 0; i < 10; i++) {
    ll.Add(i); // 无装箱行为，直接赋值
}
Console.WriteLine(ll);

// 声明一个员工链表，自动绑定类型为 Employee
LinkedList<Employee> employees = new LinkedList<Employee>();
employees.Add(new Employee("John"));
employees.Add(new Employee("Paul"));

Console.WriteLine(employees);

// 取值时无需转换，且无法添加错误类型
// 下面这行代码如果取消注释，将在编译阶段报错！
// employees.Add(5); 

Employee d = employees[1]; // 强类型返回，智能提示友好
Console.WriteLine("The second Employee is " + d);