如何在C#中进行模板专业化

通过添加中间类和字典,可以实现专业化.

为了专注于T,我们创建了一个通用接口,有一个叫做(例如)Apply的方法.对于实现接口的特定类,定义特定于该类的方法.这个中间类称为traits类.

可以将traits类指定为泛型方法调用中的参数,然后(当然)总是采用正确的实现.

traits类也可以存储在全局中,而不是手动指定它IDictionary.它可以被抬起来瞧,你在那里有真正的专业.

如果方便,您可以使用扩展方法公开它.

class MyClass
{
    public string Foo() { return "MyClass"; }
}

interface BaseTraits
{
    string Apply(T cls);
}

class IntTraits : BaseTraits>
{
    public string Apply(MyClass cls)
    {
        return cls.Foo() + " i";
    }
}

class DoubleTraits : BaseTraits>
{
    public string Apply(MyClass cls)
    {
        return cls.Foo() + " d";
    }
}

// Somewhere in a (static) class:
public static IDictionary register;
register = new Dictionary();
register[typeof(MyClass)] = new IntTraits();
register[typeof(MyClass)] = new DoubleTraits();

public static string Bar(this T obj)
{
    BaseTraits traits = register[typeof(T)] as BaseTraits;
    return traits.Apply(obj);
}

var cls1 = new MyClass();
var cls2 = new MyClass();

string id = cls1.Bar();
string dd = cls2.Bar();

有关详细说明和示例,请参阅此链接到我最近的博客和后续内容.

我也在寻找模拟模板专业化的模式.有些方法可能在某些情况下有效.不过那个案子呢

static void Add(T value1, T value2)
{
    //add the 2 numeric values
}

可以使用语句选择动作,例如if (typeof(T) == typeof(int)).但是有一种更好的方法可以通过单个虚函数调用的开销来模拟真实的模板专业化:

public interface IMath
{
    T Add(T value1, T value2);
}

public class Math : IMath
{
    public static readonly IMath P = Math.P as IMath ?? new Math();

    //default implementation
    T IMath.Add(T value1, T value2)
    {
        throw new NotSupportedException();    
    }
}

class Math : IMath, IMath
{
    public static Math P = new Math();

    //specialized for int
    int IMath.Add(int value1, int value2)
    {
        return value1 + value2;
    }

    //specialized for double
    double IMath.Add(double value1, double value2)
    {
        return value1 + value2;
    }
}

现在我们可以写,而不必事先知道类型:

static T Add(T value1, T value2)
{
    return Math.P.Add(value1, value2);
}

private static void Main(string[] args)
{
    var result1 = Add(1, 2);
    var result2 = Add(1.5, 2.5);

    return;
}

如果不仅要为已实现的类型调用特化,而且还要为派生类型调用,可以使用In参数作为接口.但是,在这种情况下,方法的返回类型不能再是泛型类型T.

一些建议的答案是使用运行时类型信息:本质上比编译时绑定方法调用慢.

编译器不像C++那样强制实现专业化.

在推荐通常的编译器来实现类似于C++的效果之后,我建议在PostSharp中寻找一种注入代码的方法.

我认为有一种方法可以使用.NET 4+来实现动态分辨率：

static class Converter
{
    public static string Convert(T data)
    {
        return Convert((dynamic)data);
    }

    private static string Convert(Int16 data) => $"Int16 {data}";
    private static string Convert(UInt16 data) => $"UInt16 {data}";
    private static string Convert(Int32 data) => $"Int32 {data}";
    private static string Convert(UInt32 data) => $"UInt32 {data}";
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(Converter.Convert(-1));
        Console.WriteLine(Converter.Convert(1));
        Console.WriteLine(Converter.Convert(-1));
        Console.WriteLine(Converter.Convert(1));
    }
}

输出：

Int16 -1
UInt16 1
Int32 -1
UInt32 1

这表明为不同的类型调用了不同的实现。