More Effective C# Item1 : 使用1.x框架API的泛型版本

    .NET平台前两个版本不支持泛型，因此，在程序中只能基于System.Object进行编码，然后通过必要的运行时检查保证程序的正确性。

    这样做是没有错的，毕竟System.Object是所有类型的基类，在程序中可以在任何时候任何地方使用System.Object传递参数，但是我们在程序中，一般会调用某些指定类型的方法，而这些方法并不会定义在System.Object中，这也就是说我们要对类型进行转换，将Object转换成某种我们期望的类型，然后才可以调用期望类型中的方法。

    在引入泛型后，之所以不再推荐上述的做法，有以下两个原因：

1. 程序的健壮性和可维护性。如果大部分的方法参数传递的都是System.Object，那么不可避免要进行类型转换，如果有类型转换，因为类型转换是否正确，并不会编译时进行检查，那么我们必须在代码中添加大量对转换异常的处理，或者说对运行时对象类型的检查。这样的代码，一方面在很多时候都是重复的，另一方面很容易有遗漏，造成程序运行时错误。
2. 程序的性能。在类型转换的过程中，不可避免会有拆箱和装箱的过程，如果进行类型转换的很频繁，那么会对程序的性能造成很大的影响。

    在.NET 2.0引入泛型后，上述两个问题在一定程度上得到了解决，使用泛型，可以在编译时对类型进行检查，如果传递的参数不符合泛型的约束，那么编译就不会通过，这样可以提前发现问题；另一方面，使用泛型，没有了装箱和拆箱的操作，对提高程序的性能也有一定的帮助。

    如果想学习泛型，那么从对泛型“传统”的认识开始是一个不错的选择，所谓“传统”，就是指集合类。泛型在涉及到集合的存储和操作过程中，有很大的发挥空间，为此，.NET框架专门建立了一个新的命名空间，即System.Collections.Generics。

    我们首先来看一下之前弱类型框架中的情况，即System.Collections，为了保证兼容性，.NET 2.0保留了之前非泛型的类型说明。

    System.Collections命名空间中的类说明如下。

•   ArrayList  使用大小可按需动态增加的数组实现 IList 接口。
•  BitArray  管理位值的压缩数组，该值表示为布尔值，其中 true 表示位是打开的 (1)，false 表示位是关闭的 (0)。
•  CaseInsensitiveComparer  比较两个对象是否相等，比较时忽略字符串的大小写。
•  CaseInsensitiveHashCodeProvider  已过时。使用忽略字符串大小写的哈希算法，为对象提供哈希代码。
•  CollectionBase  为强类型集合提供 abstract 基类。
•  Comparer  比较两个对象是否相等，其中字符串比较是区分大小写的。
•  DictionaryBase  为键/值对的强类型集合提供 abstract 基类。
•  Hashtable  表示键/值对的集合，这些键/值对根据键的哈希代码进行组织。
•  Queue  表示对象的先进先出集合。
•  ReadOnlyCollectionBase  为强类型非泛型只读集合提供 abstract 基类。
•  SortedList  表示键/值对的集合，这些键值对按键排序并可按照键和索引访问。
•  Stack  表示对象的简单的后进先出非泛型集合。

    System.Collections命名空间中的接口说明如下。

•  ICollection  定义所有非泛型集合的大小、枚举数和同步方法。
•  IComparer  公开一种比较两个对象的方法。
•  IDictionary  表示键/值对的非通用集合。
•  IDictionaryEnumerator  枚举非泛型字典的元素。
•  IEnumerable  公开枚举数，该枚举数支持在非泛型集合上进行简单迭代。
•  IEnumerator  支持对非泛型集合的简单迭代。
•  IEqualityComparer  定义方法以支持对象的相等比较。
•  IHashCodeProvider  已过时。使用自定义哈希函数为对象提供哈希代码。
•  IList  表示可按照索引单独访问的对象的非泛型集合。

    .NET 2.0中，在System.Collections.Generics命名空间中，针对上述类和接口，基本上都提供了泛型的版本，我们来看一下。

    System.Collections.Generics命名空间中的类说明如下。

