blocks|key|4549734|text|这是没有区别的。如果你看一下源代码，你会发现它在做同样的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4549735|http://referencesource.microsoft.com/#mscorlib/system/tuple.cs,9124c4bea9ab0199|offset|length|4549736|例如：|4549737|Tuple.create(1,2);+|code-block|syntax|javascript|4549738|将会调用|4549739|public+static+Tuple<T1,+T2>+Create<T1,+T2>(T1+item1,+T2+item2)+{
++++return+new+Tuple<T1,+T2>(item1,+item2);
}|4549740|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|27|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|13|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|C]]]]

There is no difference. If you take a look at the source code, it is doing the same thing.
<a href="http://referencesource.microsoft.com/#mscorlib/system/tuple.cs,9124c4bea9ab0199" rel="nofollow noreferrer">http://referencesource.microsoft.com/#mscorlib/system/tuple.cs,9124c4bea9ab0199</a>
For example:
<pre><code>Tuple.create(1,2); 
</code></pre>
is going to call
<pre><code>public static Tuple&lt;T1, T2&gt; Create&lt;T1, T2&gt;(T1 item1, T2 item2) {
 return new Tuple&lt;T1, T2&gt;(item1, item2);
}
</code></pre>

blocks|key|4549819|text|就我个人而言，我发现Tuple.Create()不那么冗长，也更容易阅读。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4549820|没有区别，在引擎盖下。Tuple.Create()重载方法只是一堆调用您发布的第一个版本的静态方法：|4549821|public+static+class+Tuple
{
++++public+static+Tuple<T1>+Create<T1>(T1+item1)+{
++++++++return+new+Tuple<T1>(item1);
++++}

++++public+static+Tuple<T1,+T2>+Create<T1,+T2>(T1+item1,+T2+item2)+{
++++++++return+new+Tuple<T1,+T2>(item1,+item2);
++++}

++++public+static+Tuple<T1,+T2,+T3>+Create<T1,+T2,+T3>(T1+item1,+T2+item2,+T3+item3)+{
++++++++return+new+Tuple<T1,+T2,+T3>(item1,+item2,+item3);
++++}

++++...|code-block|syntax|javascript|4549822|我认为一个好处是，因为您不必使用Tuple.Create指定类型，所以您可以存储匿名类型，否则您将无法确定该类型是什么。|4549823|public+class+Person
{
++++public+string+Name+{+get;+set;+}
++++public+int+Height+{+get;+set;+}
++++public+DateTime+BirthDate+{+get;+set;+}
}

var+people+=+new+List<Person>
{
++++new+Person+{+Name+=+"Bob",+Height+=+72,+BirthDate+=+new+DateTime(1984,1,1)+},
++++new+Person+{+Name+=+"Mary",+Height+=+64,+BirthDate+=+new+DateTime(1980,2,2)+}
};

var+oneAnonList+=+people.Select(x+=>+new+{+x.Name,+x.BirthDate+});
var+twoAnonList+=+people.Select(x+=>+new+{+x.Height,+x.Name+});

var+myTuple+=+Tuple.Create(oneAnonList,+twoAnonList);|4549824|这将创建一个具有两个匿名类型的元组，第一个是new+{+string+Name,+DateTime+BirthDate+}，第二个是new+{+int+Height,+string+Name+}。|4549825|因为要将它传递给另一个方法，你仍然需要能够定义参数的“类型”。所以这真的归结于便利性。|4549826|entityMap^0|A|E|0|B|E|0|0|G|C|0|0|M|13|1U|V|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|V|$]]

Personally, I find <code>Tuple.Create()</code> less verbose and easier to read.

There's no difference, under the hood. The <code>Tuple.Create()</code> overloaded methods are just a bunch of static methods that call the first version you posted:

<pre><code>public static class Tuple
{
 public static Tuple&lt;T1&gt; Create&lt;T1&gt;(T1 item1) {
 return new Tuple&lt;T1&gt;(item1);
 }

 public static Tuple&lt;T1, T2&gt; Create&lt;T1, T2&gt;(T1 item1, T2 item2) {
 return new Tuple&lt;T1, T2&gt;(item1, item2);
 }

 public static Tuple&lt;T1, T2, T3&gt; Create&lt;T1, T2, T3&gt;(T1 item1, T2 item2, T3 item3) {
 return new Tuple&lt;T1, T2, T3&gt;(item1, item2, item3);
 }

 ...
</code></pre>

I suppose one benefit is that, since you don't have to specify the type with <code>Tuple.Create</code>, you can store anonymous types for which you otherwise wouldn't be able to say what the type is.

<pre><code>public class Person
{
 public string Name { get; set; }
 public int Height { get; set; }
 public DateTime BirthDate { get; set; }
}

var people = new List&lt;Person&gt;
{
 new Person { Name = "Bob", Height = 72, BirthDate = new DateTime(1984,1,1) },
 new Person { Name = "Mary", Height = 64, BirthDate = new DateTime(1980,2,2) }
};

var oneAnonList = people.Select(x =&gt; new { x.Name, x.BirthDate });
var twoAnonList = people.Select(x =&gt; new { x.Height, x.Name });

var myTuple = Tuple.Create(oneAnonList, twoAnonList);
</code></pre>

This creates a Tuple with two anonymous types, the first is a <code>new { string Name, DateTime BirthDate }</code> and the second is a <code>new { int Height, string Name }</code>.

There's still not too terribly much you can do with that, since to pass it to another method, you'd still need to be able to define the "type" of the parameter. So it really comes down to convenience.

Consider the following expressions:

<pre><code>new Tuple&lt;int,int&gt;(1,2);

Tuple.Create(1,2);
</code></pre>

Is there any difference between these two methods of Tuple creation? From my reading it seems to be more a convenient shorthand than anything like object creation in C++ (heap vs stack).

Tuple.Create() vs new Tuple

考虑以下表达式：new Tuple<int,int>(1,2);Tuple.Create(1,2);这两种创建元组的方法有什么不同吗？从我的理解来看，它似乎比在C++中创建对象(堆和栈)更方便快捷。

问Tuple.Create()与新的元组
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Tuple.Create()与新的元组EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Tuple.Create()与新的元组
EN