IEnumerable'da neden ForEach genişletme yöntemi yok?

Eksik Zipfonksiyon hakkında soru soran başka bir sorudan ilham alındı :

Neden sınıfta ForEachuzatma yöntemi yok Enumerable? Veya herhangi bir yerde? Bir ForEachyöntem alan tek sınıf List<>. Eksik olmasının bir nedeni var mı (performans)?

Zaten çoğu zaman işi yapan dilde bir foreach ifadesi var.

Aşağıdakileri görmekten nefret ederim:

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

Onun yerine:

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

İkincisi, yazılması biraz daha uzun olsa da, çoğu durumda daha net ve okunması daha kolaydır .

Ancak, bu konudaki tutumumu değiştirdiğimi itiraf etmeliyim; bir ForEach () uzantısı yöntemi bazı durumlarda gerçekten yararlı olacaktır.

Deyim ve yöntem arasındaki büyük farklar şunlardır:

• Tip kontrolü: foreach çalışma zamanında yapılır, ForEach () derleme zamanındadır (Big Plus!)
• Bir temsilci çağırmak için sözdizimi gerçekten çok daha basittir: objects.ForEach (DoSomething);
• ForEach () zincirlenebilir: böyle bir özelliğin kötülük / kullanışlılığı tartışmaya açık olmasına rağmen.

Bunların hepsi burada birçok insan tarafından yapılan harika noktalar ve insanların neden işlevi kaçırdığını görebiliyorum. Microsoft'un sonraki çerçeve yinelemesinde standart bir ForEach yöntemi eklemesine aldırmam.

ForEach yöntemi LINQ'dan önce eklenmiştir. ForEach uzantısı eklerseniz, uzantı yöntemleri kısıtlamaları nedeniyle hiçbir zaman Liste örnekleri için çağrılmaz. Bence eklenmemesinin sebebi mevcut olanla karışmamaktır.

Ancak, bu küçük hoş işlevi gerçekten kaçırırsanız, kendi sürümünüzü sunabilirsiniz

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

Bu uzantı yöntemini yazabilirsiniz:

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

Artıları

Zincire izin verir:

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

Eksileri

Yinelemeyi zorlamak için bir şey yapana kadar aslında hiçbir şey yapmaz. Bu nedenle çağrılmamalıdır .ForEach(). .ToList()Sonunda yazabilir veya bu uzantı yöntemini de yazabilirsiniz:

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

    return source;
}

Bu, gönderim C # kitaplıklarından ayrılma için çok önemli olabilir; uzantı yöntemlerinize aşina olmayan okuyucular kodunuzu ne yapacağınızı bilemez.

Buradaki tartışma cevap verir:

Aslında, tanık olduğum özel tartışma aslında işlevsel saflığa bağlıydı. Bir ifadede, yan etkilere sahip olmama konusunda sık sık varsayımlar vardır. ForEach'a sahip olmak, sadece onlara katlanmaktan ziyade yan etkileri davet ediyor. - Keith Farmer (Ortak)

Temel olarak genişletme yöntemlerinin işlevsel olarak "saf" tutulmasına karar verildi. ForEach, amaçlanmamış Numaralandırma uzantısı yöntemlerini kullanırken yan etkileri teşvik eder.

foreachÇoğu durumda yerleşik yapıyı kullanmanın daha iyi olduğunu kabul etsem de, ForEach <> uzantısındaki bu varyasyonun kullanımının, dizini düzenli olarak foreachkendimde yönetmek zorunda kalmaktan biraz daha hoş olduğunu düşünüyorum :

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

Size verecekti:

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

Bir çözüm yazmaktır .ToList().ForEach(x => ...).

profesyoneller

Anlaması kolay - okuyucunun yalnızca C # ile birlikte gelenleri bilmesi gerekir, herhangi bir ek uzantı yöntemi değil.

Sözdizimsel gürültü çok hafiftir (sadece biraz yabancı kod ekler).

Her ne kadar bir yerli .ForEach()tüm koleksiyonu gerçekleştirmek zorunda kalacağından , genellikle fazladan belleğe mal olmaz.

Eksileri

İşlem sırası ideal değildir. Bir elementi fark etmeyi, sonra ona göre hareket etmeyi ve tekrar etmeyi tercih ederim. Bu kod önce tüm unsurları gerçekleştirir, sonra her birine sırayla etki eder.

Listenin farkına varmak bir istisna atarsa, asla tek bir öğe üzerinde hareket edemezsiniz.

Sayım sonsuzsa (doğal sayılar gibi), şansınız kalmaz.

Her zaman kendimi merak ettim, bu yüzden bunu hep yanımda taşıyorum:

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

Güzel küçük uzatma yöntemi.

Bu nedenle, bir ForEach uzantı yönteminin LINQ uzantı yöntemleri gibi bir değer döndürmediği için uygun olmadığı hakkında birçok yorum yapılmıştır. Bu gerçek bir ifade olmakla birlikte, tamamen doğru değildir.

LINQ genişletme yöntemlerinin tümü, birlikte zincirlenebilmeleri için bir değer döndürür:

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

Ancak, LINQ'nun genişletme yöntemleri kullanılarak uygulanması, genişletme yöntemlerinin aynı şekilde kullanılması ve bir değer döndürmesi gerektiği anlamına gelmez . Bir değer döndürmeyen ortak işlevselliği ortaya çıkarmak için bir uzantı yöntemi yazmak son derece geçerli bir kullanımdır.

