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

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

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

TK>1. Попробуйте для начала писать эквивалентный код.
TK>2. Основные преимущества в производительности дают те или иные архитектурные решения — от "управляемости" это зависит мало.

char* buffer = new char[10000];
for (int i = 0; i < 9999; i++)
buffer[i] = 'D';
buffer[9999] = '\0';

for (int i = 0; i < 10000; i++)
fprintf(out, buffer);

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++)
        fwrite(buffer, 10000, 1, out);
    fclose(out);
    float t = pc.Finish();
    printf("%f", t);
    return 1;

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

A>

    // открываем файл
    int fh = _open("file.dat",_O_RDWR | _O_BINARY);
    if (fh == -1)
    {
        // или при необходимости создаём новый
        fh = _creat("file.dat",_S_IREAD | _S_IWRITE);
        if (fh == -1)
            return 1;
    }

    // позиционируемся в конец файла
    _lseek(fh,0,SEEK_END);

    for (int i = 0; i < 10000; i++)
    // добавляем новую структуру
    _write(fh,&buffer,10000);