Danh sách so với danh sách - Sử dụng cái gì? Họ làm việc như thế nào?

Tôi có một số nghi ngờ về cách thức hoạt động của En Countators và LINQ. Hãy xem xét hai lựa chọn đơn giản sau:

List<Animal> sel = (from animal in Animals 
                    join race in Species
                    on animal.SpeciesKey equals race.SpeciesKey
                    select animal).Distinct().ToList();

hoặc là

IEnumerable<Animal> sel = (from animal in Animals 
                           join race in Species
                           on animal.SpeciesKey equals race.SpeciesKey
                           select animal).Distinct();

Tôi đã thay đổi tên của các đối tượng ban đầu của tôi để nó trông giống như một ví dụ chung hơn. Các truy vấn không phải là quan trọng. Điều tôi muốn hỏi là đây:

foreach (Animal animal in sel) { /*do stuff*/ }

1. Tôi nhận thấy rằng nếu tôi sử dụng IEnumerable, khi tôi gỡ lỗi và kiểm tra "sel", trong trường hợp đó là IEnumerable, nó có một số thành viên thú vị: "bên trong", "bên ngoài", "InternalKeySelector" và "outsKeySelector", 2 cái cuối cùng này xuất hiện làm đại biểu. Thành viên "bên trong" không có phiên bản "Động vật" trong đó, mà là các trường hợp "Loài", điều này rất lạ đối với tôi. Thành viên "bên ngoài" có chứa các trường hợp "Động vật". Tôi đoán rằng hai đại biểu xác định cái nào đi vào và cái gì đi ra khỏi nó?

2. Tôi nhận thấy rằng nếu tôi sử dụng "Khác biệt", "bên trong" chứa 6 mục (điều này không chính xác vì chỉ có 2 là Khác biệt), nhưng "bên ngoài" có chứa các giá trị chính xác. Một lần nữa, có lẽ các phương thức được ủy nhiệm xác định điều này nhưng điều này nhiều hơn một chút so với những gì tôi biết về IEnumerable.

3. Quan trọng nhất, lựa chọn nào trong hai tùy chọn là hiệu suất tốt nhất?

Danh sách ác chuyển đổi qua .ToList()?

Hoặc có thể sử dụng điều tra viên trực tiếp?

Nếu bạn có thể, vui lòng giải thích một chút hoặc ném một số liên kết giải thích việc sử dụng IEnumerable này.

IEnumerablemô tả hành vi, trong khi Danh sách là việc thực hiện hành vi đó. Khi bạn sử dụng IEnumerable, bạn cung cấp cho trình biên dịch một cơ hội để trì hoãn công việc cho đến sau này, có thể tối ưu hóa trên đường đi. Nếu bạn sử dụng ToList (), bạn buộc trình biên dịch xác nhận lại kết quả ngay lập tức.

Bất cứ khi nào tôi "xếp chồng" các biểu thức LINQ, tôi đều sử dụng IEnumerable, bởi vì chỉ xác định hành vi tôi cho LINQ cơ hội trì hoãn đánh giá và có thể tối ưu hóa chương trình. Hãy nhớ cách LINQ không tạo SQL để truy vấn cơ sở dữ liệu cho đến khi bạn liệt kê nó? Xem xét điều này:

public IEnumerable<Animals> AllSpotted()
{
    return from a in Zoo.Animals
           where a.coat.HasSpots == true
           select a;
}

public IEnumerable<Animals> Feline(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Felidae"
           select a;
}

public IEnumerable<Animals> Canine(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Canidae"
           select a;
}

Bây giờ bạn có một phương pháp chọn một mẫu ban đầu ("AllSpiated"), cộng với một số bộ lọc. Vì vậy, bây giờ bạn có thể làm điều này:

var Leopards = Feline(AllSpotted());
var Hyenas = Canine(AllSpotted());

Vì vậy, nó là nhanh hơn để sử dụng Danh sách hơn IEnumerable? Chỉ khi bạn muốn ngăn truy vấn được thực thi nhiều lần. Nhưng nó là tốt hơn về tổng thể? Cũng như ở trên, Leopards và Hyenas được chuyển đổi thành các truy vấn SQL duy nhất và mỗi cơ sở dữ liệu chỉ trả về các hàng có liên quan. Nhưng nếu chúng tôi đã trả về một Danh sách từ AllSpotted()đó, thì nó có thể chạy chậm hơn vì cơ sở dữ liệu có thể trả về nhiều dữ liệu hơn mức thực sự cần thiết và chúng tôi lãng phí các chu trình thực hiện việc lọc trong máy khách.

