Mengapa tidak ada metode ekstensi ForEach di IEnumerable?

Terinspirasi oleh pertanyaan lain yang menanyakan tentang Zipfungsi yang hilang :

Mengapa tidak ada ForEachmetode ekstensi di Enumerablekelas? Atau dimana saja? Satu-satunya kelas yang mendapat ForEachmetode adalah List<>. Apakah ada alasan mengapa itu hilang (kinerja)?

Sudah ada pernyataan pendahuluan termasuk dalam bahasa yang melakukan pekerjaan sebagian besar waktu.

Aku benci melihat yang berikut ini:

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

Dari pada:

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

Yang terakhir ini lebih jelas dan lebih mudah dibaca di sebagian besar situasi , meskipun mungkin sedikit lebih lama untuk mengetik.

Namun, saya harus mengakui bahwa saya mengubah pendirian saya tentang masalah itu; metode ekstensi ForEach () memang akan berguna dalam beberapa situasi.

Berikut adalah perbedaan utama antara pernyataan dan metode:

• Pengecekan tipe: foreach dilakukan pada saat runtime, ForEach () berada pada waktu kompilasi (Plus Besar!)
• Sintaks untuk memanggil delegasi memang lebih sederhana: objek.ForEach (DoSomething);
• ForEach () dapat dirantai: meskipun kejahatan / kegunaan fitur tersebut terbuka untuk diskusi.

Itu semua adalah poin bagus yang dibuat oleh banyak orang di sini dan saya dapat melihat mengapa orang kehilangan fungsi. Saya tidak keberatan Microsoft menambahkan metode ForEach standar dalam iterasi kerangka kerja berikutnya.

Metode ForEach ditambahkan sebelum LINQ. Jika Anda menambahkan ekstensi ForEach, itu tidak akan pernah dipanggil untuk instance Daftar karena kendala metode ekstensi. Saya pikir alasannya tidak ditambahkan adalah untuk tidak mengganggu yang sudah ada.

Namun, jika Anda benar-benar kehilangan fungsi kecil yang menyenangkan ini, Anda dapat meluncurkan versi Anda sendiri

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

Anda dapat menulis metode ekstensi ini:

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

Pro

Memungkinkan chaining:

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

Cons

Ini tidak akan benar-benar melakukan apa pun sampai Anda melakukan sesuatu untuk memaksa iterasi. Karena itu, itu tidak boleh disebut .ForEach(). Anda bisa menulis .ToList()di akhir, atau menulis metode ekstensi ini juga:

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

    return source;
}

Ini mungkin terlalu signifikan keberangkatan dari perpustakaan C # pengiriman; pembaca yang tidak terbiasa dengan metode ekstensi Anda tidak akan tahu apa yang membuat kode Anda.

Diskusi di sini memberikan jawabannya:

Sebenarnya, diskusi spesifik yang saya saksikan ternyata bergantung pada kemurnian fungsional. Dalam sebuah ekspresi, sering ada asumsi yang dibuat tentang tidak memiliki efek samping. Memiliki ForEach secara khusus mengundang efek samping daripada hanya bertahan dengan mereka. - Petani Keith (Mitra)

Pada dasarnya keputusan dibuat untuk menjaga metode penyuluhan fungsional "murni". ForEach akan mendorong efek samping saat menggunakan metode ekstensi Enumerable, yang bukan tujuannya.

Sementara saya setuju bahwa lebih baik menggunakan built-in foreachconstruct dalam banyak kasus, saya menemukan penggunaan variasi ini pada ekstensi <Enach <> menjadi sedikit lebih baik daripada harus mengelola indeks secara teratur 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));

Akan memberi Anda:

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

Salah satu solusinya adalah menulis .ToList().ForEach(x => ...).

pro

Mudah dimengerti - pembaca hanya perlu tahu apa yang dikirim dengan C #, bukan metode ekstensi tambahan.

Kebisingan sintaksis sangat ringan (hanya menambahkan sedikit kode tambahan).

Biasanya tidak memerlukan memori ekstra, karena penduduk asli .ForEach()harus menyadari seluruh koleksinya.

kontra

Urutan operasi tidak ideal. Saya lebih suka menyadari satu elemen, lalu menindaklanjutinya, lalu ulangi. Kode ini menyadari semua elemen terlebih dahulu, kemudian bertindak masing-masing secara berurutan.

Jika menyadari daftar melempar pengecualian, Anda tidak pernah bisa bertindak pada satu elemen.

Jika enumerasi tidak terbatas (seperti angka alami), Anda kurang beruntung.

Saya selalu bertanya-tanya sendiri, itulah sebabnya saya selalu membawa ini:

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

Metode ekstensi kecil yang bagus.

Jadi ada banyak komentar tentang fakta bahwa metode ekstensi ForEach tidak tepat karena tidak mengembalikan nilai seperti metode ekstensi LINQ. Meskipun ini adalah pernyataan faktual, itu tidak sepenuhnya benar.

Metode ekstensi LINQ melakukan semua mengembalikan nilai sehingga mereka dapat dirantai bersama:

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

Namun, hanya karena LINQ diimplementasikan menggunakan metode ekstensi tidak berarti metode ekstensi harus digunakan dengan cara yang sama dan mengembalikan nilai. Menulis metode ekstensi untuk mengekspos fungsionalitas umum yang tidak mengembalikan nilai adalah penggunaan yang benar-benar valid.

