C # / VB.NET / .NET yılında hangi döngü daha hızlı çalışır, forya foreach?

forBir foreachdöngünün uzun zaman önce bir döngüden daha hızlı çalıştığını okuduğumdan beri , tüm koleksiyonlar, genel koleksiyonlar, tüm diziler vb. İçin doğru olduğunu varsaydım.

Google'ı inceledim ve birkaç makale buldum, ancak çoğu sonuçsuz (makaleler hakkındaki yorumları okuyun) ve açık uçlu.

İdeal olan, her senaryonun listelenmesi ve bunun için en iyi çözümdür.

Örneğin (nasıl olması gerektiğine dair bir örnek):

1. 1000+ dize dizisi yineleme için - fordaha iyi olduğunuforeach
2. üzerinden yineleme için IList(non jenerik) dizeleri - foreachdaha iyi olduğunufor

Web'de aynı için bulunan birkaç referans:

1. Emmanuel Schanzer'in orijinal büyük eski makalesi
2. CodeProject ÖNSÖZ Vs. İÇİN
3. Blog - Sormak foreachya da istememek foreach, soru bu
4. ASP.NET forumu - NET 1.1 C # forvsforeach

[Düzenle]

Okunabilirlik yönünün yanı sıra, gerçeklerle ve rakamlarla gerçekten ilgileniyorum. Sıkıştırılan son performans optimizasyonunun önemli olduğu uygulamalar vardır.

Patrick Smacchia , geçtiğimiz ay bu konuda aşağıdaki sonuçlarla blog yazdı :

• Listedeki döngüler için List'deki foreach döngülerinden 2 kat daha ucuzdur.
• Dizide döngü, Liste'de döngüden yaklaşık 2 kat daha ucuzdur.
• Sonuç olarak, foreach kullanarak dizi döngü döngü foreach kullanarak (bu hepimizin ne yaptığına inanıyorum) kullanarak liste döngü 5 kat daha ucuzdur.

İlk olarak, Dmitry'nin (şimdi silinmiş) cevabına karşı bir iddia . Diziler için, C # derleyicisi foreacheşdeğer bir fordöngü için olduğu gibi büyük oranda aynı kodu yayar . Bu, bu kriter için sonuçların temelde aynı olduğunu açıklıyor:

using System;
using System.Diagnostics;
using System.Linq;

class Test
{
    const int Size = 1000000;
    const int Iterations = 10000;

