C# 创建一个包含泛型集合的泛型方法并调用 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)