What are the Advantages/Disadvantages between Tuple.Create and new Tuple

Question

Are there any guidelines for when I should use Tuple.Create() instead of new Tuple() ?

There must be a reason for Microsoft having 2 ways to create the same object. Speed differences or other known advantages/disadvantaes?

Hi @shev72, check out this link http://stackoverflow.com/questions/3089706/what-requirement-was-the-tuple-designed-to-solve — Vikrant, Mar 09 '15 at 12:36
The best option to test if there are perfomance differences is benchmarking. — Binkan Salaryman, Mar 09 '15 at 12:43

score 3 · Accepted Answer · answered Mar 09 '15 at 12:36

Sadly in C# constructors don't do type inference. So you can't write:

Tuple<int, int> xxx = new Tuple(1, 2);

while methods do it:

Tuple<int, int> xxx = Tuple.Create(1, 2);

for using constructors you need:

Tuple<int, int> xxx = new Tuple<int, int>(1, 2);

This is more verbose.

Note that if type inference doesn't work for you (because you want a tuple of a different type than the parameters you are passing):

Tuple<object, object> xxx = Tuple.Create("A", "B"); // Invalid

then they are equivalent for verbosity:

Tuple<object, object> xxx = Tuple.Create<object, object>("A", "B");

Tuple<object, object> xxx = new Tuple<object, object>("A", "B");

Tuple<object, object> xxx = Tuple.Create((object)"A", (object)"B");

score 2 · Answer 2 · edited May 23 '17 at 12:24

As seen from the source code Tuple.Create(item1) is just calling new Tuple<T1>(item1). So, there is not any speed difference between them.

 public static Tuple<T1> Create<T1>(T1 item1) {
            return new Tuple<T1>(item1);
        }

So, you can create your collection with both ways:

Tuple<int> myTuple = Tuple.Create(1); // This one uses type inference
Tuple<int> myTuple = new Tuple<int>(1);

But, of course there is a reason of the existence of both constructor and generic method. Constructors in C# can't support type inference. So, they have to create some generic method to support type inference. For example, this will give you compiler error:

Tuple<int> myTuple = new Tuple(1); // Oops, compiler error

So, instead of writing the above code, we can write this thanks to Create() method:

Tuple<int> myTuple = Tuple.Create(1);

By the way, you can read Eric Lippert's answer for more information, if you want to know why can't the C# constructor infer type.

The constructor is likely to run faster, because the call to `Create` might not get `inline`d. — Binkan Salaryman, Mar 09 '15 at 12:37
The difference is negligible - No need for premature optimization. — Binkan Salaryman, Mar 09 '15 at 14:15
thanks for the pointer to Eric Lipper's answer, very usefl and interesting read! — shelbypereira, Mar 09 '15 at 15:20

score 2 · Answer 3 · answered Mar 09 '15 at 12:36

2

No speed differences but since the Create is a generic method so the compiler can infer the generic argument types for you.This is not possible for the constructor.

answered Mar 09 '15 at 12:36

Selman Genç

100,147
13
119
184

What are the Advantages/Disadvantages between Tuple.Create and new Tuple

3 Answers3