Tuple.Create() vs tuple mới

Question

xem xét như sau:

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

Có sự khác biệt giữa hai phương pháp này tạo tuple? Từ đọc của tôi nó có vẻ là một cách viết tắt thuận tiện hơn bất cứ thứ gì như tạo đối tượng trong C++ (đống vs stack).

Answer 1

Vâng, câu hỏi này là cũ ... nhưng tuy nhiên tôi nghĩ rằng tôi có thể đóng góp xây dựng. Từ câu trả lời được chấp nhận:

Tôi cho rằng một lợi ích là, kể từ khi bạn không cần phải xác định loại với Tuple.Create, bạn có thể lưu trữ các loại vô danh mà bạn nếu không sẽ không thể nói gì loại là

Hậu quả là đúng: bạn có thể lưu trữ các loại vô danh mà ...

Nhưng phần đầu tiên:

kể từ khi bạn không cần phải xác định t ype với Tuple.Create

không phải lúc nào cũng đúng.Hãy xem xét các tình huống sau:

interface IAnimal 
{ 
} 

class Dog : IAnimal 
{ 
} 

Sau đây sẽ không biên dịch:

Tuple<IAnimal> myWeirdTuple; 

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

Bạn sẽ phải chỉ định tham số gõ vào Create phương pháp như thế này:

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

đó là như verbose as calling new Tuple<IAnimal>(new Dog()) IMO

Answer 2

Không có sự khác biệt. Nếu bạn nhìn vào mã nguồn, nó đang làm điều tương tự.

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

Ví dụ:

Tuple.create(1,2); 

sẽ gọi

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

Answer 3

Lợi ích của việc sử dụng Tuple.Create() là bạn không nhất thiết cần phải xác định loại mới Tuple như với new Tuple<T1,T2>(*,*). Với tùy chọn đầu tiên, tùy chọn này hợp lệ:

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

Answer 4

Cá nhân, tôi thấy Tuple.Create() ít tiết và dễ đọc hơn.

Không có sự khác biệt, dưới mui xe. Các Tuple.Create() phương pháp quá tải chỉ là một loạt các phương pháp tĩnh gọi phiên bản đầu tiên bạn đăng:

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

    ... 

Tôi cho rằng một lợi ích là, kể từ khi bạn không cần phải xác định loại với Tuple.Create, bạn có thể lưu trữ vô danh các loại mà bạn sẽ không thể nói loại đó là gì.

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

này tạo ra một tuple với hai loại vô danh, đầu tiên là một new { string Name, DateTime BirthDate } và thứ hai là một new { int Height, string Name }.

Vẫn không quá nhiều bạn có thể làm với điều đó, vì chuyển nó sang phương pháp khác, bạn vẫn cần phải xác định "loại" của tham số. Vì vậy, nó thực sự đi xuống để thuận tiện.