    static void Main()
    {
        double[] data = new double[Size];
        Random rng = new Random();
        for (int i=0; i < data.Length; i++)
        {
            data[i] = rng.NextDouble();
        }

        double correctSum = data.Sum();

        Stopwatch sw = Stopwatch.StartNew();
        for (int i=0; i < Iterations; i++)
        {
            double sum = 0;
            for (int j=0; j < data.Length; j++)
            {
                sum += data[j];
            }
            if (Math.Abs(sum-correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("For loop: {0}", sw.ElapsedMilliseconds);

        sw = Stopwatch.StartNew();
        for (int i=0; i < Iterations; i++)
        {
            double sum = 0;
            foreach (double d in data)
            {
                sum += d;
            }
            if (Math.Abs(sum-correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("Foreach loop: {0}", sw.ElapsedMilliseconds);
    }
}

Sonuçlar:

For loop: 16638
Foreach loop: 16529

Daha sonra, Greg'in koleksiyon türü hakkındaki amacının önemli olduğunu doğrulayın - diziyi List<double>yukarıdakinden bir olarak değiştirin ve radikal olarak farklı sonuçlar elde edin. Genel olarak sadece önemli ölçüde yavaş olmakla kalmaz, aynı zamanda foreach dizin tarafından erişime göre önemli ölçüde yavaşlar. Bunu söyledikten sonra, neredeyse her zaman kodun daha basit hale getirildiği bir for döngüsü tercih ediyorum - çünkü okunabilirlik neredeyse her zaman önemlidir, oysa mikro optimizasyon nadiren.

foreachdöngüler daha özel amacı olduğunu fordöngüler .

Bir foreachdöngü kullanmak, kodunuzu kullanan herkese koleksiyondaki yeri ne olursa olsun bir koleksiyonun her üyesine bir şeyler yapmayı planladığınızı gösterir. Ayrıca orijinal koleksiyonu değiştirmediğinizi gösterir (ve denerseniz bir istisna atar).

Diğer bir avantajı ise foreach, sadece mantıklı IEnumerableolduğu gibi , her öğenin aslında bir indeksinin olduğu herhangi bir yerde çalışmasıdır .forIList

Ancak, bir öğenin dizinini kullanmanız gerekiyorsa, elbette bir fordöngü kullanmanıza izin verilmelidir . Ancak, bir dizin kullanmanız gerekmiyorsa, bir dizine sahip olmak sadece kodunuzu karmaşık hale getirir.

Farkında olduğum kadar önemli bir performans etkisi yok. Gelecekte bir aşamada, kodu foreachbirden fazla çekirdek üzerinde çalıştırmak için uyarlamak daha kolay olabilir , ancak şu anda endişelenecek bir şey değil.

Performansla ilgili argümanlar olduğunda, vakanızı desteklemek için nicel sonuçlar kullanabilmeniz için küçük bir test yazmanız yeterlidir.

StopWatch sınıfını kullanın ve doğruluk için birkaç milyon kez tekrarlayın. (For döngüsü olmadan bu zor olabilir):

using System.Diagnostics;
//...
Stopwatch sw = new Stopwatch()
sw.Start()
for(int i = 0; i < 1000000;i ++)
{
    //do whatever it is you need to time
}
sw.Stop();
//print out sw.ElapsedMilliseconds

Parmaklar, bu farkın ihmal edilebilir olduğunu gösterdi ve en sürdürülebilir kodda ne olursa olsun yapabilirsiniz.

Her zaman yakın olacak. Bir dizi için, bazen for biraz daha hızlıdır, ancak foreachdaha ifade edicidir ve LINQ, vb. Sunar. Genel olarak, sopa ile foreach.

Ayrıca, foreachbazı senaryolarda optimize edilebilir. Örneğin, bağlantılı bir liste dizin oluşturucu tarafından korkunç olabilir, ancak hızlı olabilir foreach. Aslında, standart LinkedList<T>bu nedenle bir indeksleyici bile sunmuyor.

Benim tahminim, vakaların% 99'unda muhtemelen önemli olmayacak, neden en uygun yerine daha hızlı (neden en kolay / bakımı kolay olduğu gibi) seçesiniz ki?

İkisi arasında büyük bir performans farkı olması muhtemel değildir. Her zaman olduğu gibi, "hangisi daha hızlı?" soru, her zaman "Bunu ölçebilirim" diye düşünmelisin.

Döngünün gövdesinde aynı şeyi yapan iki döngü yazın, her ikisini de yürütün ve zamanlayın ve hızdaki farkın ne olduğunu görün. Bunu hem neredeyse boş bir gövdeyle hem de gerçekte ne yapacağınıza benzer bir döngü gövdesi ile yapın. Ayrıca, kullandığınız koleksiyon türüyle de deneyin, çünkü farklı koleksiyon türleri farklı performans özelliklerine sahip olabilir.

Döngülerin döngülere tercih edilmesinin çok iyi nedenleri vardır . Eğer bir döngü kullanabiliyorsanız , patronunuz tam size göre.foreachforforeach

Ancak, her yineleme tek tek sırayla bir listeden geçmez. Eğer yasaklıyorsa , evet bu yanlıştır.

Ben senin yerinde olsaydım, döngüler için tüm doğallarını özyinelemeye dönüştürürdüm . Bu ona öğretirdi ve aynı zamanda sizin için iyi bir zihinsel egzersiz.

TechEd 2005'te Jeffrey Richter:

"Yıllar içinde C # derleyicisinin temelde bana yalancı olduğunu öğrenmek için geldim." .. "Pek çok şey hakkında yalan söylüyor." .. "Bir foreach döngüsü yaptığınızda olduğu gibi ..." .. "... bu yazdığınız küçük bir kod satırıdır, ama C # derleyicisinin bunu yapmak için tükürdüğü şey olağanüstüdür. deneyin / son olarak orada engelleyin, sonunda bloğun içinde değişkeninizi IDisposable bir arayüze çevirir ve cast alırsa üzerinde Dispose yöntemini çağırır, döngü içinde Current özelliğini ve MoveNext yöntemini döngü içinde tekrar tekrar çağırır, bir çok insan foreach kullanıyor, çünkü kodlaması çok kolay, yapması çok kolay .. ".." foreach performans açısından çok iyi değil,

İsteğe Bağlı Web Yayını: http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032292286&EventCategory=3&culture=en-US&CountryCode=US

Bu gülünç. For-loop'u, performans açısından veya diğerlerini yasaklamak için zorlayıcı bir neden yoktur.

Performans karşılaştırması ve diğer argümanlar için Jon Skeet'in bloguna bakın .

Bir nesne koleksiyonuyla çalıştığınız durumlarda foreachdaha iyidir, ancak bir sayıyı arttırırsanız,for döngü daha iyidir.

Son durumda, aşağıdakine benzer bir şey yapabileceğinizi unutmayın:

foreach (int i in Enumerable.Range(1, 10))...

Ama kesinlikle daha iyi performans göstermiyor, aslında a'dan daha kötü bir performansa sahip for.

Bu sizi kurtarmalıdır:

public IEnumerator<int> For(int start, int end, int step) {
    int n = start;
    while (n <= end) {
        yield n;
        n += step;
    }
}

kullanın:

foreach (int n in For(1, 200, 4)) {
    Console.WriteLine(n);
}

Daha büyük kazanma için parametre olarak üç delege alabilirsiniz.

Derin .NET - Bölüm 1 Yineleme hakkında okuyabilirsiniz

.NET kaynak kodunun sökülmesine kadar olan sonuçları (ilk başlatma olmadan) kapsar.

örneğin - Bir foreach döngüsü ile Dizi İterasyonu:

ve - foreach döngüsü ile yinelemeyi listeleyin:

ve sonuç:

Bir de hız farklılıkları for- ve bir foreachsen vb diziler, listeler, gibi ortak yapılar aracılığıyla döngü ve a yapıyoruz küçük -loopLINQ ve koleksiyon üzerinde sorgu neredeyse her zaman biraz daha yavaştır, ancak yazmak daha iyidir! Diğer posterlerin de söylediği gibi, milisaniye ekstra performanstan ziyade ifadeyi tercih edin.

Şimdiye kadar söylenmeyen şey, bir foreachdöngü derlendiğinde, yinelemekte olduğu koleksiyona göre derleyici tarafından optimize edilmesidir. Bu, hangi döngüyü kullanacağınızdan emin olmadığınız zaman, foreachdöngüyü kullanmanız gerektiği anlamına gelir - derlendiğinde sizin için en iyi döngüyü üretecektir. Daha okunabilir.

foreachDöngü ile ilgili bir diğer önemli avantaj , toplama uygulamanız değiştiğinde ( örneğin bir int'den arraybir List<int>örneğe), foreachdöngünüzün herhangi bir kod değişikliği gerektirmemesidir:

foreach (int i in myCollection)

Yukarıdakiler, koleksiyonunuzun türü ne olursa olsun aynıdır, halbuki fordöngünüzde, ' myCollectionden' arraye değiştirirseniz aşağıdakiler oluşmaz List:

for (int i = 0; i < myCollection.Length, i++)

"Onu for döngüsünün kabul edilebilir olduğuna ikna etmeme yardımcı olacak herhangi bir argüman var mı?"

Hayır, patronunuz size hangi programlama dilini kullanacağınızı söyleyecek düzeyde mikro yönetim yapıyorsa, söyleyebileceğiniz hiçbir şey yoktur. Afedersiniz.

Muhtemelen numaralandırdığınız koleksiyonun türüne ve dizinleyicisinin uygulanmasına bağlıdır. Bununla birlikte, genel foreacholarak, kullanımın daha iyi bir yaklaşım olması muhtemeldir.

Ayrıca, IEnumerableyalnızca dizin oluşturucularla değil , herhangi biriyle çalışır .

Bu, çoğu "daha hızlı" sorusuyla aynı iki cevaba sahiptir:

1) Ölçmezseniz, bilmiyorsunuz.

2) (Çünkü ...) Duruma göre değişir.

Bu yineleme yapacağınız IEnumerable tipi (veya türleri) için "MoveNext ()" yönteminin ne kadar pahalı olduğuna, "this [int index]" yönteminin ne kadar pahalı olduğuna bağlıdır.

"Foreach" anahtar sözcüğü bir dizi işlem için kısayoldur - IEnumerable'da bir kez GetEnumerator () öğesini çağırır, yineleme başına bir kez MoveNext () öğesini çağırır, bazı tür denetimleri yapar, vb. Performans ölçümlerini etkilemesi en muhtemel şey MoveNext () 'in maliyetidir, çünkü O (N) kez çağrılır. Belki ucuz, ama belki de değil.

"For" anahtar kelimesi daha öngörülebilir görünüyor, ancak döngülerin çoğu için "toplama [dizin]" gibi bir şey bulacaksınız. Bu basit bir dizi indeksleme işlemine benziyor, ancak aslında maliyeti tamamen yinelediğiniz koleksiyonun doğasına bağlı olan bir yöntem çağrısı. Muhtemelen ucuz, ama belki de değil.

Koleksiyonun temeldeki yapısı temelde bağlantılı bir listeyse, MoveNext kir ucuzdur, ancak dizinleyicinin O (N) maliyeti olabilir ve bu da bir "for" döngüsü O (N * N) 'nın gerçek maliyetini oluşturur.

Her dil yapısının kullanım için uygun bir zamanı ve yeri vardır. C # dilinin dört ayrı yineleme ifadesine sahip olmasının bir nedeni vardır - her biri belirli bir amaç için vardır ve uygun bir kullanıma sahiptir.

Patronunuzla oturmanızı ve forilmiğin neden bir amacı olduğunu rasyonel olarak açıklamaya çalışmanızı öneririm . Bir foryineleme bloğunun bir algoritmayı bir foreachyinelemeden daha açık bir şekilde tanımladığı zamanlar vardır . Bu doğru olduğunda, bunları kullanmak uygundur.

Ayrıca patronunuza da dikkat çekerim - Performans değildir ve pratik bir şekilde bir sorun olmamalıdır - daha çok algoritmayı özlü, anlamlı, sürdürülebilir bir şekilde ifade etme meselesidir. Bunun gibi mikro optimizasyonlar, performans optimizasyonunun noktasını tamamen özlüyor, çünkü herhangi bir gerçek performans avantajı, döngü yeniden yapılandırmasından değil algoritmik yeniden tasarım ve yeniden düzenleme işlemlerinden gelecek.

Rasyonel bir tartışmadan sonra hala bu otoriter görüş varsa, nasıl ilerleyeceğiniz size bağlıdır. Şahsen, rasyonel düşüncenin cesaretinin kırıldığı bir ortamda çalışmaktan mutlu olmazdım ve farklı bir işveren altında başka bir konuma geçmeyi düşünürdüm. Ancak, üzülmeden önce tartışmayı şiddetle tavsiye ederim - yerinde basit bir yanlış anlama olabilir.

Yaptığın ne içeride perfomance etkileyen döngü değil gerçek döngü yapısı (davanızı varsayarak Önemsiz olmayan).

Gerçekte forolduğundan daha hızlı olup olmadığı daha foreachönemlidir. Birinden diğerinin seçilmesinin performansınız üzerinde önemli bir etki yaratacağından şüpheliyim.

Uygulamanızı optimize etmenin en iyi yolu, gerçek kodun profillenmesidir. Bu, en çok iş / zamanı açıklayan yöntemleri belirler. Önce bunları optimize edin. Performans hala kabul edilebilir değilse, prosedürü tekrarlayın.

Genel bir kural olarak, nadiren önemli kazanımlar sağlayacakları için mikro optimizasyonlardan uzak durmanızı tavsiye ederim. Tek istisna, tanımlanmış etkin yolları optimize etmektir (örn. Profilleriniz çok kullanılan birkaç yöntemi tanımlarsa, bunları kapsamlı bir şekilde optimize etmek mantıklı olabilir).

İkisi neredeyse aynı şekilde koşacak. Her ikisini de kullanmak için bir kod yazın, sonra ona IL'yi gösterin. Karşılaştırılabilir hesaplamaları göstermelidir, yani performansta bir fark yoktur.

Çünkü uygulamak için daha basit bir mantık vardır, bu yüzden foreach'den daha hızlıdır.

Belirli bir hız optimizasyonu sürecinde değilseniz, hangi yöntemi okumanın ve sürdürmenin en kolay yoldan hangisini kullandığını söyleyebilirim.

Koleksiyon sınıflarından birinde olduğu gibi bir yineleyici ayarlanmışsa, foreach iyi bir kolay seçenektir. Ve yinelediğiniz bir tamsayı aralığıysa, muhtemelen daha temizdir.

Jeffrey Richter, yakın zamanda yayınlanan bir podcast'te foreach ile foreach arasındaki performans farkını konuştu: http://pixel8.infragistics.com/shows/everything.aspx#Episode:9317

Çoğu durumda gerçekten hiçbir fark yoktur.

Genellikle, her zaman açık bir sayısal dizininiz olmadığında her zaman foreach kullanmak zorundasınız ve her zaman yinelenebilir bir koleksiyonunuz olmadığında kullanmak zorundasınız (örneğin, bir üst üçgendeki iki boyutlu dizi ızgarası üzerinde yineleme) . Seçim yapabileceğiniz bazı durumlar var.

Kodda sihirli sayılar görünmeye başlarsa döngüler için bakımı biraz daha zor olabilir. For döngüsünü kullanamayacağınız için rahatsız olmanız ve sadece döngüler yasaklandığı için bir alt koleksiyon oluşturmak için bir koleksiyon veya lambda kullanmanız gerekir.

For döngüsü gibi bir şeyin kullanımını tamamen yasaklamak biraz garip görünüyor.

Burada iki döngü arasındaki performans farklılıklarının çoğunu kapsayan ilginç bir makale var .

Şahsen ben döngüler için biraz daha okunabilir foreach buluyorum ama eldeki iş için en iyi kullanmak gerekir ve bir for döngüsü daha uygun ise bir foreach döngü eklemek için ekstra uzun kod yazmak zorunda değilsiniz.

Daha hızlıforeach yinelenen döngüyü buldum . Aşağıdaki test sonuçlarıma bakın. Aşağıdaki kodda , zamanı ölçmek için ve döngüsünü kullanarak ayrı ayrı 100, 10000 ve 100000 boyutlarında bir yineleme yapıyorum .List arrayforforeach

private static void MeasureTime()
    {
        var array = new int[10000];
        var list = array.ToList();
        Console.WriteLine("Array size: {0}", array.Length);

        Console.WriteLine("Array For loop ......");
        var stopWatch = Stopwatch.StartNew();
        for (int i = 0; i < array.Length; i++)
        {
            Thread.Sleep(1);
        }
        stopWatch.Stop();
        Console.WriteLine("Time take to run the for loop is {0} millisecond", stopWatch.ElapsedMilliseconds);

        Console.WriteLine(" ");
        Console.WriteLine("Array Foreach loop ......");
        var stopWatch1 = Stopwatch.StartNew();
        foreach (var item in array)
        {
            Thread.Sleep(1);
        }
        stopWatch1.Stop();
        Console.WriteLine("Time take to run the foreach loop is {0} millisecond", stopWatch1.ElapsedMilliseconds);

        Console.WriteLine(" ");
        Console.WriteLine("List For loop ......");
        var stopWatch2 = Stopwatch.StartNew();
        for (int i = 0; i < list.Count; i++)
        {
            Thread.Sleep(1);
        }
        stopWatch2.Stop();
        Console.WriteLine("Time take to run the for loop is {0} millisecond", stopWatch2.ElapsedMilliseconds);

        Console.WriteLine(" ");
        Console.WriteLine("List Foreach loop ......");
        var stopWatch3 = Stopwatch.StartNew();
        foreach (var item in list)
        {
            Thread.Sleep(1);
        }
        stopWatch3.Stop();
        Console.WriteLine("Time take to run the foreach loop is {0} millisecond", stopWatch3.ElapsedMilliseconds);
    }

GÜNCELLENMİŞ

@Jgauffin önerisinden sonra @johnskeet kodunu kullandım ve fordöngüsünün arrayaşağıdakilerden daha hızlı olduğunu gördüm ,

• Dizi ile foreach döngüsü.
• Listeli döngü için.
• Listeli foreach döngüsü.

Test sonuçlarımı ve kodumu aşağıya bakın,

private static void MeasureNewTime()
    {
        var data = new double[Size];
        var rng = new Random();
        for (int i = 0; i < data.Length; i++)
        {
            data[i] = rng.NextDouble();
        }
        Console.WriteLine("Lenght of array: {0}", data.Length);
        Console.WriteLine("No. of iteration: {0}", Iterations);
        Console.WriteLine(" ");
        double correctSum = data.Sum();

        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < Iterations; i++)
        {
            double sum = 0;
            for (int j = 0; j < data.Length; j++)
            {
                sum += data[j];
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("For loop with Array: {0}", sw.ElapsedMilliseconds);

        sw = Stopwatch.StartNew();
        for (var i = 0; i < Iterations; i++)
        {
            double sum = 0;
            foreach (double d in data)
            {
                sum += d;
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("Foreach loop with Array: {0}", sw.ElapsedMilliseconds);
        Console.WriteLine(" ");

        var dataList = data.ToList();
        sw = Stopwatch.StartNew();
        for (int i = 0; i < Iterations; i++)
        {
            double sum = 0;
            for (int j = 0; j < dataList.Count; j++)
            {
                sum += data[j];
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("For loop with List: {0}", sw.ElapsedMilliseconds);

        sw = Stopwatch.StartNew();
        for (int i = 0; i < Iterations; i++)
        {
            double sum = 0;
            foreach (double d in dataList)
            {
                sum += d;
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("Foreach loop with List: {0}", sw.ElapsedMilliseconds);
    }

Gerçekten kafasını vidalayabilir ve bunun yerine IQueryable. Foreach kapatma için gidebilirsiniz:

myList.ForEach(c => Console.WriteLine(c.ToString());

Kimsenin ikisi arasında "büyük" bir performans farkı bulmasını beklemezdim.

Cevap, erişmeye çalıştığınız koleksiyonun daha hızlı bir dizinleyici erişim uygulamasına veya daha hızlı bir IEnumerator erişim uygulamasına sahip olup olmadığına bağlıdır. IEnumerator genellikle dizinleyiciyi kullandığından ve yalnızca geçerli dizin konumunun bir kopyasına sahip olduğundan, numaralandırıcı erişiminin doğrudan dizin erişiminden en az yavaş veya daha yavaş olmasını beklerim, ancak çok fazla değil.

Elbette bu cevap, derleyicinin uygulayabileceği optimizasyonları hesaba katmaz.

For-loop ve foreach-loop'un her zaman eşdeğer olmadığını unutmayın. Liste değişirse liste numaralandırıcıları bir istisna atar, ancak bu uyarıyı her zaman normal bir döngü için alamazsınız. Liste yanlış zamanda değiştirilirse farklı bir istisna bile alabilirsiniz.