Добрый день, уважаемые участники форума!
Сегодня столкнулся с интересным фактом, который немного меня удивил.

Пишу 2 простейших приложения для записи в файл на управляемом(C#) и неуправляемом(C++) коде

#include <stdio.h>


class PerfCounter
    {
    public:
        LARGE_INTEGER _start;

        PerfCounter()
        {}
        /// <summary>
        /// Начинает подсчет вермени выполнения.
        /// </summary>
        void Start()
        {
            QueryPerformanceCounter(&_start);
        }

        /// <summary>
        /// Завершает полсчет вермени исполнения и возвращает время в секундах.
        /// </summary>
        /// <returns>Время в секундах потраченое на выполнение участка
        /// кода. Десятичная часть отражает доли секунды.</returns>
        float Finish()
        {
            LARGE_INTEGER finish;
            QueryPerformanceCounter(&finish);

            LARGE_INTEGER freq;
            QueryPerformanceFrequency(&freq);
            return (float)((finish.QuadPart - _start.QuadPart) / (float)freq.QuadPart);
        }
    };

int main(int argc, char* argv[])
{
    FILE* out = fopen("C:\\1\\1.txt", "a");
    char* buffer = new char[10000];
    for (int i = 0; i < 10000; i++)
        buffer[i] = 'D';
    PerfCounter pc;
    pc.Start();
    for (int i = 0; i < 10000; i++)
    fprintf(out, "%s", buffer);
    fclose(out);
    float t = pc.Finish();
    printf("%f", t);
    return 1;

}

    class Program
    {
        static void Main(string[] args)
        {
            char[] array = new char[10000];
            for (int i = 0; i < 10000; i++)
            {
                array[i] = 'D';
            }
            PerfCounter pc = new PerfCounter();
            pc.Start();
            using (StreamWriter writer = new StreamWriter(
                new FileStream(@"C:\1\2.txt", FileMode.Append, FileAccess.Write)))
            {
                for (int i = 0; i < 10000; i++)
                {
                    writer.Write(array);
                }
            }
            Console.WriteLine(pc.Finish());
        }
    }

    public class PerfCounter
    {
        Int64 _start;

        /// <summary>
        /// Начинает подсчет вермени выполнения.
        /// </summary>
        public void Start()
        {
            _start = 0;
            QueryPerformanceCounter(ref _start);
        }

        /// <summary>
        /// Завершает полсчет вермени исполнения и возвращает время в секундах.
        /// </summary>
        /// <returns>Время в секундах потраченое на выполнение участка
        /// кода. Десятичная часть отражает доли секунды.</returns>
        public float Finish()
        {
            Int64 finish = 0;
            QueryPerformanceCounter(ref finish);

            Int64 freq = 0;
            QueryPerformanceFrequency(ref freq);
            return (((float)(finish - _start) / (float)freq));
        }

        [DllImport("Kernel32.dll")]
        static extern bool QueryPerformanceCounter(ref Int64 performanceCount);

        [DllImport("Kernel32.dll")]
        static extern bool QueryPerformanceFrequency(ref Int64 frequency);
    }

Компилирую оба в релизе Вижуал Студией

И замеряю производительность, вот результаты 5 тестов(в секундах):

Управляемый код                         Неуправляемый код

2,57                                    3,17
2,86                                    3,57
2,97                                    3,00
3,35                                    3,12
2,66                                    3,09

Тестовые примеры, извлекающие данные из базы данных SqlServer дали еще большую разницу.

Это нормально? Мне казалось, что неуправляемый код должен давать преимущества в производительности...
Или я где то ошибаюсь?