Сохраните данные BigInteger в двоичном или шестнадцатеричном формате. Он удобочитаем для компьютера и для достаточно преданных своему делу людей. ;>

Затрачивать дополнительные усилия на то, чтобы сделать вывод «удобочитаемым» — пустая трата времени. Ни один человек не сможет разобраться в 450 000 цифр, независимо от того, являются ли они основанием 10, основанием 16, основанием 2 или чем-то еще.

ОБНОВИТЬ

При более внимательном рассмотрении преобразования Base 10 можно заметить, что базовую производительность ToString можно сократить почти вдвое, используя несколько потоков в многоядерной системе. Основное препятствие заключается в том, что наибольший расход времени на весь процесс десятичной дроби составляет операция первого деления исходного числа из 450 000 разрядов.

Stats on my quad core P7: 
Generating a 500k digit random number using power and multiply: 5 seconds
Dividing that big number by anything just once: 11 seconds
ToString(): 22 seconds
ToQuickString: 18 seconds
ToStringMT: 12.9 seconds

.

public static class BigIntExtensions
{
    private static List<BigInteger> powersOfTen;

    // Must be called before ToStringMt()
    public static void InitPowersOfTen(BigInteger n)
    {
        powersOfTen = new List<BigInteger>();

        powersOfTen.Add(1);

        for (BigInteger i = 10; i < n; i *= i)
            powersOfTen.Add(i);
    }

    public static string ToStringMT(this BigInteger n)
    {
        // compute the index into the powersOfTen table for the given parameter. This is very fast.
        var m = (int)Math.Ceiling(Math.Log(BigInteger.Log10(n), 2));

        BigInteger r1;
        // the largest amount of execution time happens right here:
        BigInteger q1 = BigInteger.DivRem(n, BigIntExtensions.powersOfTen[m], out r1);

        // split the remaining work across 4 threads - 3 new threads plus the current thread
        var t1 = Task.Factory.StartNew<string>(() =>
        {
            BigInteger r1r2;
            BigInteger r1q2 = BigInteger.DivRem(r1, BigIntExtensions.powersOfTen[m - 1], out r1r2);
            var t2 = Task.Factory.StartNew<string>(() => BuildString(r1r2, m - 2));
            return BuildString(r1q2, m - 2) + t2.Result;
        });
        BigInteger q1r2;
        BigInteger q1q2 = BigInteger.DivRem(q1, BigIntExtensions.powersOfTen[m - 1], out q1r2);
        var t3 = Task.Factory.StartNew<string>(() => BuildString(q1r2, m - 2));
        var sb = new StringBuilder();
        sb.Append(BuildString(q1q2, m - 2));
        sb.Append(t3.Result);
        sb.Append(t1.Result);
        return sb.ToString();
    }

    // same as ToQuickString, but bails out before m == 0 to reduce call overhead.
    // BigInteger.ToString() is faster than DivRem for smallish numbers.
    private static string BuildString(BigInteger n, int m)
    {
        if (m <= 8)
            return n.ToString();

        BigInteger remainder;
        BigInteger quotient = BigInteger.DivRem(n, powersOfTen[m], out remainder);
        return BuildString(quotient, m - 1) + BuildString(remainder, m - 1);
    }
}

Для ToQuickString() и ToStringMT() перед использованием этих функций необходимо инициализировать массив степени 10. Инициализацию этого массива не следует включать в измерения времени выполнения функции, поскольку массив можно повторно использовать при последующих вызовах, поэтому стоимость его инициализации амортизируется в течение всего времени существования программы, а не вызовов отдельных функций.

Для производственной системы я бы установил более автоматическую инициализацию, такую ​​как инициализация разумного количества записей в статическом конструкторе класса, а затем проверка в ToQuickString() или ToStringMT(), чтобы увидеть, достаточно ли записей в таблице для обработки задано BigInteger. Если нет, добавьте в таблицу достаточно записей для обработки текущего BigInteger, а затем продолжите операцию.

Эта функция ToStringMT создает рабочие задачи вручную, чтобы распределить оставшуюся работу по 4 потокам на доступных исполнительных ядрах в многоядерном ЦП. Вместо этого вы могли бы просто заставить исходную функцию ToQuickString() выделять половину своей работы в другой поток при каждой рекурсии, но это быстро создает слишком много задач и увязает в накладных расходах планирования задач. Рекурсия проходит весь путь до отдельных десятичных цифр. Я изменил функцию BuildString(), чтобы она выходила раньше (m ‹= 8 вместо m == 0), потому что BigInteger.ToString() быстрее, чем DivRem для небольших чисел.

90% времени выполнения ToStringMt() занимает первый вызов DivRem. После этого он очень быстро сходится, но первый действительно болезненный.

Сначала я бы вычислил все числа формы 10^(2^m) меньше, чем n. Затем я бы использовал DivRem с самой большой из них, чтобы разделить проблему на две подзадачи. Повторяйте это рекурсивно, пока не дойдете до отдельных цифр.

var powersOfTen=new List<BigInteger>();
powersOfTen.Add(1);
for(BigInteger i=10;i<n;i=i*i)
  powersOfTen.Add(i);

string ToString(BigInteger n, int m)
{
  if(m==0)
    return n.ToString();
  quotient = DivRem(n,powersOfTen[m], remainder)
  return ToString(quotient, m-1)+ToString(remainder, m-1)
}

Вы также можете полностью оптимизировать конкатенацию строк, напрямую записывая в массив символов.

В качестве альтернативы вы можете рассмотреть возможность использования базы 1000 000 000 во всех расчетах. Таким образом, вам вообще не нужно базовое преобразование. Это, вероятно, намного быстрее для факторного расчета.

List<int> multiply(List<int> f1, int f2)
{
  int carry=0;
  for(int i=0;i<f1.Count;i++)
  {
    var product=(Int64)f1[i]*(Int64)f2;
    carry=product/1000000000;
    result.Add(product%1000000000);
  }
  if(carry!=0)
    result.Add(carry);
}

Теперь преобразование в строку с основанием 10 тривиально и дешево.