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));
}

当我看到接口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

考虑DLR：

    static void Main(string[] args)
    {
        int i = Mul(2, 4);
        Console.WriteLine(i);
        Console.Read();
    }

    static dynamic Mul(dynamic x, dynamic y)
    {
        return x * y;
    }

性能待定（我希望它比直接过载慢），但可读性要好得多。如果您提供的类型没有实现所需的运算符或导致值被截断的不同类型，可能会有点毛茸茸。

从评论更新： 如果性能如此重要，那么听起来您已经选择了重复/可读性与您寻求的性能之间的权衡。代码生成并继续前进。一些额外代码的任何维护问题都可能因性能本身的维护而相形见绌。

Answer 2

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

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

表示运算符的通用方法：

这是我的第一个想法。问题是如何实现它们。 MiscUtil通过调用存储在静态字段中的委托来完成此任务。

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 IArithmetic<T>
{
   T Multiply(T n1,T n2);
}

使用 struct ：

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);
}

如果你想为多种类型提供一个干净的接口，那么创建一个瘦的重载包装器转发到泛型方法：

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

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

Answer 3

那么，你可以做的是在构建过程中使用例如T4生成重复的代码。

Answer 4

public T Mul<T>(T a, T b){
    dynamic x = a;
    dynamic y = b;
    return (T)x*y;
}

Answer 5

我曾尝试使用CodeDom在运行时生成一个程序集并动态加载它。这很有效，但有一些局限性。例如，您的环境可能不允许您动态编译程序集，并且有一个重要的：性能。虽然“calculator”类只生成一次，但调用虚方法的开销实际上是计算所需时间的两倍。

你可以尝试看看它在你的环境中会如何表现，我只是列出了这些类（因为这是很久以前的事了，我不再有代码了。）

interface ICalculator<T> {
    T Add(T left, T right);
    T Multiply(T left, T right);
}

internal static class Calculator<T> {
     static ICalculator<T> instance;
     static Calculator() { 
          Type type = typeof(T);
          // 1. Use CodeDom to design a class that implements ICalculator<T> using the
          // builtin +,-,*,/ operators
          // 2. Compile assembly in memory
          // 3. Load assembly and create an instance of the ICalculator<T> class
          Type concreteType = GetTypeFromDynamicAssembly(); // Get this from the assembly.
          instance = Activator.CreateInstance(concreteType) as ICalculator<T>;
     }

     public static T Add(T left, T right) {
          return instance.Add(left, right);
     }
}

class MyClassUsingGenericMathType<T> {
    T Sum(params T[] values) {
        T sum = default(T);
        foreach (T value in values) {
            sum = Calculator<T>.Add(sum, value);
        }

        return sum;
    }
}

这个想法是你在第一次使用时动态构建实现（然后调用静态构造函数），之后Calculator方法直接调用你正在使用的数字类型的相应操作符。正如我所说，我记得每次执行操作时都会增加开销，但我从未分析是否有可能使用某些编译器属性来加速进程。

另一件事：使用不实现相应运算符的类型会导致运行时异常而不是编译错误。所以它远非完美。

c＃模板整数方法？

5 个答案:

表示运算符的通用方法：

4）如何运作：