•  Comparer< T>  为 IComparer<  T  >  泛型接口的实现提供基类。
•  Dictionary<  TKey, TValue>  表示键和值的集合。
•  Dictionary<  TKey, TValue>.KeyCollection   表示 Dictionary<(Of <(TKey, TValue>)>) 中键的集合。无法继承此类。
• Dictionary<TKey, TValue>.ValueCollection  表示 Dictionary<(Of <(TKey, TValue>)>) 中值的集合。无法继承此类。
• EqualityComparer<T>  为 IEqualityComparer<(Of <(T>)>) 泛型接口的实现提供基类。
• HashSet<T>  表示值的集。
  
• KeyedByTypeCollection<TItem>  提供一个集合，该集合的项是用作键的类型。
• KeyNotFoundException  指定用于访问集合中元素的键与集合中的任何键都不匹配时所引发的异常。
• LinkedList<T>  表示双向链表。
  
• LinkedListNode<T>  表示 LinkedList<(Of <(T>)>) 中的节点。无法继承此类。
• List<T>  表示可通过索引访问的对象的强类型列表。提供用于对列表进行搜索、排序和操作的方法。
• Queue<T>  表示对象的先进先出集合。
• SortedDictionary<TKey, TValue>  表示按键排序的键/值对的集合。
• SortedDictionary<TKey, TValue>.KeyCollection  表示 SortedDictionary<TKey, TValue> 中键的集合。无法继承此类。
• SortedDictionary<TKey, TValue>.ValueCollection  表示 SortedDictionary<TKey, TValue> 中值的集合。无法继承此类
• SortedList<TKey, TValue>  表示键/值对的集合，这些键/值对基于关联的 IComparer<T> 实现按照键进行排序。
• Stack<T>  表示同一任意类型的实例的大小可变的后进先出 (LIFO) 集合。
• SynchronizedCollection<T>  提供一个线程安全集合，其中包含泛型参数所指定类型的对象作为元素。
• SynchronizedKeyedCollection<(K, T>  提供一个线程安全集合，该集合所含对象的类型由一个泛型参数指定，并且集合根据键进行分组。
• SynchronizedReadOnlyCollection<T>  提供一个线程安全只读集合，该集合包含泛型参数所指定的类型的对象作为元素。

    System.Collections.Generics命名空间中的接口说明如下。

• ICollection<T>  定义操作泛型集合的方法。
• IComparer<T>  定义类型为比较两个对象而实现的方法。
• IDictionary<TKey, TValue>  表示键/值对的泛型集合。
• IEnumerable<T>  公开枚举数，该枚举数支持在指定类型的集合上进行简单迭代。
• IEnumerator<T>  支持在泛型集合上进行简单迭代。
• IEqualityComparer<T>  定义方法以支持对象的相等比较。
• IList<T>  表示可按照索引单独访问的一组对象。

    上述类和接口的说明都来自MSDN，可以点击进入每一个类型中进行详细查看。

    接下来，我们看一下System命名空间新添加的一个接口，IEqutable<T>，该接口的声明如下。

public interface IEquatable<T>
{
    bool Equals(T other);
}

    如果我们需要在定义类型时，重写Object的Equals方法，那么最好事先这个接口，来看以下的代码。

internal class Employee : IEquatable<Employee>
{
    private string m_strEmpName;
    internal string EmpName
    {
        get { return m_strEmpName; }
        set { m_strEmpName = value; }
    }

    private string m_strAddress;
    public string Address
    {
        get { return m_strAddress; }
        set { m_strAddress = value; }
    }

    /// <summary>
    /// IEqutable interface
    /// </summary>
    /// <param name="other"></param>
    /// <returns></returns>
    public bool Equals(Employee other)
    {
        return this.EmpName.Equals(other.EmpName) && this.Address.Equals(other.Address);
    }

    /// <summary>
    /// override object's equals method.
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public override bool Equals(object obj)
    {
        if (obj == null)
        {
            return false;
        }
        if (object.ReferenceEquals(this, obj))
        {
            return true;
        }
        if (this.GetType() != obj.GetType())
        {
            return false;
        }
        return Equals(obj as Employee);
    }
}

    上述代码中，如果我们在调用Equals方法时，传入的参数类型是Employee，那么会非常简化执行的过程。

    如果我们需要对定义在其他类库中的类型进行比较，那么我们还可以使用System.Collections.Generics命名空间中的IEqulityComparer<T>接口，该接口的声明如下。

public interface IEqualityComparer<T>
{
    int Equals( T x, T y);
    int GetHashCode(T obj);
}

    一般情况下，我们不需要直接实现IEqulityComparer<T>接口，而是使用EqulityComparer<T>类的Default属性，但是在有些情况下，还是需要实现该接口（因为.NET是单继承，有时不应该把这一次宝贵的继承机会放在这里）。

    来看下面的代码，演示了如何使用Default属性。

internal class EmployeeComparer : EqualityComparer<Employee>
{
    public override bool Equals(Employee x, Employee y)
    {
        return EqualityComparer<Employee>.Default.Equals(x, y);
    }

    public override int GetHashCode(Employee obj)
    {
        return EqualityComparer<Employee>.Default.GetHashCode(obj);
    }
}

    上述示例告诉我们，越是基础的算法，可能越需要一个泛型类型定义，例如Equals方法，利用编译时类型检查，我们可以大大减少代码量，并可以提高程序的性能。

    下面我们来看一下System.Collections.Generics命名空间中的IComparable<T>接口，该接口的声明如下。

public interface IComparable<T>
{
    int CompareTo(T other);
}

    和旧版本IComparable接口相比，新接口中直接将参数类型进行了转换，我们来看下面的代码。

#region IComparable Members

public int CompareTo(object obj)
{
    if (!(obj is Employee))
    {
        throw new ArgumentException("obj is not Employee!");
    }
    Employee temp = obj as Employee;
    return this.EmpName.CompareTo(temp.EmpName);
}

#endregion

#region IComparable<Employee> Members

public int CompareTo(Employee other)
{
    return this.EmpName.CompareTo(other.EmpName);
}

#endregion

    上述代码让Employee类分别实现了IComparable接口和IComparable<T>接口，可以看出，带有泛型的接口，非常简洁，并且不会抛出任何运行时异常。

    在引入了泛型后，并不是之前非泛型的接口就没有用武之地了，有些情况下，还是需要使用非泛型的版本，例如当我们在进行比较时，如果是我们创建的类型之间进行比较，那么可以使用泛型版本的比较方式，但是如果需要使用我们创建的类型和第三方提供的类型进行比较，那么这时，就只能使用非泛型版本的比较方式了。

    .NET框架同时也添加了一些泛型的委托，用来实现一些常见的模式。

    例如我们向Employee类中添加一个名为OutputInfo的方法，用于输出员工信息，然后针对一个Employee类型的List，需要输出List中所有元素的信息。

    首先来看第一种实现方式。

private static void TestEnum(List<Employee> lstEmp)
{
    foreach (Employee emp in lstEmp)
    {
        emp.OutputInfo();
    }
}

    然后看一下如何使用泛型方式来实现。

private static void TestEnumWithDelegate<T>(List<T> lstEmp, Action<T> doIt)
{
    foreach (T temp in lstEmp)
    {
        doIt(temp);
    }
}

private static void Output(Employee emp)
{
    emp.OutputInfo();
}

    上述代码编写了两个方法，我们来看一下上述两种方式应该如何调用，如下。

List<Employee> lstEmp = new List<Employee>();
lstEmp.Add(new Employee("Wing", "BeiJing"));
lstEmp.Add(new Employee("UnKnown", "Moon"));
TestEnum(lstEmp);
TestEnumWithDelegate<Employee>(lstEmp, Output);

    当我们需要对List<T>进行排序时，我们可以指定排序的方式，List<T>的Sort方法添加了一个重载的形式，它以Comparsion<T>类型的代理作为参数，我们来看下面的代码。

private static void SortList(List<Employee> lstEmp)
{
    lstEmp.Sort( delegate(Employee x, Employee y){return x.EmpName.CompareTo(y.EmpName);});
}

    上述代码就是通过使用匿名代理的方式，实现了List排序的方式。

    总结：通过上面的描述，我们可以看到泛型给我们带来了很多的便利，它也会让我们改变很多之前的编程习惯。通过泛型，你可以使得组件更加容易使用，同时还可以避免很多错误，很多类型检查可以放在编译时进行，这样可以使得代码非常清晰。而使用内建的泛型委托定义，我们可以使用C#最新版本的一些增强特性。越早将非泛型代码切换到泛型版本，你就能够越早的享受到它带来的便利。