i++ czy i--

Chciałem sprawdzić czy pętla z i++ oraz i-- są sobie równe. Dlatego zrobiłem mały test:

            //Test dla i++
            Stopwatch s1 = new Stopwatch();
            s1.Start();
            for (int i = 0; i < lim; i++)
            {
                //code
            }
            s1.Stop();
            Console.WriteLine("Time for i++: {0} ms",
                    s1.ElapsedMilliseconds);

            //Test dla i--
            Stopwatch s2 = new Stopwatch();
            s2.Start();
            for (int i = lim - 1; i >= 0; i--)
            {
                //code
            }
            s2.Stop();
            Console.WriteLine("Time for i--: {0} ms",
                    s2.ElapsedMilliseconds);

Dodałem możliwość powtarzania tego testu. Obliczenia powtarzałem z 10 razy, aby wyniki były bardziej wiarygodne.

           int lim = int.MaxValue; //2147483647

            long time1 =0, time2=0;
            List<long> gList1 = new List<long>();
            List<long> gList2 = new List<long>();

            for (int i = 0; i < 10; i++) //powtarza 10 razy
            {
                TestFor(lim, ref time1, ref  time2);
                gList1.Add(time1);
                gList2.Add(time2);
            }
            var avgPlus = gList1.Average();
            var avgMinus = gList2.Average();
            var maxPlus = gList1.Max();
            var maxMinus = gList2.Max();
            var minPlus = gList1.Min();
            var minMinus = gList2.Min();

            Console.WriteLine(new { avgPlus, maxPlus, minPlus }); 
            // wyświetla wyniki dla i++

            Console.WriteLine(new { avgMinus, maxMinus, minMinus });
            // wyświetla wyniki dla i--

Jednostki w przedstawionych wynikach są liczone w milisekundach.
1) Brak operacji w pętli.
{
avgPlus = 5084,
maxPlus = 5178,
minPlus = 4998
}
{
avgMinus = 6747,
maxMinus = 6828,
minMinus = 6677
}

Operacja i++ jest szybsza. Czasy dla operacji i++ są około 1,7 sekundy mniejsze niż dla operacji i--.

2) Prosta operacja zawarta w pętli.

            int iter = 0;
            iter++;

{
avgPlus = 6368,
maxPlus = 6494,
minPlus = 6319
}
{
avgMinus = 5472,
maxMinus = 5600,
minMinus = 5446
}
Wyniki są odwrotne do wyników z poprzedniego testu. W tym przypadku operacja i-- jest szybsza. Ciekawe jest, że wyniki dla prostej operacji w pętli są lepsze niż dla pętli bez operacji.

3) Operacja na stringu.

            "ab".Replace('a','b');

{
avgPlus = 127846,3,
maxPlus = 136981,
minPlus = 125358
}
{
avgMinus = 125099,2,
maxMinus = 131357,
minMinus = 123913
}
Badanie potwierdza wnioski z punktu 2, że operacja i-- jest szybsza od i++.

4) Skoro była inkrementacja w pętli to sprawdziłem dekrementacje.

            int iter = 0;
            iter--;

{
avgPlus = 6237,4,
maxPlus = 6260,
minPlus = 6225
}
{
avgMinus = 5337,6,
maxMinus = 5383,
minMinus = 5298
}
Badanie potwierdza wniosek z punktu 2. Operacja dekrementacji jest szybka od operacji inkrementacji.

5) W ciele pętli jest tworzenie obiektu.
{
avgPlus = 52622,
maxPlus = 54548,
minPlus = 51284
}
{
avgMinus = 51557,1,
maxMinus = 55958,
minMinus = 50173
}
Ostatnie badanie potwierdza, że operacja dekrementacji jest szybsza od operacji inkrementacji.

Jak na razie nie wiem dlaczego tak się dzieje. Gdyby ktoś wiedział dlaczego operacja dekrementacji jest szybsza, to proszę o kontakt.