IEnumerable için foreach'in LINQ eşdeğeri <T>

LINQ'da aşağıdakilerin eşdeğerini yapmak istiyorum, ancak nasıl olduğunu anlayamıyorum:

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

Gerçek sözdizimi nedir?

İçin herhangi bir ForEach uzantısı yoktur IEnumerable; sadece List<T>. Böylece yapabilirsin

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

Alternatif olarak, kendi ForEach uzantı yönteminizi yazın:

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

Fredrik düzeltmeyi sağladı, ancak bunun neden başlangıçta çerçeve içinde olmadığını düşünmeye değer olabilir. Fikir LINQ sorgu operatörleri dünyaya makul bir işlevsel şekilde uygun, yan etkisi ücretsiz olması gerektiğine inanıyorum. Açıkça ForEach tam tersi - tamamen yan etkiye dayalı bir yapı.

Bu, bunun kararın arkasındaki felsefi nedenleri düşünerek kötü bir şey olduğunu söylemek değildir.

Güncelleme 7/17/2012: Görünüşe göre C # 5.0'dan itibaren foreach, aşağıda açıklanan davranış değiştirildi ve " iç içe lambda ifadesinde yineleme değişkeninin kullanımı foreachartık beklenmedik sonuçlar üretmiyor . " Bu yanıt C # ≥ 5.0 için geçerli değil .

@ John Skeet ve foreach anahtar kelimesini tercih eden herkes.

5.0'dan önceki C #'da "foreach" ile ilgili sorun, " anlama için" eşdeğerinin diğer dillerde nasıl çalıştığı ve nasıl çalışacağını beklediğim ile tutarsız olmasıdır (kişisel görüş burada sadece diğerleri tarafından belirtildiği için belirtilmiştir. okunabilirlik ile ilgili görüş). " Değiştirilmiş kapanışa erişim " ve " Zararlı sayılan döngü değişkeninin kapatılması " ile ilgili tüm soruları görün . Bu sadece "zararlı" çünkü "foreach" C # uygulanan yolu.

@Fredrik Kalseth'in cevabındaki işlevsel olarak eşdeğer uzatma yöntemini kullanarak aşağıdaki örnekleri alın.

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

Aşırı tartışılmış örnek için özür dilerim. Sadece Gözlemlenebilir'i kullanıyorum çünkü böyle bir şey yapmak tamamen zor değil. Açıkçası bu gözlemlenebilir yaratmanın daha iyi yolları var, sadece bir noktaya göstermeye çalışıyorum. Tipik olarak gözlemlenebilir öğeye abone olunan kod, eşzamansız olarak ve potansiyel olarak başka bir iş parçacığında yürütülür. "Foreach" kullanılıyorsa, bu çok garip ve potansiyel olarak deterministik olmayan sonuçlar doğurabilir.

"ForEach" uzantısı yöntemini kullanarak aşağıdaki test geçer:

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

Aşağıdakiler hatayla başarısız olur:

Beklenen: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ile eşdeğer> Ama şuydu: <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()));
}

İçin kullanılabilir olan FirstOrDefault()uzantıyı kullanabilirsiniz IEnumerable<T>. Yüklemden dönerek false, her öğe için çalıştırılacak, ancak aslında bir eşleşme bulamaması umurumda olmayacak. Bu ToList()ek yükü önleyecektir .

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

Fredrik'in yöntemini kullandım ve dönüş türünü değiştirdim.

Bu şekilde yöntem, diğer LINQ yöntemleri gibi ertelenmiş yürütmeyi destekler .

DÜZENLEME: Bu açık değilse, bu yöntemin herhangi bir kullanımı ToList () veya yöntemi numaralandırılabilir tam olarak çalışmaya zorlamak için başka bir yol ile bitmelidir . Aksi takdirde eylem gerçekleştirilmez!

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

Ve işte görmenize yardımcı olacak test:

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

Sonunda ToList () öğesini kaldırırsanız, StringBuilder boş bir dize içerdiğinden sınamanın başarısız olduğunu görürsünüz. Çünkü hiçbir yöntem ForEach'ı numaralandırmaya zorlamamıştır.

Yan Etkilerinizi IEnumerable'ımdan uzak tutun

LINQ'da aşağıdakilerin eşdeğerini yapmak istiyorum, ancak nasıl olduğunu anlayamıyorum:

Diğerlerinin de burada ve yurtdışında işaret ettiği gibi LINQ ve IEnumerableyöntemlerin yan etkisiz olması beklenmektedir.

IEnumerable'daki her öğeye gerçekten "bir şeyler" yapmak istiyor musunuz? O zaman foreachen iyi seçimdir. Burada yan etkiler olduğunda insanlar şaşırmazlar.

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

Eminim yan etki istemezsin

Ancak tecrübelerime göre yan etkiler genellikle gerekli değildir. Çoğu zaman, Jon Skeet, Eric Lippert veya Marc Gravell tarafından bir StackOverflow.com yanıtıyla keşfedilmeyi bekleyen basit bir LINQ sorgusu vardır.

Bazı örnekler

