More Effective C# Item3 : 运行时检查泛型参数的类型并提供特定的算法

    我感觉这一条目应该算是对Item2的补充，还是在“约束”的条件下，如何使得程序得到最优化的结果，颇有“带着脚铐跳芭蕾”的意味。Item2中的条目可以看做是在有约束的情况下，对泛型类外部的影响；本条目可以看做是对泛型内部的影响。

    通常情况下，.NET框架，或者我们自身针对不同项目制定的框架，都会包含一系列的接口或者基类，接口或者基类之间，会有继承的关系，形成一个系统的骨架，在此基础上根据具体的业务，对框架进行填充，使得最终的系统才会有血有肉。

    在设计泛型类时，如果指定的“约束”是很宽泛的“约束”，即从类型层次结构上来看，“约束”指定的类型包含了子类型。那么可以在编写泛型方法时，对泛型参数的类型进行判断，如果该参数的类型属于某一种特定的类型（这里的特定类型一定会是泛型类型的子类型），那么就可以调用特定类型的方法，从而可以充分利用子类型的特点。

    我们还是使用《More Effective C#》中提供的示例进行说明吧，来看下面的代码。

public sealed class ReserseEnumerable<T> : IEnumerable<T>
{
    private class ReserseEnumerator : IEnumerator<T>
    {
        int currentIndex;
        IList<T> collection;
        public ReserseEnumerator(IList<T> srcCollection)
        {
            collection = srcCollection;
            currentIndex = collection.Count;
        }

        #region IEnumerator<T> Members

        public T Current
        {
            get { return collection[currentIndex]; }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            
        }

        #endregion

        #region IEnumerator Members

        object IEnumerator.Current
        {
            get { return this.Current; }
        }

        public bool MoveNext()
        {
            return --currentIndex >= 0;
        }

        public void Reset()
        {
            currentIndex = collection.Count;
        }

        #endregion
    }

    IEnumerable<T> sourceSequence;
    public IList<T> originalSequence;

    public ReserseEnumerable(IEnumerable<T> sequence)
    {
        sourceSequence = sequence;
    }
    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()
    {
        if (originalSequence == null)
        {
            originalSequence = new List<T>();
            foreach (T item in sourceSequence)
            {
                originalSequence.Add(item);
            }
        }
        return new ReserseEnumerator(originalSequence);
    }

    #endregion

    #region IEnumerable Members

    IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    #endregion
}

    上述代码实现了一个对列表进行反转的功能，它指定的“约束”是比较宽泛的，在代码中，并没有对泛型参数的类型再做进一步的判断和处理。

    这里有必要说明一点，上面的代码是没有错误的，对于使用者来说，它从最大程度上开放了“约束”。但是在内部实现方面，我们还可以做以下优化，来看一下IReserseEnumerable<T>的构造函数，我们可以对其进行以下改动。

public ReverseEnumerable(IEnumerable<T> sequence)
{
    sourceSequence = sequence;
    // If sequence doesn't implement IList<T>,
    // originalSequence is null, so this works
    // fine.
    originalSequence = sequence as IList<T>;
}

public ReverseEnumerable(IList<T> sequence)
{
    sourceSequence = sequence;
    originalSequence = sequence;
}

    对于GetEnumerator<T>方法来说，我们可以对其进行以下改动。

public IEnumerator<T> GetEnumerator()
{
    // Create a copy of the original sequence,
    // so it can be reversed.
    if (originalSequence == null)
    {
        if (sourceSequence is ICollection<T>)
        {
            ICollection<T> source = sourceSequence
               as ICollection<T>;
            originalSequence = new List<T>(source.Count);
        }
        else
            originalSequence = new List<T>();
        foreach (T item in sourceSequence)
            originalSequence.Add(item);
    }
    return new ReverseEnumerator(originalSequence);
}

    总结：我们可以在泛型约束的范围内，通过对泛型参数的类型进行判断和处理，这样在照顾到重用性的同时，也可以尽可能的提高程序的性能。