Tại sao không có phương thức mở rộng ForEach trên IEnumerable?

Lấy cảm hứng từ một câu hỏi khác hỏi về Zipchức năng còn thiếu :

Tại sao không có ForEachphương thức mở rộng trong Enumerablelớp? Hay bất cứ nơi nào? Lớp duy nhất có được một ForEachphương thức là List<>. Có một lý do tại sao nó thiếu (hiệu suất)?

Đã có một tuyên bố foreach bao gồm trong ngôn ngữ làm công việc hầu hết thời gian.

Tôi ghét phải xem những điều sau đây:

list.ForEach( item =>
{
    item.DoSomething();
} );

Thay vì:

foreach(Item item in list)
{
     item.DoSomething();
}

Cái sau rõ ràng hơn và dễ đọc hơn trong hầu hết các tình huống , mặc dù có thể lâu hơn một chút để gõ.

Tuy nhiên, tôi phải thừa nhận tôi đã thay đổi lập trường của mình về vấn đề đó; một phương thức mở rộng ForEach () thực sự sẽ hữu ích trong một số trường hợp.

Dưới đây là những khác biệt chính giữa tuyên bố và phương thức:

• Kiểm tra kiểu: foreach được thực hiện trong thời gian chạy, ForEach () đang ở thời gian biên dịch (Big Plus!)
• Cú pháp để gọi một đại biểu thực sự đơn giản hơn nhiều: object.ForEach (DoS Something);
• ForEach () có thể bị xiềng xích: mặc dù tính xấu / tính hữu dụng của tính năng này được mở để thảo luận.

Đó là tất cả những điểm tuyệt vời được thực hiện bởi nhiều người ở đây và tôi có thể thấy tại sao mọi người thiếu chức năng. Tôi sẽ không nhớ Microsoft thêm một phương thức ForEach tiêu chuẩn trong lần lặp khung tiếp theo.

Phương pháp ForEach đã được thêm vào trước LINQ. Nếu bạn thêm tiện ích mở rộng ForEach, nó sẽ không bao giờ được gọi cho các phiên bản Danh sách vì các ràng buộc về phương thức tiện ích mở rộng. Tôi nghĩ lý do nó không được thêm vào là không can thiệp vào cái hiện có.

Tuy nhiên, nếu bạn thực sự bỏ lỡ chức năng nhỏ xinh này, bạn có thể tung ra phiên bản của riêng mình

public static void ForEach<T>(
    this IEnumerable<T> source,
    Action<T> action)
{
    foreach (T element in source) 
        action(element);
}

Bạn có thể viết phương thức mở rộng này:

// Possibly call this "Do"
IEnumerable<T> Apply<T> (this IEnumerable<T> source, Action<T> action)
{
    foreach (var e in source)
    {
        action(e);
        yield return e;
    }
}

Ưu

Cho phép xích:

MySequence
    .Apply(...)
    .Apply(...)
    .Apply(...);

Nhược điểm

Nó sẽ không thực sự làm bất cứ điều gì cho đến khi bạn làm một cái gì đó để buộc lặp đi lặp lại. Vì lý do đó, nó không nên được gọi .ForEach(). Bạn có thể viết .ToList()ở cuối hoặc bạn cũng có thể viết phương thức mở rộng này:

// possibly call this "Realize"
IEnumerable<T> Done<T> (this IEnumerable<T> source)
{
    foreach (var e in source)
    {
        // do nothing
        ;
    }

    return source;
}

Điều này có thể quá quan trọng khi rời khỏi thư viện C # vận chuyển; những người đọc không quen thuộc với các phương thức mở rộng của bạn sẽ không biết phải làm gì với mã của bạn.

Các cuộc thảo luận ở đây đưa ra câu trả lời:

Trên thực tế, các cuộc thảo luận cụ thể mà tôi đã chứng kiến ​​đã thực sự xoay quanh độ tinh khiết của chức năng. Trong một biểu thức, thường có những giả định được đưa ra về việc không có tác dụng phụ. Có ForEach đặc biệt mời các tác dụng phụ thay vì chỉ đưa ra chúng. - Keith Farmer (Đối tác)

Về cơ bản, quyết định đã được đưa ra để giữ cho các phương thức mở rộng hoạt động "thuần túy". Một ForEach sẽ khuyến khích các tác dụng phụ khi sử dụng các phương thức mở rộng Vô số, không phải là mục đích.

Mặc dù tôi đồng ý rằng tốt hơn là sử dụng foreachcấu trúc tích hợp trong hầu hết các trường hợp, tôi thấy việc sử dụng biến thể này trên tiện ích mở rộng ForEach <> sẽ đẹp hơn một chút so với việc phải tự mình quản lý chỉ mục foreach:

