Tuple.Create() vs nowej krotki

Question

Rozważmy następujący:

Tuple<int, int> t1 = new Tuple<int,int>(1,2); 
Tuple<int, int> t2 = Tuple.Create(1,2); 

Czy jest jakaś różnica między tymi dwiema metodami tworzenia krotki? Z mojego czytania wynika, że ​​jest bardziej wygodnym skrótem niż cokolwiek, jak tworzenie obiektów w C++ (heap vs stack).

Answer 1

Cóż, te pytania są stare ... ale mimo wszystko uważam, że mogę wnosić konstruktywny wkład. Z przyjętą odpowiedzi:

Przypuszczam jedną korzyścią jest to, że ponieważ nie trzeba określić typ z Tuple.Create można przechowywać anonimowych typów, dla których w przeciwnym razie nie byłyby w stanie powiedzieć, co typ jest

konsekwencją jest prawdziwe: można przechowywać anonimowych typów, dla których ...

Ale pierwsza część:

ponieważ nie trzeba określić t ype z Tuple.Create

nie zawsze jest prawdziwe.Rozważmy następujący scenariusz:

interface IAnimal 
{ 
} 

class Dog : IAnimal 
{ 
} 

Następujące nie skompilować:

Tuple<IAnimal> myWeirdTuple; 

myWeirdTuple = Tuple.Create(new Dog()); 

Trzeba będzie podać parametr typu w metodzie Create jak ten:

myWeirdTuple = Tuple.Create<IAnimal>(new Dog()); 

która jako verbose pod nazwą new Tuple<IAnimal>(new Dog()) IMO

Answer 2

Nie ma różnicy. Jeśli spojrzeć na kod źródłowy, robi to samo.

http://referencesource.microsoft.com/#mscorlib/system/tuple.cs,9124c4bea9ab0199

Na przykład:

Tuple.create(1,2); 

zamierza zadzwonić

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

Answer 3

Zaletą korzystania Tuple.Create() jest to, że nie koniecznie trzeba określić typy nowy Tuple tak jak z new Tuple<T1,T2>(*,*). Z pierwszej opcji, to jest ważne:

var newTuple = Tuple.Create(1,2); 

Answer 4

Osobiście uważam Tuple.Create() mniej gadatliwy i łatwiejsze do odczytania.

Nie ma różnicy, pod maską. W Tuple.Create() przeciążone metody to tylko kilka z metod statycznych, które nazywają się pierwsza wersja ty Wysłany:

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); 
    } 

    ... 

Przypuszczam jedną korzyścią jest to, że ponieważ nie trzeba określić typ z Tuple.Create można zapisać anonimowy typy, dla których inaczej nie byłbyś w stanie powiedzieć, jaki jest typ.

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); 

Stwarza to krotka z dwóch anonimowych typów, pierwszy jest new { string Name, DateTime BirthDate } a drugi jest new { int Height, string Name }.

Nadal nie jest zbyt wiele, co można z tym zrobić, ponieważ aby przekazać go innej metodzie, nadal trzeba będzie zdefiniować "typ" parametru. Tak naprawdę sprowadza się to do wygody.