c # двойное преобразование в массив символов или альтернативу

Файл должен быть в текстовом формате?

В противном случае наиболее эффективным способом сделать это является использование BinaryWriter (и BinaryReader для их обратного чтения).

См. http://msdn.microsoft.com/en-us/library/system.io.binarywriter.aspx для получения дополнительной информации.

Если возможна запись в текстовый файл напрямую, Steamwriter можно использовать для написания строго типизированных структур. Я не тестировал использование памяти, но считаю, что они должны быть эффективными

        using (var tw = new System.IO.StreamWriter("filename", true)) //(true to append to file)
        {
            tw.Write(x.A);
            tw.Write(';');
        }

Если требуется построитель строк, строго типизированные перегрузки также могут быть вызваны с помощью:

        builder.Append(x.A) //strongly typed as long as the field is a system type
            .Append(';')
            .Append(x.B)
            .Append(';'); 

Конечно, оба метода выглядели бы лучше, реализуя какой-то цикл или делегатов, но это выходит за рамки логики упаковки.

ИЗМЕНИТЬ пользовательское двойное письмо, опубликованное в другом ответе: C # двойное преобразование в массив символов или альтернативный вариант

Вы должны писать прямо в файловый поток, чтобы уменьшить использование памяти.

using(var writer = new StreamWriter(...))
{
   writer.Write(x.A);
   writer.Write(";");
   writer.Write(x.B);
   writer.Write(";");
   writer.Write(x.C);
}

Вы уверены, что это предположительно много вызовов Double.ToString, которые вызывают проблемы с вашей памятью? Каждая строка должна быть собрана при сборке следующего поколения 0, и сборщик мусора .NET довольно эффективен в этом.

Если строки, которые вы создаете, превышают 85 КБ, они будут созданы в куче больших объектов, и это может увеличить общую память, требуемую вашему приложению, даже если большие строки существуют временно (фрагментация кучи больших объектов).

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

StringBuilder - правильный класс для построения строк в памяти, но если вы создаете строки только в памяти, чтобы позже записать их в файл, вы должны вместо этого записывать непосредственно в файл, используя StreamWriter.

StringBuilder потребуется расширить буфер, используемый для хранения строки, и вы можете избежать этих дополнительных накладных расходов, заранее установив емкость StringBuilder (вы уже делаете это в своем примере кода).

Независимо от того, какую перегрузку вы вызываете для форматирования Double в StringBuilder, вызов в конечном итоге приведет к вызову Double.ToString. StringBuilder.AppendFormat форматируется непосредственно в буфер без выделения дополнительной отформатированной строки, поэтому с точки зрения использования памяти StringBuilder.AppendFormat так же хорошо, как и StringBuilder.Append, и обе перегрузки будут выделять строку с отформатированным Double как часть процесса форматирования. Однако StringBuilder.AppendFormat будет упаковывать Double, потому что принимает массив params Object[]. Использование перегрузки StringBuilder.Append, которая принимает Double, не страдает от этой проблемы.

Если вы с уверенностью знаете, что Double.ToString является источником ваших проблем с памятью, я считаю, что вам лучше всего написать собственный код форматирования с плавающей запятой, который может записывать число с плавающей запятой непосредственно в StringBuilder. Задача нетривиальная, но вы можете почерпнуть вдохновение из библиотеки C с открытым исходным кодом.

Из чистого любопытства, что делать, я не мог удержаться от попытки создать сценарий, который бы писал двойников напрямую. Ниже приведен результат. Я не тестировал его или что-то еще, но он работал, как ожидалось, в (ограниченных) тестах, которые я проводил.

        double[] test = { 8.99999999, -4, 34.567, -234.2354, 2.34, 500.8 };
        using (var sw = new FileStream(@"c:\temp\test.txt", FileMode.Create))
        {
            using (var bw = new BinaryWriter(sw))
            {
                const byte semicol = 59, minus = 45, dec = 46, b0 = 48;

                Action<double> write = d =>
                {
                    if (d == 0)
                        bw.Write(b0);
                    else
                    {
                        if (d < 0)
                        {
                            bw.Write(minus);
                            d = -d;
                        }

                        double m = Math.Pow(10d, Math.Truncate(Math.Log10(d)));
                        while(true)
                        {
                            var r = ((decimal)(d / m) % 10); //decimal because of floating point errors
                            if (r == 0) break;
                            if (m == 0.1)
                                bw.Write(dec); //decimal point
                            bw.Write((byte)(48 + r));         
                            m /= 10d;
                        }
                    }

                    bw.Write(semicol);
                };

                foreach (var d in test)
                    write(d);
            }
        }