Argumen khusus tentang ForEach adalah bahwa, berdasarkan batasan pada metode ekstensi (yaitu bahwa metode ekstensi tidak akan pernah menimpa metode yang diwariskan dengan tanda tangan yang sama ), mungkin ada situasi di mana metode ekstensi kustom tersedia di semua kelas yang menerapkan Tidak dapat dihitung <T> kecuali Daftar <T>. Ini dapat menyebabkan kebingungan ketika metode mulai berperilaku berbeda tergantung pada apakah metode ekstensi atau metode warisan dipanggil.

Anda dapat menggunakan (dapat ditagih, tetapi dievaluasi malas) Select, pertama melakukan operasi Anda, dan kemudian mengembalikan identitas (atau sesuatu yang lain jika Anda suka)

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

Anda harus memastikan itu masih dievaluasi, baik dengan Count()(operasi termurah untuk menyebutkan afaik) atau operasi lain yang Anda perlukan.

Saya ingin melihatnya dibawa ke perpustakaan standar:

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

Kode di atas kemudian menjadi people.WithLazySideEffect(p => Console.WriteLine(p))yang secara efektif setara dengan foreach, tetapi malas dan rantai.

Perhatikan bahwa MoreLINQ NuGet menyediakan ForEachmetode ekstensi yang Anda cari (serta Pipemetode yang mengeksekusi delegasi dan menghasilkan hasilnya). Lihat:

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

@Coincoin

Kekuatan sebenarnya dari metode ekstensi foreach melibatkan penggunaan kembali Action<>tanpa menambahkan metode yang tidak perlu ke kode Anda. Katakanlah Anda memiliki 10 daftar dan Anda ingin melakukan logika yang sama pada mereka, dan fungsi yang sesuai tidak masuk ke dalam kelas Anda dan tidak digunakan kembali. Alih-alih memiliki sepuluh untuk loop, atau fungsi generik yang jelas-jelas merupakan helper yang bukan milik, Anda dapat menyimpan semua logika Anda di satu tempat (the Action<>. Jadi, puluhan baris diganti dengan

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

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

dll ...

Logikanya ada di satu tempat dan Anda belum mencemari kelas Anda.

Sebagian besar metode ekstensi LINQ mengembalikan hasil. ForEach tidak cocok dengan pola ini karena tidak mengembalikan apa pun.

Jika Anda memiliki F # (yang akan berada dalam versi .NET berikutnya), Anda dapat menggunakan

Seq.iter doSomething myIEnumerable

Sebagian karena desainer bahasa tidak setuju dengan itu dari perspektif filosofis.

• Tidak memiliki (dan menguji ...) fitur kurang berfungsi daripada memiliki fitur.
• Ini tidak terlalu pendek (ada beberapa kasus fungsi yang lewat di mana itu, tapi itu tidak akan menjadi penggunaan utama).
• Tujuannya adalah untuk memiliki efek samping, yang bukan tentang LINQ.
• Mengapa ada cara lain untuk melakukan hal yang sama dengan fitur yang sudah kita miliki? (kata kunci foreach)

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

Anda dapat menggunakan pilih ketika Anda ingin mengembalikan sesuatu. Jika tidak, Anda dapat menggunakan ToList terlebih dahulu, karena Anda mungkin tidak ingin mengubah apa pun dalam koleksi.

Saya menulis posting blog tentang hal itu: http://blogs.msdn.com/kirillosenkov/archive/2009/01/31/foreach.aspx

Anda dapat memberikan suara di sini jika Anda ingin melihat metode ini dalam .NET 4.0: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=279093

Dalam 3.5, semua metode ekstensi ditambahkan ke IEnumerable ada untuk dukungan LINQ (perhatikan bahwa mereka didefinisikan dalam kelas System.Linq.Enumerable). Dalam posting ini, saya menjelaskan mengapa foreach tidak termasuk dalam LINQ: Metode ekstensi LINQ yang ada mirip dengan Parallel.For?

Apakah saya atau Daftar <T> .Foreach sudah dibuat usang oleh Linq. Awalnya ada

foreach(X x in Y) 

di mana Y hanya harus IEnumerable (Pre 2.0), dan mengimplementasikan GetEnumerator (). Jika Anda melihat MSIL yang dihasilkan, Anda dapat melihat bahwa itu persis sama dengan

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

    Console.WriteLine(i);
}

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

Kemudian di DotNet2.0 Generik datang dan Daftar. Foreach selalu merasa bagi saya untuk menjadi implementasi dari pola Vistor, (lihat Pola Desain oleh Gamma, Helm, Johnson, Vlissides).

Sekarang tentu saja dalam 3,5 kita bisa menggunakan Lambda untuk efek yang sama, misalnya coba http://dotnet-developments.blogs.techtarget.com/2008/09/02/iterators-lambda-and-linq-oh- saya/

Saya ingin memperluas jawaban Aku .

Jika Anda ingin memanggil metode dengan tujuan semata-mata untuk efek samping tanpa mengulangi seluruh enumerable terlebih dahulu, Anda dapat menggunakan ini:

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

Belum ada yang menunjukkan bahwa ForEach <T> menghasilkan kompilasi jenis waktu memeriksa di mana kata kunci foreach diperiksa runtime.

Setelah melakukan beberapa refactoring di mana kedua metode digunakan dalam kode, saya mendukung. ForEach, karena saya harus memburu kegagalan pengujian / kegagalan runtime untuk menemukan masalah pendahuluan.