Aslında sadece bir değer toplarsanız (biriktirirseniz), Aggregateuzantı yöntemini göz önünde bulundurmalısınız .

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

Belki de yeni bir IEnumerable mevcut değerlerden .

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

Veya belki de bir arama tablosu oluşturmak istersiniz:

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

Olasılıklar listesi (tamamen amaçlanmamıştır) devam etmektedir.

Harekete istiyorsanız numaralandırma sen gerektiğini rulo olarak verim her öğeyi.

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

Microsoft tarafından deneysel bir sürüm var LINQ için Etkileşimli Extensions (ayrıca Nuget üzerine , bkz RxTeams profili daha bağlantılar için). Kanal 9 video iyi açıklıyor.

Dokümanları yalnızca XML biçiminde sağlanır. Bu belgeleri daha okunaklı bir formatta olmasını sağlamak için Sandcastle'da çalıştırdım . Dokümanlar arşivini açın ve index.html dosyasını arayın .

Diğer pek çok güzellik arasında, beklenen ForEach uygulamasını sağlar. Bunun gibi bir kod yazmanıza izin verir:

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

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

PLINQ'ya (.Net 4.0'dan beri kullanılabilir) göre,

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

IEnumerable üzerinde paralel bir foreach döngüsü yapmak.

ForEach'ın amacı yan etkilere neden olmaktır. IEnumerable bir setin tembel numaralandırması içindir.

Bu kavramsal fark, düşündüğünüzde oldukça görünür.

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

Bu, bir "sayım" veya "ToList ()" veya üzerinde bir şey yapana kadar yürütülmez. Açıkça ifade edilen şey bu değildir.

Yineleme zincirlerini ayarlamak, içeriği ilgili kaynaklarına ve koşullarına göre tanımlamak için IEnumerable uzantılarını kullanmalısınız. İfade Ağaçlar güçlü ve etkilidir, ancak doğalarını takdir etmeyi öğrenmelisiniz. Ve tembel değerlendirmeyi geçersiz kılan birkaç karakteri kaydetmek için sadece programlamak için değil.

Birçok insan bundan bahsetti, ama yazmak zorunda kaldım. Bu en açık / en okunabilir değil mi?

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

Kısa ve basit (st).

Şimdi seçeneği var ...

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

Tabii ki, bu yepyeni bir iplik solucanı kutusu açar.

ps (Yazı tipleri için üzgünüm, sistemin karar verdiği şey)

Çok sayıda cevabın işaret ettiği gibi, böyle bir uzatma yöntemini kendiniz kolayca ekleyebilirsiniz. Ancak, bunu yapmak istemiyorsanız, BCL'de böyle bir şeyin farkında olmasam da, Systemzaten Reaktif Uzantıya bir referansınız varsa (ve eğer , sahip olmalıdır):

using System.Reactive.Linq;

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

Yöntem adları biraz farklı olsa da, sonuç tam olarak aradığınız şeydir.

ForEach da Zincirleme olabilir , sadece eylemden sonra pileline geri koyun. akıcı kal

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

Uygulamanın istekli bir sürümü.

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
}

Düzenleme: Bir Tembel versiyonu gibi, verim dönüşü kullanıyor bu .

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

Tembel versiyonun gerçekleşmesi GEREKİR , örneğin ToList (), aksi takdirde hiçbir şey olmaz. ToolmakerSteve'nin harika yorumlarına bakın.

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

Hem ForEach () hem de ForEachLazy () 'i kütüphanemde saklıyorum.

Bu "işlevsel yaklaşım" soyutlaması büyük zaman sızdırıyor. Dil seviyesindeki hiçbir şey yan etkileri engellemez. Kaptaki her öğe için lambda / delege çağrısı yapabildiğiniz sürece "ForEach" davranışını elde edersiniz.

Burada örneğin srcDictionary'ü destDictionary ile birleştirmenin bir yolu (anahtar zaten varsa - üzerine yazılır)

bu bir hack'tir ve herhangi bir üretim kodunda kullanılmamalıdır.

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

Jon Skeet'ten ilham alarak çözümünü aşağıdakilerle genişlettim:

Genişletme Yöntemi:

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

Müşteri:

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 IEnumerable<T>.ForEachve bir dizi başka faydalı uzantıya sahiptir. Muhtemelen sadece bağımlılığı almaya değmez ForEach, ama orada birçok yararlı şey var.

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

https://github.com/morelinq/MoreLINQ

Bağlantı uzatma yöntemlerinin yan etkiden arındırılmış olması gerektiği fikrine katılmıyorum (sadece herhangi bir delege yan etki yapamayacağı için değil).

Aşağıdakileri göz önünde bulundur:

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

Örneğin gösterdiği şey, gerçekten, bir eylemi tanımlayan değeri çevirmek ve çevirmek için büyük bir anahtar yapısı yazmak zorunda kalmadan, bir dizi öğe üzerinde yan etkileri olan birçok olası eylemden birini çağırmaya izin veren bir tür geç bağlamadır. karşılık gelen yönteme.

Akıcı kalmak için böyle bir numara kullanılabilir:

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

VB.NET için şunları kullanmalısınız:

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

Yine başka bir ForEachörnek

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