c# 模板整数方法？

Question

是否可以为任何类型的整数大小制作模板方法？

为了说明，想象一下这个非常简单的例子(方法的主体在我的问题中并不重要):

public int Mul(int a, int b)    {
    return a*b;
}

现在，我想要支持任何类型整数的相同方法(当然不包括 BigInteger)。我必须编写所有变体:

public long Mul(long a, long b)    {
    return a*b;
}
public ulong Mul(ulong a, ulong b)    {
    return a*b;
}
public short Mul(short a, short b)    {
    return a*b;
}
public ushort Mul(ushort a, ushort b)    {
    return a*b;
}
public byte Mul(byte a, byte b)    {
    return a*b;
}

虽然这个例子非常简单而且复制起来实际上不是问题，但如果我有更复杂的算法，比如这样(复制所有整数类型):

    public static IEnumerable<long> GetPrimesFactors(this long number)
    {
        for (long i = 2; i <= number / 2; i++)
        {
            while (number % i == 0)
            {
                yield return i;
                number /= i;
            }
        }
        yield return number;
    }

它引入了维护风险，因为存在重复的代码和逻辑(编码集成商会说在多个地方使用相同的逻辑是邪恶的)。

你们中的一些人可能会建议实现长版本并转换结果，但是必须要求消费者代码转换可能会造成混淆并降低可读性:

void SomeMethod(IEnumerable<int> valuesToProcess)
{
    foreach(int value in valuesToProcess) { Console.WriteLine(value); }
}

void Main()
{
    int i = 42;
    SomeMethod(((long)i).GetPrimesFactors().Select(l=>(int)l)); 
    SomeMethod(GetPrimesFactors(i));

    long l = 42L;
    SomeMethod(l.GetPrimesFactors().Select(l=>(int)l));
}

当我看到接口(interface)的定义时IEnumerable<T> ，尤其是 Sum 的定义方法重载:

    public static decimal? Sum(this IEnumerable<decimal?> source);
    public static decimal Sum(this IEnumerable<decimal> source);
    public static double? Sum(this IEnumerable<double?> source);
    public static double Sum(this IEnumerable<double> source);
    public static float? Sum(this IEnumerable<float?> source);       
    public static float Sum(this IEnumerable<float> source);
    public static int? Sum(this IEnumerable<int?> source);
    public static int Sum(this IEnumerable<int> source);
    public static long? Sum(this IEnumerable<long?> source);
    public static long Sum(this IEnumerable<long> source);

我的结论是这是不可能的...这就是 MS 必须实现所有重载的原因。

有没有人有设计通用整数方法而无需复制逻辑的任何技巧？

Answer 1

没有干净的高性能解决方案。我能想到的选择是:

1. 手动复制代码(快速且冗余)
2. 使用代码生成器自动复制代码(速度快但有点丑)。一个 .net 数字库是这样的，但我不记得它的名字了。
3. 使用某种间接形式，例如 MiscUtil 的 Operator 类，或 DLR(慢)
4. 算术助手结构。我不确定性能有多好，但你可以试试。

表示运算符的通用方法:

这是我的第一个想法。问题是如何实现它们。 MiscUtil 通过调用存储在静态字段中的委托(delegate)来实现这一点。

static Func<T,T,T> _multiply;
public static T Multiply(T n1,T n2)
{
  return _multiply(n1, n2);
}

这里要注意的一点是，您应该避免使用静态构造函数，因为它的存在会减慢静态字段的访问速度。

但这涉及间接调用，而且成本很高。接下来，我尝试通过手动专门针对某些已知类型来改进这一点:

public static T Multiply(T n1,T n2)
{
  if(typeof(T)==typeof(int))
    return (T)(object)((int)(object)n1*(int)(object)n2);
  ...
  return _multiply(n1, n2);
}

JIT 编译器足够聪明，可以识别哪些 if 情况必须采用，并将它们删除。虽然这提高了性能，但它使方法的 IL 表示变得臃肿。现在 JIT 编译器还不够智能，无法内联这些方法，因为它们的 IL 表示很长，并且内联启发式只查看方法的 IL 长度，而不是其机器代码长度。我不记得这些转换是否会导致装箱，或者 JITter 是否足够聪明来优化它。仍然缺乏内联的成本太高。

4) 的工作原理:

首先创建一个接口(interface)，其中包含您需要的基本操作(算术运算符，...):

interface IArithmetic<T>
{
   T Multiply(T n1,T n2);
}

使用结构为您需要的每种类型实现它:

public struct Int32Arithmetic:IArithmetic<Int32>
{
   Int32 Multiply(Int32 n1,Int32 n2)
   {
     return n1*n2;
   }
}

然后使大部分实际代码通用，并传入算术助手:

internal T MyOperation<T,TArithmetic>(T n1, T n2)
  where TArithmetic:struct,IArithmetic<T>
{
   return default(TArithmetic).Multiply(n1,n2);
}

如果您想要一个用于多种类型的干净接口(interface)，请创建一个转发到通用方法的精简重载包装器:

public Int32 MyOperation(Int32 n1,Int32 n2)
{
  return MyOperation<Int32,Int32Arithmetic>(n1, n2);
}

这可能很快，因为泛型会专门针对每种值类型。它不使用间接寻址，并且 IL 中的方法主体不会太长，因此内联是可能的。但我自己还没有尝试过。