Почему .NET decimal.ToString(строка) округляется от нуля, по-видимому, не соответствует спецификации языка?

Я вижу, что в С# округление a decimal по умолчанию использует MidpointRounding.ToEven. Это ожидается, и это диктует спецификацию С#. Однако, учитывая следующее:

• A decimal dVal
• Формат string sFmt, который при передаче в dVal.ToString(sFmt) приведет к строке, содержащей округленную версию dVal

... очевидно, что decimal.ToString(string) возвращает значение, округленное с помощью MidpointRounding.AwayFromZero. Это может показаться прямым противоречием спецификации С#.

Мой вопрос таков: Есть ли веская причина? Или это просто несогласованность в языке?

Ниже, для справки, я включил некоторый код, который записывает в консоль ассортимент результатов округления и результаты операции decimal.ToString(string), каждый из каждого значения в массиве значений decimal. Фактические выходы встроены. После этого я включил соответствующий абзац из раздела С# Language Specification в тип decimal.

Пример кода:

static void Main(string[] args)
{
    decimal[] dArr = new decimal[] { 12.345m, 12.355m };

    OutputBaseValues(dArr);
    // Base values:
    // d[0] = 12.345
    // d[1] = 12.355

    OutputRoundedValues(dArr);
    // Rounding with default MidpointRounding:
    // Math.Round(12.345, 2) => 12.34
    // Math.Round(12.355, 2) => 12.36
    // decimal.Round(12.345, 2) => 12.34
    // decimal.Round(12.355, 2) => 12.36

    OutputRoundedValues(dArr, MidpointRounding.ToEven);
    // Rounding with mr = MidpointRounding.ToEven:
    // Math.Round(12.345, 2, mr) => 12.34
    // Math.Round(12.355, 2, mr) => 12.36
    // decimal.Round(12.345, 2, mr) => 12.34
    // decimal.Round(12.355, 2, mr) => 12.36

    OutputRoundedValues(dArr, MidpointRounding.AwayFromZero);
    // Rounding with mr = MidpointRounding.AwayFromZero:
    // Math.Round(12.345, 2, mr) => 12.35
    // Math.Round(12.355, 2, mr) => 12.36
    // decimal.Round(12.345, 2, mr) => 12.35
    // decimal.Round(12.355, 2, mr) => 12.36

    OutputToStringFormatted(dArr, "N2");
    // decimal.ToString("N2"):
    // 12.345.ToString("N2") => 12.35
    // 12.355.ToString("N2") => 12.36

    OutputToStringFormatted(dArr, "F2");
    // decimal.ToString("F2"):
    // 12.345.ToString("F2") => 12.35
    // 12.355.ToString("F2") => 12.36

    OutputToStringFormatted(dArr, "###.##");
    // decimal.ToString("###.##"):
    // 12.345.ToString("###.##") => 12.35
    // 12.355.ToString("###.##") => 12.36

    Console.ReadKey();
}

private static void OutputBaseValues(decimal[] dArr)
{
    Console.WriteLine("Base values:");
    for (int i = 0; i < dArr.Length; i++) Console.WriteLine("d[{0}] = {1}", i, dArr[i]);
    Console.WriteLine();
}

private static void OutputRoundedValues(decimal[] dArr)
{
    Console.WriteLine("Rounding with default MidpointRounding:");
    foreach (decimal d in dArr) Console.WriteLine("Math.Round({0}, 2) => {1}", d, Math.Round(d, 2));
    foreach (decimal d in dArr) Console.WriteLine("decimal.Round({0}, 2) => {1}", d, decimal.Round(d, 2));
    Console.WriteLine();
}

private static void OutputRoundedValues(decimal[] dArr, MidpointRounding mr)
{
    Console.WriteLine("Rounding with mr = MidpointRounding.{0}:", mr);
    foreach (decimal d in dArr) Console.WriteLine("Math.Round({0}, 2, mr) => {1}", d, Math.Round(d, 2, mr));
    foreach (decimal d in dArr) Console.WriteLine("decimal.Round({0}, 2, mr) => {1}", d, decimal.Round(d, 2, mr));
    Console.WriteLine();
}

private static void OutputToStringFormatted(decimal[] dArr, string format)
{
    Console.WriteLine("decimal.ToString(\"{0}\"):", format);
    foreach (decimal d in dArr) Console.WriteLine("{0}.ToString(\"{1}\") => {2}", d, format, d.ToString(format));
    Console.WriteLine();
}

Параграф из раздела 4.1.7 Спецификации языка С# ( "Десятичный тип" ) (получите полный spec здесь (.doc)):

Результатом операции над значениями типа decimal является результат вычисления точного результата (сохранение шкалы, как определено для каждого оператора), а затем округление в соответствии с представлением. Результаты округляются до ближайшего представимого значения и, когда результат одинаково близок к двум представляемым значениям, к значению, которое имеет четное число в наименее значащей позиции разряда (это называется "округление банкиров" ). Нулевой результат всегда имеет знак 0 и шкалу 0.

Легко видеть, что они, возможно, не рассматривали ToString(string) в этом параграфе, но я склонен думать, что это соответствует этому описанию.