public static int ForEach<T>(this IEnumerable<T> list, Action<int, T> action)
{
    if (action == null) throw new ArgumentNullException("action");

    var index = 0;

    foreach (var elem in list)
        action(index++, elem);

    return index;
}

var people = new[] { "Moe", "Curly", "Larry" };
people.ForEach((i, p) => Console.WriteLine("Person #{0} is {1}", i, p));

Sẽ cung cấp cho bạn:

Person #0 is Moe
Person #1 is Curly
Person #2 is Larry

Một cách giải quyết là viết .ToList().ForEach(x => ...).

ưu

Dễ hiểu - người đọc chỉ cần biết tàu nào có C #, không phải bất kỳ phương thức mở rộng bổ sung nào.

Tiếng ồn cú pháp rất nhẹ (chỉ thêm một chút mã ngoại lai).

Không thường tốn thêm bộ nhớ, vì .ForEach()dù sao người bản địa cũng sẽ phải nhận ra toàn bộ bộ sưu tập.

khuyết điểm

Thứ tự hoạt động không lý tưởng. Tôi muốn nhận ra một yếu tố, sau đó hành động theo nó, sau đó lặp lại. Mã này nhận ra tất cả các yếu tố trước, sau đó hành động theo từng chuỗi.

Nếu nhận ra danh sách ném một ngoại lệ, bạn không bao giờ phải hành động trên một yếu tố duy nhất.

Nếu phép liệt kê là vô hạn (như số tự nhiên), bạn sẽ không gặp may.

Tôi đã luôn tự hỏi rằng, đó là lý do tại sao tôi luôn mang theo thứ này bên mình:

public static void ForEach<T>(this IEnumerable<T> col, Action<T> action)
{
    if (action == null)
    {
        throw new ArgumentNullException("action");
    }
    foreach (var item in col)
    {
        action(item);
    }
}

Phương pháp mở rộng nhỏ đẹp.

Vì vậy, đã có rất nhiều ý kiến ​​về thực tế rằng phương thức mở rộng ForEach không phù hợp vì nó không trả về giá trị như các phương thức mở rộng LINQ. Mặc dù đây là một tuyên bố thực tế, nó không hoàn toàn đúng.

Các phương thức mở rộng LINQ đều trả về một giá trị để chúng có thể được nối lại với nhau:

collection.Where(i => i.Name = "hello").Select(i => i.FullName);

Tuy nhiên, chỉ vì LINQ được triển khai bằng các phương thức mở rộng không có nghĩa là các phương thức mở rộng phải được sử dụng theo cùng một cách và trả về một giá trị. Viết một phương thức mở rộng để hiển thị chức năng phổ biến không trả về giá trị là một cách sử dụng hoàn toàn hợp lệ.

Lập luận cụ thể về ForEach là, dựa trên các ràng buộc đối với các phương thức mở rộng (cụ thể là phương thức mở rộng sẽ không bao giờ ghi đè một phương thức được kế thừa có cùng chữ ký ), có thể có tình huống phương thức tiện ích mở rộng tùy chỉnh có sẵn trên tất cả các lớp. Vô số <T> ngoại trừ Danh sách <T>. Điều này có thể gây nhầm lẫn khi các phương thức bắt đầu hành xử khác nhau tùy thuộc vào việc phương thức mở rộng hoặc phương thức kế thừa đang được gọi.

Bạn có thể sử dụng (có thể đánh giá được, nhưng được đánh giá một cách lười biếng) Select, trước tiên thực hiện thao tác của bạn và sau đó trả lại danh tính (hoặc một cái gì đó khác nếu bạn muốn)

IEnumerable<string> people = new List<string>(){"alica", "bob", "john", "pete"};
people.Select(p => { Console.WriteLine(p); return p; });

Bạn sẽ cần đảm bảo rằng nó vẫn được đánh giá, bằng Count()(hoạt động rẻ nhất để liệt kê afaik) hoặc hoạt động khác mà bạn cần dù sao đi nữa.

Tôi rất thích nhìn thấy nó được đưa vào thư viện tiêu chuẩn:

static IEnumerable<T> WithLazySideEffect(this IEnumerable<T> src, Action<T> action) {
  return src.Select(i => { action(i); return i; } );
}

Các mã trên sau đó trở thành people.WithLazySideEffect(p => Console.WriteLine(p))tương đương hiệu quả với foreach, nhưng lười biếng và có thể xâu chuỗi.

Lưu ý rằng MoreLINEQ NuGet cung cấp ForEachphương thức mở rộng mà bạn đang tìm kiếm (cũng như Pipephương thức thực thi ủy nhiệm và mang lại kết quả của nó). Xem:

• https://www.nuget.org/packages/morelinq
• https://code.google.com.vn/p/morelinq/wiki/OperatorsOverview

@ Bitcoin

