Setara dengan LINQ untuk IEnumerable <T>

Saya ingin melakukan yang setara dengan yang berikut ini di LINQ, tapi saya tidak tahu caranya:

IEnumerable<Item> items = GetItems();
items.ForEach(i => i.DoStuff());

Apa sintaks yang sebenarnya?

Tidak ada ekstensi ForEach untuk IEnumerable; hanya untuk List<T>. Jadi kamu bisa melakukannya

items.ToList().ForEach(i => i.DoStuff());

Atau, tulis metode ekstensi ForEach Anda sendiri:

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

Fredrik telah memberikan perbaikan, tetapi mungkin layak mempertimbangkan mengapa ini tidak dalam kerangka untuk memulai. Saya percaya idenya adalah bahwa operator kueri LINQ harus bebas efek samping, cocok dengan cara yang cukup fungsional dalam memandang dunia. Jelas ForEach justru sebaliknya - sebuah konstruksi berbasis efek samping murni .

Itu bukan untuk mengatakan ini adalah hal yang buruk untuk dilakukan - hanya memikirkan alasan filosofis di balik keputusan.

Pembaruan 7/17/2012: Rupanya pada C # 5.0, perilaku yang foreachdijelaskan di bawah ini telah diubah dan " penggunaan foreachvariabel iterasi dalam ekspresi lambda bersarang tidak lagi menghasilkan hasil yang tidak terduga. " Jawaban ini tidak berlaku untuk C # ≥ 5.0 .

@John Skeet dan semua orang yang lebih suka kata kunci foreach.

Masalah dengan "foreach" dalam C # sebelum 5.0 , adalah bahwa itu tidak konsisten dengan cara yang setara "untuk pemahaman" bekerja dalam bahasa lain, dan dengan bagaimana saya mengharapkannya bekerja (pendapat pribadi yang dinyatakan di sini hanya karena orang lain telah menyebutkan mereka pendapat tentang keterbacaan). Lihat semua pertanyaan tentang " Akses ke penutupan yang dimodifikasi " serta " Menutup variabel loop yang dianggap berbahaya ". Ini hanya "berbahaya" karena cara "foreach" diimplementasikan dalam C #.

Ambil contoh berikut menggunakan metode ekstensi yang setara secara fungsional dengan yang ada di jawaban @Fredrik Kalseth.

public static class Enumerables
{
    public static void ForEach<T>(this IEnumerable<T> @this, Action<T> action)
    {
        foreach (T item in @this)
        {
            action(item);
        }
    }
}

Permintaan maaf untuk contoh yang terlalu dibuat-buat. Saya hanya menggunakan Observable karena tidak sepenuhnya diambil untuk melakukan sesuatu seperti ini. Jelas ada cara yang lebih baik untuk membuat ini dapat diamati, saya hanya berusaha menunjukkan suatu hal. Biasanya kode yang berlangganan observable dijalankan secara tidak serempak dan berpotensi di utas lainnya. Jika menggunakan "foreach", ini bisa menghasilkan hasil yang sangat aneh dan berpotensi non-deterministik.

Tes berikut menggunakan metode ekstensi "ForEach" lolos:

[Test]
public void ForEachExtensionWin()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                values.ForEach(value => 
                                    source.OnNext(() => value));

                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Win
    Assert.That(evaluatedObservable, 
        Is.EquivalentTo(values.ToList()));
}

Berikut ini gagal dengan kesalahan:

Diharapkan: setara dengan <0, 1, 2, 3, 4, 5, 6, 7, 8, 9> Tetapi adalah: <9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9>

[Test]
public void ForEachKeywordFail()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                foreach (var value in values)
                                {
                                    //If you have resharper, notice the warning
                                    source.OnNext(() => value);
                                }
                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Fail
    Assert.That(evaluatedObservable, 
        Is.EquivalentTo(values.ToList()));
}

Anda dapat menggunakan FirstOrDefault()ekstensi yang tersedia untuk IEnumerable<T>. Dengan kembali falsedari predikat, itu akan dijalankan untuk setiap elemen tetapi tidak akan peduli bahwa itu tidak benar-benar menemukan kecocokan. Ini akan menghindari ToList()overhead.