Trong một chương trình, có thể tốt hơn là trì hoãn chuyển đổi truy vấn của bạn thành một danh sách cho đến khi kết thúc, vì vậy nếu tôi sẽ liệt kê thông qua Leopards và Hyenas hơn một lần, tôi sẽ làm điều này:

List<Animals> Leopards = Feline(AllSpotted()).ToList();
List<Animals> Hyenas = Canine(AllSpotted()).ToList();

Có một bài viết rất hay được viết bởi: Claudio Bernasconi's TechBlog tại đây: Khi nào nên sử dụng IEnumerable, ICollection, IList và List

Dưới đây là một số điểm cơ bản về các kịch bản và chức năng:

Một lớp thực hiện IEnumerablecho phép bạn sử dụng foreachcú pháp.

Về cơ bản nó có một phương pháp để có được mục tiếp theo trong bộ sưu tập. Nó không cần toàn bộ bộ sưu tập trong bộ nhớ và không biết có bao nhiêu vật phẩm trong đó, foreachchỉ cần tiếp tục lấy vật phẩm tiếp theo cho đến khi hết.

Điều này có thể rất hữu ích trong một số trường hợp nhất định, ví dụ trong một bảng cơ sở dữ liệu lớn mà bạn không muốn sao chép toàn bộ vào bộ nhớ trước khi bắt đầu xử lý các hàng.

Bây giờ Listthực hiện IEnumerable, nhưng đại diện cho toàn bộ bộ sưu tập trong bộ nhớ. Nếu bạn có một IEnumerablevà bạn gọi .ToList()bạn tạo một danh sách mới với nội dung liệt kê trong bộ nhớ.

Biểu thức linq của bạn trả về một bảng liệt kê và theo mặc định, biểu thức sẽ thực thi khi bạn lặp lại bằng cách sử dụng foreach. Một IEnumerablecâu lệnh linq thực thi khi bạn lặp lại foreach, nhưng bạn có thể buộc nó lặp lại sớm hơn bằng cách sử dụng .ToList().

Ý tôi là đây:

var things = 
    from item in BigDatabaseCall()
    where ....
    select item;

// this will iterate through the entire linq statement:
int count = things.Count();

// this will stop after iterating the first one, but will execute the linq again
bool hasAnyRecs = things.Any();

// this will execute the linq statement *again*
foreach( var thing in things ) ...

// this will copy the results to a list in memory
var list = things.ToList()

// this won't iterate through again, the list knows how many items are in it
int count2 = list.Count();

// this won't execute the linq statement - we have it copied to the list
foreach( var thing in list ) ...

Không ai đề cập đến một sự khác biệt quan trọng, mỉa mai trả lời về một câu hỏi đóng như là một bản sao của điều này.

IEnumerable là chỉ đọc và Danh sách thì không.

Xem sự khác biệt thực tế giữa Danh sách và IEnumerable

Điều quan trọng nhất cần nhận ra là, bằng cách sử dụng Linq, truy vấn không được đánh giá ngay lập tức. Nó chỉ được chạy như một phần của việc lặp lại thông qua kết quả IEnumerable<T>là foreach- đó là điều mà tất cả các đại biểu kỳ lạ đang làm.

Vì vậy, ví dụ đầu tiên đánh giá truy vấn ngay lập tức bằng cách gọi ToListvà đưa kết quả truy vấn vào danh sách.
Ví dụ thứ hai trả về một IEnumerable<T>chứa tất cả thông tin cần thiết để chạy truy vấn sau này.

Về hiệu suất, câu trả lời là phụ thuộc . Nếu bạn cần đánh giá kết quả ngay lập tức (giả sử, bạn đang thay đổi cấu trúc bạn truy vấn sau này hoặc nếu bạn không muốn lặp đi lặp lại trong IEnumerable<T>một thời gian dài), hãy sử dụng danh sách. Khác sử dụng một IEnumerable<T>. Mặc định nên sử dụng đánh giá theo yêu cầu trong ví dụ thứ hai, vì thông thường sử dụng ít bộ nhớ hơn, trừ khi có một lý do cụ thể để lưu trữ kết quả trong danh sách.

Ưu điểm của IEnumerable là thực thi hoãn lại (thường là với cơ sở dữ liệu). Truy vấn sẽ không được thực hiện cho đến khi bạn thực sự lặp qua dữ liệu. Đó là một truy vấn chờ cho đến khi nó cần thiết (còn gọi là lười tải).

Nếu bạn gọi ToList, truy vấn sẽ được thực thi hoặc "cụ thể hóa" như tôi muốn nói.