Sức mạnh thực sự của phương thức mở rộng foreach liên quan đến khả năng sử dụng lại Action<>mà không cần thêm các phương thức không cần thiết vào mã của bạn. Giả sử bạn có 10 danh sách và bạn muốn thực hiện cùng một logic trên chúng và một hàm tương ứng không phù hợp với lớp của bạn và không được sử dụng lại. Thay vì có mười vòng lặp, hoặc một hàm chung rõ ràng là một trình trợ giúp không thuộc về, bạn có thể giữ tất cả logic của mình ở một nơi ( Action<>vì vậy, hàng chục dòng được thay thế bằng

Action<blah,blah> f = { foo };

List1.ForEach(p => f(p))
List2.ForEach(p => f(p))

Vân vân...

Logic ở một nơi và bạn đã không làm ô nhiễm lớp học của mình.

Hầu hết các phương pháp mở rộng LINQ trả về kết quả. ForEach không phù hợp với mẫu này vì nó không trả về gì cả.

Nếu bạn có F # (sẽ có trong phiên bản .NET tiếp theo), bạn có thể sử dụng

Seq.iter doSomething myIEnumerable

Một phần là do các nhà thiết kế ngôn ngữ không đồng ý với nó từ góc độ triết học.

• Không có (và thử nghiệm ...) một tính năng sẽ ít hoạt động hơn so với việc có một tính năng.
• Nó không thực sự ngắn hơn (có một số trường hợp chức năng vượt qua, nhưng đó không phải là sử dụng chính).
• Mục đích của nó là có tác dụng phụ, đó không phải là vấn đề của linq.
• Tại sao có một cách khác để làm điều tương tự như một tính năng chúng ta đã có? (từ khóa foreach)

https://bloss.msdn.microsoft.com/ericlippert/2009/05/18/foreach-vs-foreach/

Bạn có thể sử dụng chọn khi bạn muốn trả lại một cái gì đó. Nếu bạn không, bạn có thể sử dụng ToList trước, vì có lẽ bạn không muốn sửa đổi bất cứ điều gì trong bộ sưu tập.

Tôi đã viết một bài đăng trên blog về nó: http://bloss.msdn.com/kirillosenkov/archive/2009/01/31/foreach.aspx

Bạn có thể bỏ phiếu tại đây nếu bạn muốn xem phương thức này trong .NET 4.0: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=279093

Trong 3.5, tất cả các phương thức mở rộng được thêm vào IEnumerable đều có hỗ trợ LINQ (lưu ý rằng chúng được định nghĩa trong lớp System.Linq.Enumerable). Trong bài đăng này, tôi giải thích tại sao foreach không thuộc về LINQ: Phương thức mở rộng LINQ hiện tại tương tự như Parallel.For?

Là tôi hay là Danh sách <T>. Phần lớn đã bị Linq làm cho lỗi thời. Ban đầu có

foreach(X x in Y) 

trong đó Y đơn giản phải là IEnumerable (Pre 2.0) và triển khai GetEnumerator (). Nếu bạn nhìn vào MSIL được tạo ra, bạn có thể thấy rằng nó giống hệt như

IEnumerator<int> enumerator = list.GetEnumerator();
while (enumerator.MoveNext())
{
    int i = enumerator.Current;

    Console.WriteLine(i);
}

(Xem http://alski.net/post/0a-for-foreach-forFirst-forLast0a-0a-.aspx cho MSIL)

Sau đó, trong DotNet2.0 Generics xuất hiện và Danh sách. Foreach luôn cảm thấy với tôi là một triển khai của mẫu Vistor, (xem Mẫu thiết kế của Gamma, Helm, Johnson, Vlissides).

Bây giờ tất nhiên trong 3,5, thay vào đó, chúng ta có thể sử dụng Lambda để có hiệu quả tương tự, ví dụ: thử http://dotnet-developments.bloss.techtarget.com/2008/09/02/iterators-lambda-and-linq-oh- của tôi /

Tôi muốn mở rộng câu trả lời của Aku .

Nếu bạn muốn gọi một phương thức cho mục đích duy nhất là hiệu ứng phụ của nó mà không lặp lại toàn bộ số đầu tiên, bạn có thể sử dụng phương thức này:

private static IEnumerable<T> ForEach<T>(IEnumerable<T> xs, Action<T> f) {
    foreach (var x in xs) {
        f(x); yield return x;
    }
}

Không ai đã chỉ ra rằng ForEach <T> dẫn đến việc kiểm tra kiểu thời gian biên dịch trong đó từ khóa foreach được kiểm tra thời gian chạy.

Đã thực hiện một số phép tái cấu trúc trong đó cả hai phương thức được sử dụng trong mã, tôi ủng hộ .orEach, vì tôi phải tìm kiếm các lỗi thử nghiệm / lỗi thời gian chạy để tìm các vấn đề về foreach.