IEnumerable<Item> items = GetItems();
items.FirstOrDefault(i => { i.DoStuff(); return false; });

Saya mengambil metode Fredrik dan memodifikasi tipe pengembalian.

Dengan cara ini, metode ini mendukung eksekusi yang ditangguhkan seperti metode LINQ lainnya.

EDIT: Jika ini tidak jelas, segala penggunaan metode ini harus diakhiri dengan ToList () atau cara lain untuk memaksa metode untuk bekerja pada enumerable lengkap. Jika tidak, tindakan tidak akan dilakukan!

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
{
    foreach (T item in enumeration)
    {
        action(item);
        yield return item;
    }
}

Dan inilah tes untuk membantu melihatnya:

[Test]
public void TestDefferedExecutionOfIEnumerableForEach()
{
    IEnumerable<char> enumerable = new[] {'a', 'b', 'c'};

    var sb = new StringBuilder();

    enumerable
        .ForEach(c => sb.Append("1"))
        .ForEach(c => sb.Append("2"))
        .ToList();

    Assert.That(sb.ToString(), Is.EqualTo("121212"));
}

Jika Anda menghapus ToList () pada akhirnya, Anda akan melihat tes gagal karena StringBuilder berisi string kosong. Ini karena tidak ada metode yang memaksa ForEach untuk menghitung.

Jauhkan Efek Samping Anda dari IEnumerable saya

Saya ingin melakukan yang setara dengan yang berikut ini di LINQ, tapi saya tidak tahu caranya:

Seperti yang orang lain tunjukkan di sini dan di luar negeri, LINQ danIEnumerable metode diharapkan bebas efek samping.

Apakah Anda benar-benar ingin "melakukan sesuatu" untuk setiap item di IEnumerable? Maka foreachmerupakan pilihan terbaik. Orang-orang tidak terkejut ketika efek samping terjadi di sini.

foreach (var i in items) i.DoStuff();

Saya yakin Anda tidak ingin efek samping

Namun dalam pengalaman saya efek samping biasanya tidak diperlukan. Lebih sering daripada tidak ada permintaan LINQ sederhana menunggu untuk ditemukan disertai dengan jawaban StackOverflow.com oleh Jon Skeet, Eric Lippert, atau Marc Gravell menjelaskan bagaimana melakukan apa yang Anda inginkan!

Beberapa contoh

Jika Anda sebenarnya hanya mengagregasi (mengakumulasi) beberapa nilai maka Anda harus mempertimbangkan Aggregatemetode ekstensi.

items.Aggregate(initial, (acc, x) => ComputeAccumulatedValue(acc, x));

Mungkin Anda ingin membuat yang baru IEnumerabledari nilai yang ada.

items.Select(x => Transform(x));

Atau mungkin Anda ingin membuat tabel pencarian:

items.ToLookup(x, x => GetTheKey(x))

Daftar (pun kata yang tidak sepenuhnya dimaksudkan) tentang kemungkinan berlanjut dan terus.

Jika Anda ingin bertindak sebagai gulungan enumerasi, Anda harus menghasilkan setiap item.

public static class EnumerableExtensions
{
    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
    {
        foreach (var item in enumeration)
        {
            action(item);
            yield return item;
        }
    }
}

Ada rilis eksperimental oleh Microsoft untuk Interactive Extensions to LINQ (juga di NuGet , lihat profil RxTeams untuk tautan lainnya). Video Channel 9 menjelaskannya dengan baik.

Dokumennya hanya disediakan dalam format XML. Saya telah menjalankan dokumentasi ini di Sandcastle untuk membuatnya dalam format yang lebih mudah dibaca. Buka zip arsip docs dan cari index.html .

Di antara banyak barang lainnya, ini menyediakan implementasi ForEach yang diharapkan. Anda dapat menulis kode seperti ini:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };

numbers.ForEach(x => Console.WriteLine(x*x));

Menurut PLINQ (tersedia sejak .Net 4.0), Anda dapat melakukan

