c# templating integer methods?

Consider the 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;
    }

Performance is to be determined (I'd expect it to be slower than straight overloads), but readability is much nicer. Could get a little hairy if you provide types that don't implement the required operators or different types that cause values to truncate.

Updated from comment: If performance is so critical, then it sounds like you have already chosen the trade-off between duplicating/readability and the performance you seek. Code-gen it and move on. Any maintenance issues from a few pieces of extra code are likely dwarfed by the maintenance of the performance itself.

Well, what you could do is generate the duplicated code during your build process using, for example, T4.

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

I once tried so implement something similar using CodeDom to generate an assembly during runtime and dynamically load it. This works rather well, but has some limitations. For example, your environment might not allow you to dynamically compile assemblies and there is the big one: performance. Although the "calculator"-class is only generated once, the overhead of calling a virtual method actually doubles the time necessary for the calculation.

You could give it a try to see how it would perform in your environment, I just lay out the classes (since this was a long time ago and I don't have the code anymore).

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

The idea is that you dynamically built the implementation first time it is used (the static constructor is invoked then), after that the Calculator methods directly call the corresponding operator of the numeric type you are using. As I said, I remember that this adds an overhead everytime an operation is performed, but I never analyzed whether there is a potential for speeding up the process using some Compiler-attributes.

Another thing: using a type that doesn't implement the corresponding operators would cause a runtime-exception rather than a compile error. So it's far from perfect.