ToArray（）和ToArray之间的区别 <int> （）;

Question

Excuse me if I am asking silly question, but can anybody explain the difference between following two calls ( ToArray ). In the intellisense it does not show them as overloaded methods & of course the output of both the calls are same.

List<int> i = new List<int> { 1, 2, 5, 64 };
int[] input = i.Where(j => j % 2 == 1).ToArray();
input = i.Where(j => j % 2 == 1).ToArray<int>();

Answer 1

There is no difference, it is the exact same ToArray() method. The compiler can simply infer that you want the ToArray<int> version from the syntax of the expression. The return value of Where() was inferred to return int. In other words, it uses Where<int>() . Which was inferred from the type of the List<>. So it can infer that you need ToArray<int> .

So the type inference chain is List<int> => Where<int>() => ToArray<int>() .

Change the list to, say, List<long> and the expression still works without having to modify it.

Answer 2

There is no difference here. In the first call, the compiler has inferred the type int , while in the second you have specified it explicitly.

There may be cases where the type is necessary because it cannot be inferred. For example, you have a custom collection that implements IEnumerable<T> twice, for two different types T . This hurts usability so it is preferable that you avoid such constructions.

Answer 3

It's the same generic method. In the first case, the generic type parameter is inferred by compiler from the generic type parameter of the Enumeration you're calling ToArray<T>() on. But you can also specify it explicitly.

Answer 4

They are the same thing. You are witnessing what is called "type inference". In certain scenarios, the C# compiler can detect the type based on the parameters passed in and you do not have to explicitly specify the type parameters. In your example, it's known that i is an IEnumerable<int> , and thus .ToArray() can infer the parameter int .

Here is a nice article that goes into this in depth: http://joelabrahamsson.com/a-neat-little-type-inference-trick-with-c/

Answer 5

No difference.

int[] input = i.Where(j => j % 2 == 1).ToArray();

Here, only the compiler is inferring the T generic argument based on the type of enumerable you call ToArray() on.

input = i.Where(j => j % 2 == 1).ToArray<int>();

Here, return value of Where() is inferred by compiler to return int .

• ToArray<T>() is Generic is so that it can operate on any IEnumerable<T> .
• ToArray() actually just redirects to an implicit interpretation of ToArray<T>() based on the T of the source IEnumerable.
• If you call a generic method and don't supply any type arguments, the compiler will try to infer them for you.