IEnumerable<T>.AsParallel().ForAll() 

untuk melakukan loop foreach paralel pada IEnumerable.

Tujuan dari ForEach adalah untuk menimbulkan efek samping. IEnumerable adalah untuk enumerasi satu set yang malas.

Perbedaan konseptual ini cukup terlihat ketika Anda mempertimbangkannya.

SomeEnumerable.ForEach(item=>DataStore.Synchronize(item));

Ini tidak akan dijalankan sampai Anda melakukan "menghitung" atau "Daftar ()" atau sesuatu di atasnya. Jelas bukan apa yang diungkapkan.

Anda harus menggunakan ekstensi IEnumerable untuk menyiapkan rantai iterasi, menentukan konten berdasarkan sumber dan ketentuan masing-masing. Pohon Ekspresi kuat dan efisien, tetapi Anda harus belajar untuk menghargai sifat mereka. Dan tidak hanya untuk pemrograman di sekitar mereka untuk menyimpan beberapa karakter yang mengesampingkan evaluasi malas.

Banyak orang yang menyebutkannya, tetapi saya harus menuliskannya. Bukankah ini paling jelas / paling mudah dibaca?

IEnumerable<Item> items = GetItems();
foreach (var item in items) item.DoStuff();

Singkat dan sederhana.

Sekarang kami memiliki opsi untuk ...

        ParallelOptions parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 4;
#if DEBUG
        parallelOptions.MaxDegreeOfParallelism = 1;
#endif
        Parallel.ForEach(bookIdList, parallelOptions, bookID => UpdateStockCount(bookID));

Tentu saja, ini membuka kaleng ulat baru.

ps (Maaf tentang font, itu yang diputuskan sistem)

Seperti yang sudah ditunjukkan oleh banyak jawaban, Anda dapat dengan mudah menambahkan sendiri metode perluasan semacam itu. Namun, jika Anda tidak ingin melakukan itu, meskipun saya tidak mengetahui hal seperti ini di BCL, masih ada opsi di Systemnamespace, jika Anda sudah memiliki referensi ke Reactive Extension (dan jika Anda tidak , Kamu harus punya):

using System.Reactive.Linq;

items.ToObservable().Subscribe(i => i.DoStuff());

Meskipun nama metode sedikit berbeda, hasil akhirnya adalah persis apa yang Anda cari.

ForEach juga dapat Dirantai , cukup kembalikan ke pileline setelah tindakan. tetap fasih

Employees.ForEach(e=>e.Act_A)
         .ForEach(e=>e.Act_B)
         .ForEach(e=>e.Act_C);

Orders  //just for demo
    .ForEach(o=> o.EmailBuyer() )
    .ForEach(o=> o.ProcessBilling() )
    .ForEach(o=> o.ProcessShipping());


//conditional
Employees
    .ForEach(e=> {  if(e.Salary<1000) e.Raise(0.10);})
    .ForEach(e=> {  if(e.Age   >70  ) e.Retire();});

Sebuah Bersemangat versi implementasi.

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enu, Action<T> action)
{
    foreach (T item in enu) action(item);
    return enu; // make action Chainable/Fluent
}

Edit: a Malas versi menggunakan yield return, seperti ini .

public static IEnumerable<T> ForEachLazy<T>(this IEnumerable<T> enu, Action<T> action)
{
    foreach (var item in enu)
    {
        action(item);
        yield return item;
    }
}

Versi Malas PERLU terwujud, ToList () misalnya, jika tidak, tidak ada yang terjadi. lihat di bawah komentar hebat dari ToolmakerSteve.

IQueryable<Product> query = Products.Where(...);
query.ForEachLazy(t => t.Price = t.Price + 1.00)
    .ToList(); //without this line, below SubmitChanges() does nothing.
SubmitChanges();

Saya menyimpan ForEach () dan ForEachLazy () di perpustakaan saya.

Abstraksi "pendekatan fungsional" ini bocor banyak waktu. Tidak ada pada tingkat bahasa yang mencegah efek samping. Selama Anda bisa membuatnya memanggil lambda / delegasi Anda untuk setiap elemen dalam wadah - Anda akan mendapatkan perilaku "ForEach".

