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

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

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

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

Мой вопрос - это: дело обстоит так существует ли серьезное основание? Или это - просто несоответствие в языке?

Ниже, для ссылки, я включал некоторый код, который пишет для консольного подключения к выбору округления операционных результатов и decimal.ToString(string) операционные результаты, каждый на каждом значении в массиве decimal значения. Эффективные выходные мощности встраиваются. После этого я включал соответствующий абзац от раздела C# 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 из Спецификации языка C# ("Десятичный тип") (получают полную спецификацию здесь (.doc)):

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

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