Question

private delegate T MyFunc<T>(int i);

private static double SumNumber(int i, int n, MyFunc<double> func)
{
    double sum = 0.0;
    for (int j = i; i <= n; j++)
    {
        sum += func(j);
    }
    return sum;
}

private static Vector SumVector(int i, int n, MyFunc<Vector> func)
{
    Vector sum = new Vector(0.0, 0.0);
    for (int j = i; i <= n; j++)
    {
        sum += func(j);
    }
    return sum;
}

This is a program to calculate sum of MyFunc(j) where j is i to n.

I tried to use interface like:

interface IAddable<T>
{
    static T operator +(T x, T y);
}

but it didn’t work.

So what should I do?

Answer 1

Firstly, note that in many ways the non-generic overload version is simpler. Generics do not support operators, nor do interfaces.

Indeed, if there are Sum methods available for your types (perhaps via extension methods on IEnumerable<T>) the caller could use simply:

var data = sourceData.Select(projection).Sum();

where projection is the moral equivalent of func.

For doing it your way, what you might try first is dynamic:

private static T Sum<T>(int i, int n, Func<int,T> func)
{
    if(i >= n) throw new ArgumentOutOfRangeException();
    T sum = func(i);
    for (int j = i + 1; i <= n; j++)
    {
        sum = (dynamic)sum + (dynamic)func(j);
    }
    return sum;
}

otherwise, there are some tricks you can do to fake generic operators (see MiscUtil), or you could pass in the accumulator method (i.e. Func<T,T,T> add) as a parameter.