Di sini misalnya satu cara menggabungkan srcDictionary ke destDictionary (jika kunci sudah ada - ditimpa)

ini adalah hack, dan tidak boleh digunakan dalam kode produksi apa pun.

var b = srcDictionary.Select(
                             x=>
                                {
                                  destDictionary[x.Key] = x.Value;
                                  return true;
                                }
                             ).Count();

Terinspirasi oleh Jon Skeet, saya telah memperluas solusinya dengan yang berikut:

Metode ekstensi:

public static void Execute<TSource, TKey>(this IEnumerable<TSource> source, Action<TKey> applyBehavior, Func<TSource, TKey> keySelector)
{
    foreach (var item in source)
    {
        var target = keySelector(item);
        applyBehavior(target);
    }
}

Klien:

var jobs = new List<Job>() 
    { 
        new Job { Id = "XAML Developer" }, 
        new Job { Id = "Assassin" }, 
        new Job { Id = "Narco Trafficker" }
    };

jobs.Execute(ApplyFilter, j => j.Id);

. . .

    public void ApplyFilter(string filterId)
    {
        Debug.WriteLine(filterId);
    }

MoreLinq memiliki IEnumerable<T>.ForEachdan banyak ekstensi berguna lainnya. Mungkin tidak pantas hanya untuk ketergantungan ForEach, tetapi ada banyak hal berguna di sana.

https://www.nuget.org/packages/morelinq/

https://github.com/morelinq/MoreLINQ

Saya dengan hormat tidak setuju dengan gagasan bahwa metode ekstensi tautan harus bebas efek samping (bukan hanya karena tidak, delegasi mana pun dapat melakukan efek samping).

Pertimbangkan yang berikut ini:

   public class Element {}

   public Enum ProcessType
   {
      This = 0, That = 1, SomethingElse = 2
   }

   public class Class1
   {
      private Dictionary<ProcessType, Action<Element>> actions = 
         new Dictionary<ProcessType,Action<Element>>();

      public Class1()
      {
         actions.Add( ProcessType.This, DoThis );
         actions.Add( ProcessType.That, DoThat );
         actions.Add( ProcessType.SomethingElse, DoSomethingElse );
      }

      // Element actions:

      // This example defines 3 distict actions
      // that can be applied to individual elements,
      // But for the sake of the argument, make
      // no assumption about how many distict
      // actions there may, and that there could
      // possibly be many more.

      public void DoThis( Element element )
      {
         // Do something to element
      }

      public void DoThat( Element element )
      {
         // Do something to element
      }

      public void DoSomethingElse( Element element )
      {
         // Do something to element
      }

      public void Apply( ProcessType processType, IEnumerable<Element> elements )
      {
         Action<Element> action = null;
         if( ! actions.TryGetValue( processType, out action ) )
            throw new ArgumentException("processType");
         foreach( element in elements ) 
            action(element);
      }
   }

Apa yang ditunjukkan contoh ini adalah benar-benar semacam ikatan yang memungkinkan seseorang memanggil salah satu dari banyak tindakan yang mungkin memiliki efek samping pada urutan elemen, tanpa harus menulis konstruksi saklar besar untuk memecahkan kode nilai yang mendefinisikan tindakan dan menerjemahkan ke dalam metode yang sesuai.

Agar tetap lancar, seseorang dapat menggunakan trik seperti ini:

GetItems()
    .Select(i => new Action(i.DoStuf)))
    .Aggregate((a, b) => a + b)
    .Invoke();

Untuk VB.NET Anda harus menggunakan:

listVariable.ForEach(Sub(i) i.Property = "Value")

ForEachContoh lain lagi

public static IList<AddressEntry> MapToDomain(IList<AddressModel> addresses)
{
    var workingAddresses = new List<AddressEntry>();

    addresses.Select(a => a).ToList().ForEach(a => workingAddresses.Add(AddressModelMapper.MapToDomain(a)));

    return workingAddresses;
}