Cả hai đều có ưu điểm và nhược điểm riêng. Nếu bạn gọi ToList, bạn có thể xóa một số bí ẩn khi truy vấn được thực thi. Nếu bạn gắn bó với IEnumerable, bạn sẽ có được lợi thế là chương trình không thực hiện bất kỳ công việc nào cho đến khi nó thực sự cần thiết.

Tôi sẽ chia sẻ một khái niệm bị lạm dụng mà tôi rơi vào một ngày:

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));


// updating existing list
names[0] = "ford";

// Guess what should be printed before continuing
print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

Kết quả mong đợi

// I was expecting    
print( startingWith_M.ToList() ); // mercedes, mazda
print( startingWith_F.ToList() ); // fiat, ferrari

Kết quả thực tế

// what printed actualy   
print( startingWith_M.ToList() ); // mazda
print( startingWith_F.ToList() ); // ford, fiat, ferrari

Giải trình

Theo các câu trả lời khác, việc đánh giá kết quả đã được hoãn lại cho đến khi gọi ToListhoặc các phương thức gọi tương tự chẳng hạn ToArray.

Vì vậy, tôi có thể viết lại mã trong trường hợp này là:

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

// updating existing list
names[0] = "ford";

// before calling ToList directly
var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));

print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

Chơi arround

https://repl.it/E8Ki/0

Nếu tất cả những gì bạn muốn làm là liệt kê chúng, hãy sử dụng IEnumerable.

Mặc dù vậy, hãy coi chừng việc thay đổi bộ sưu tập gốc đang được liệt kê là một hoạt động nguy hiểm - trong trường hợp này, bạn sẽ muốn ToList trước tiên. Điều này sẽ tạo ra một thành phần danh sách mới cho mỗi thành phần trong bộ nhớ, liệt kê IEnumerablevà do đó ít hiệu suất hơn nếu bạn chỉ liệt kê một lần - nhưng an toàn hơn và đôi khi các Listphương thức rất tiện dụng (ví dụ như trong truy cập ngẫu nhiên).

Ngoài tất cả các câu trả lời được đăng ở trên, đây là hai xu của tôi. Có nhiều loại khác ngoài Danh sách thực hiện IEnumerable như ICollection, ArrayList, v.v. Vì vậy, nếu chúng ta có IEnumerable là tham số của bất kỳ phương thức nào, chúng ta có thể chuyển bất kỳ loại bộ sưu tập nào cho hàm. Tức là chúng ta có thể có phương pháp để hoạt động trừu tượng chứ không phải thực hiện cụ thể.

Có nhiều trường hợp (chẳng hạn như danh sách vô hạn hoặc danh sách rất lớn) trong đó IEnumerable không thể được chuyển đổi thành Danh sách. Các ví dụ rõ ràng nhất là tất cả các số nguyên tố, tất cả người dùng facebook với các chi tiết của họ hoặc tất cả các mục trên ebay.

Sự khác biệt là các đối tượng "Danh sách" được lưu trữ "ngay tại đây và ngay bây giờ", trong khi các đối tượng "IEnumerable" hoạt động "chỉ một lần". Vì vậy, nếu tôi xem qua tất cả các mục trên ebay, mỗi lần một thứ sẽ là thứ mà ngay cả một máy tính nhỏ cũng có thể xử lý, nhưng ".ToList ()" chắc chắn sẽ khiến tôi hết bộ nhớ, cho dù máy tính của tôi có lớn đến đâu. Không có máy tính nào có thể tự chứa và xử lý một lượng dữ liệu khổng lồ như vậy.

[Chỉnh sửa] - Không cần phải nói - không phải "cái này hay cái kia". thông thường sẽ rất hợp lý khi sử dụng cả danh sách và IEnumerable trong cùng một lớp. Không có máy tính nào trên thế giới có thể liệt kê tất cả các số nguyên tố, bởi vì theo định nghĩa, điều này sẽ đòi hỏi một lượng bộ nhớ vô hạn. Nhưng bạn có thể dễ dàng nghĩ ra cái class PrimeContainernào chứa một cái IEnumerable<long> primes, vì lý do rõ ràng cũng chứa a SortedList<long> _primes. tất cả các số nguyên tố tính toán cho đến nay. nguyên tố tiếp theo được kiểm tra sẽ chỉ được chạy theo các số nguyên tố hiện có (tối đa căn bậc hai). Bằng cách đó, bạn có được cả hai - số nguyên tố một lần (IEnumerable) và một danh sách tốt "số nguyên tố cho đến nay", đó là một xấp xỉ khá tốt của toàn bộ danh sách (vô hạn).