C# Create a Generic method contains generic collection and invoke Sum()

Question

using System;
using System.Collections.Generic;
using System.Linq;

public class Test
{
    public static void Fun<T>(List<T> list)
    {
        // The foreach works
        foreach(T i in list)
        {
            Console.WriteLine(i);
        }

        //The following line has error: List<T>' does not contain a definition for 'Sum'
        Console.WriteLine(list.Sum());
    }

     public static void Main()
    {
        var arr = new int[]{1,2,3,4};
        Fun<int>(arr.ToList());
    }
}

the foreach works, but list.Sum() doesn't. It shows:

'List' does not contain a definition for 'Sum' and the best extension method overload 'Queryable.Sum(IQueryable)' requires a receiver of type 'IQueryable'

if I declare as public static void Fun(List<int> list), then it works, anybody know why?

a similar C++ version can work:

#include <iostream>
#include <vector>
using namespace std;

template<class T>
struct MyList
{
    MyList(vector<T> v) : m(v){};
    vector<T> m;
    T Sum()
    {
        T sum = T();
        for(auto i : m)
        {
            sum += i;
        }
        return sum;
    }
};



template<class T>
void Fun(MyList<T> list)
{
    cout << list.Sum() << endl;
}

int main(int argc, char *argv[])
{
    Fun(MyList<int>({1,2,3}));
    Fun(MyList<double>({1.0,2.0,3.0}));
}

output: 
6
6.3

Answer 1

The difference between your C++ code and C# code is that in your C++ code, your MyList<T> template explicitly defines a Sum method. In contrast, C#'s List<T> doesn't define a Sum() method. Rather, List<T> implements IEnumerable<T>, and there are extension methods in the System.Linq namespace to provide Sum functionality to certain closed types of IEnumerable<T>.

Referring to the documentation, you'll see that Sum (without a selector, so not something like Sum(x => x.Value)) is only defined for the following closed types:

• IEnumerable<Single>
• IEnumerable<Int32>
• IEnumerable<Int64>
• IEnumerable<Double>
• IEnumerable<Decimal>
• IEnumerable<Nullable<Single>>
• IEnumerable<Nullable<Int32>>
• IEnumerable<Nullable<Int64>>
• IEnumerable<Nullable<Double>>
• IEnumerable<Nullable<Decimal>>

Therefore, it is not a feature of List<T>, and there is now way for the compiler to verify at compile time that the T in List<T> will be one of these types.

Note that long is the same as Int64, int is the same as Int32, and single is the same as float.

You could possibly provide some kind of aggregation functionality with the aid of a delegate:

public static void Fun<T>(List<T> list, Func<T, T, T> sumDelegate)
{
    T sumValue = default(T);
    // The foreach works
    foreach(T i in list)
    {
        Console.WriteLine(i);
        sumValue = sumDelegate(sumValue, i);
    }

    //The following line has error: List<T>' does not contain a definition for 'Sum'
    Console.WriteLine(sumValue);
}

And then call it like so:

var arr = new int[]{1,2,3,4};
Fun<int>(arr.ToList(), (x, y) => x + y);

Try it online

Answer 2

I don't know, how C++ works in this case, but in your code generic type parameter T isn't constrained to any type and compiler doesn't know whether T supports + operator or not. You can use dynamic keyword here to allow the compiler to determine the type in runtime

public static void Fun<T>(List<T> list)
{
    dynamic sum = default(T);
    foreach (T i in list)
    {
        Console.WriteLine(i);
        sum += (dynamic)i;
    }            

    Console.WriteLine(sum);
}

Or just in one line var sum = list.Aggregate((arg1, arg2) => (dynamic)arg1 + arg2);

But you should be very careful with it. If you pass a type, which doesn't support or overload the +, you'll get an exception in runtime. You can apply generic constraint to T and allow it match only numeric types where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable (it's quite long, but there is no generic constraint to match a numeric types in C# for now)