ForEach ile ilgili özel tartışma, uzatma yöntemleriyle ilgili kısıtlamalara dayanarak (yani bir uzatma yönteminin aynı imzayla devralınan bir yöntemi asla geçersiz kılmayacağı), özel genişletme yönteminin çığır açan tüm sınıflarda mevcut olduğu bir durum olabilir. IEnumerable > Liste hariç >. Bu, yöntemler, genişletme yönteminin mi yoksa devralma yönteminin mi çağrıldığına bağlı olarak farklı davranmaya başladığında karışıklığa neden olabilir.<T<T

Önce (zincirlenebilir, ancak tembel bir şekilde değerlendirilmiş) Select, önce işleminizi yapabilir ve daha sonra kimliği iade edebilirsiniz (veya isterseniz başka bir şey)

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

Hala Count()(afaik numaralandırmanın en ucuz işlemi) veya yine de ihtiyacınız olan başka bir işlemle değerlendirildiğinden emin olmanız gerekir.

Yine de standart kütüphaneye getirdi görmek isterdim:

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

Yukarıdaki kod daha sonra people.WithLazySideEffect(p => Console.WriteLine(p))etkin bir şekilde foreach ile eşdeğer, ancak tembel ve zincirlenebilir hale gelir .

Not o MoreLINQ Nuget sağlar ForEacharadığınız uzatma yöntemi (yanı sıra bir Pipetemsilci yürütür ve sonucu verir yöntemi). Görmek:

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

@Coincoin

Foreach eklenti yönteminin gerçek gücü, Action<>kodunuza gereksiz yöntemler eklemeden yeniden kullanılabilirliği içerir . 10 listeniz olduğunu ve bunlarda aynı mantığı gerçekleştirmek istediğinizi ve buna karşılık gelen bir işlevin sınıfınıza uymadığını ve yeniden kullanılmadığını varsayalım. Döngüler için on veya açık bir şekilde ait olmayan bir yardımcı olan genel bir işlev yerine, tüm mantığınızı tek bir yerde tutabilirsiniz ( Action<>.

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

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

vb...

Mantık tek bir yerde ve sınıfınızı kirletmediniz.

LINQ genişletme yöntemlerinin çoğu sonuç döndürür. ForEach, hiçbir şey döndürmediği için bu desene uymaz.

F # (.NET'in sonraki sürümünde olacak) varsa, aşağıdakileri kullanabilirsiniz:

Seq.iter doSomething myIEnumerable

Kısmen, dil tasarımcıları ona felsefi bir bakış açısıyla katılmıyorlar.

• Bir özelliğe sahip olmamak (ve test etmek ...) bir özelliğe sahip olmaktan daha az iştir.
• Gerçekten daha kısa değil (olduğu yerde bazı geçiş fonksiyonu durumları var, ancak bu birincil kullanım olmayacak).
• Amacı, linq ile ilgili olmayan yan etkilere sahip olmaktır.
• Zaten sahip olduğumuz bir özellikle aynı şeyi yapmanın başka bir yolu var mı? (foreach anahtar kelimesi)

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

Bir şey döndürmek istediğinizde select komutunu kullanabilirsiniz. Bunu yapmazsanız, öncelikle koleksiyondaki hiçbir şeyi değiştirmek istemediğiniz için ToList'i kullanabilirsiniz.

Bu konuda bir blog yazısı yazdım: http://blogs.msdn.com/kirillosenkov/archive/2009/01/31/foreach.aspx

Bu yöntemi .NET 4.0'da görmek istiyorsanız buraya oy verebilirsiniz: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=279093

3.5'te, IEnumerable'a eklenen tüm genişletme yöntemleri LINQ desteği için vardır (System.Linq.Enumerable sınıfında tanımlandıklarına dikkat edin). Bu yazıda, foreach neden LINQ: Parallel.For?

Bu benim mi yoksa Liste <T>. Her zaman Linq tarafından eskimiş hale getirildi. Başlangıçta vardı

foreach(X x in Y) 

burada Y'nin IEnumerable (Pre 2.0) olması ve bir GetEnumerator () uygulaması gerekiyordu. Oluşturulan MSIL'a bakarsanız, bunun tam olarak aynı olduğunu görebilirsiniz.

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

    Console.WriteLine(i);
}

( MSIL için http://alski.net/post/0a-for-foreach-forFirst-forLast0a-0a-.aspx adresine bakın )

Sonra DotNet2.0 Generics geldi ve Liste. Foreach her zaman Vistor deseninin bir uygulaması olduğumu hissetti, (bkz. Gamma, Helm, Johnson, Vlissides Tasarım Desenleri).

Şimdi elbette 3.5'te bunun yerine aynı etki için bir Lambda kullanabiliriz, örneğin bir örnek için http://dotnet-developments.blogs.techtarget.com/2008/09/02/iterators-lambda-and-linq-oh- benim/

Aku'nun cevabını genişletmek istiyorum .

Bir yöntemi, yalnızca tüm numaralandırmayı tekrarlamadan yan etkisinin amacı için çağırmak istiyorsanız, bunu kullanabilirsiniz:

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

Hiç kimse, ForEach <T> öğesinin foreach anahtar kelimesinin çalışma zamanı denetlendiği yerde derleme zamanı türü denetimi ile sonuçlanmadığına işaret etmedi.

Her iki yöntem kodu kullanılan bazı refactoring yaptıktan sonra, ben foreach sorunları bulmak için test hataları / çalışma zamanı hataları avlamak zorunda kaldı .ForEach iyilik.