Тема тысячи раз обсуждалась, но тем не менее.
Насколько оптимизирующий JIT-компилятор оптимизирует?
К примеру, весь цивилизованный мир уверяет, что тривиальные свойства инлайнятся, и я до недавнего времени был уверен, что в большинстве случаев это так. Но после странных скачков производительности в проекте решил-таки проверить. Имеется класс с целочисленным свойством и полем:

    class PropertyTest
    {

        public long Field;

        public long Property
        {
            get
            {
                return Field;
            }
            set
            {
                Field = value;
            }
        }
    }

В цикле суммируем числа от 0 до N — 1 сначала через поле, а затем через свойство:

        static void Main(string[] args)
        {
            var test = new PropertyTest();
            
            const long N = 10000000;
            
            var sum = 0L;
            var start = DateTime.Now;

            for (int i = 0; i < N; ++i)
            {
                test.Field = i;
                sum += test.Field;
            }

            var period = DateTime.Now - start;

            Console.WriteLine("Ticks: {0}, Sum: {1}", period.Ticks, sum);

            sum = 0;
            start = DateTime.Now;

            for (int i = 0; i < N; ++i)
            {
                test.Property = i;
                sum += test.Property;
            }

            period = DateTime.Now - start;

            Console.WriteLine("Ticks: {0}, Sum: {1}", period.Ticks, sum);
            Console.ReadKey(true);
        }

На моей машине (C2D 2.5GHz/Vista/.NET 3.5 SP1) выигрыш при использовании поля получается чуть ли не в 5 раз.

Вопрос: как понимать результаты подобной оптимизации?