一、泛型方法的特化

使用一个非泛型 helper 类和一个内嵌的泛型类可以实现对泛型方法的特化。

    internal static class IndexerImpl //non-generic static helper class
    {
        private static T IndexerDefaultImpl<T>(int i) => default(T); //default implementation

        private static T IndexerImpl2<T>(int i) => default(T); //another implementation for short/int/long

        private static string IndexerForString(int i) => (i * i).ToString(); //specialization for T=string
        private static DateTime IndexerForDateTime(int i) => new DateTime(i * i * i); //specialization for T=DateTime

        static IndexerImpl() //install the specializations
        {
            Specializer<string>.Fun = IndexerForString;
            Specializer<DateTime>.Fun = IndexerForDateTime;

            Specializer<short>.Fun = IndexerImpl2<short>;
            Specializer<int>.Fun = IndexerImpl2<int>;
            Specializer<long>.Fun = IndexerImpl2<long>;
        }

        internal static class Specializer<T> //specialization dispatcher
        {
            internal static Func<int, T> Fun;
            internal static T Call(int i)
                => null != Fun
                    ? Fun(i)
                    : IndexerDefaultImpl<T>(i);
        }
    }

    public class YourClass<T>
    {
        public T this[int i] => IndexerImpl.Specializer<T>.Call(i);
    }

如果需要传入实例对返回结果进行计算，可以增加一个参数：

    internal static class IndexerImpl //non-generic static helper class
    {
        private static T IndexerDefaultImpl<T>(int i, YourClass<T> yourClass) => default(T); //default implementation

        private static T IndexerImpl2<T>(int i, YourClass<T> yourClass) => default(T); //another implementation for short/int/long

        private static string IndexerForString<T>(int i, YourClass<T> yourClass) => (i * i).ToString(); //specialization for T=string
        private static DateTime IndexerForDateTime<T>(int i, YourClass<T> yourClass) => new DateTime(i * i * i); //specialization for T=DateTime

        static IndexerImpl() //install the specializations
        {
            Specializer<string>.Fun = IndexerForString;
            Specializer<DateTime>.Fun = IndexerForDateTime;

            Specializer<short>.Fun = IndexerImpl2;
            Specializer<int>.Fun = IndexerImpl2;
            Specializer<long>.Fun = IndexerImpl2;
        }

        internal static class Specializer<T> //specialization dispatcher
        {
            internal static Func<int, YourClass<T>, T> Fun;
            internal static T Call(int i, YourClass<T> yourClass)
                => null != Fun
                    ? Fun(i, yourClass)
                    : IndexerDefaultImpl(i, yourClass);
        }
    }

    public class YourClass<T>
    {
        public T this[int i] => IndexerImpl.Specializer<T>.Call(i, this);
    }

二、泛型方法的偏特化

偏特化也是差不多的做法，只不过帮助类变成了以不需要特化的类型构成的泛型类：

    internal static class GetValueImpl<R, S>
    {
        private static T DefImpl<T>(R r, S s) => default(T);
        private static int IntRet(R r, S s) => int.MaxValue;

        internal static class Specializer<T>
        {
            internal static Func<R, S, T> Fun;
            internal static T Call(R r, S s) => null != Fun ? Fun(r, s) : DefImpl<T>(r, s);
        }

        static GetValueImpl()
        {
            Specializer<int>.Fun = IntRet;
        }
    }

    public class TestClass
    {
        public T GetValue<R, S, T>(R r, S s) => GetValueImpl<R, S>.Specializer<T>.Call(r, s);
    }

以上代码片段中，被偏特化的是 GetValue 方法中的 T 类型参数，当 T=int 的时候，实际被调用的方法就是 GetValueImpl.IntRet 方法，其他情况是 GetValueImpl.DefImpl 方法。