// Этот пример демонстрирует метод Math.Round() вместе с перечислением

// MidpointRounding.

using System;

class Sample 
{
   public static void Main() 
   {
   decimal result = 0.0m;
   decimal posValue =  3.45m;
   decimal negValue = -3.45m;

// По умолчанию округление положительного и отрицательного значения осуществляется

// к ближайшему четному числу (ToEven). Точность результата 1 десятичная позиция.
    result = Math.Round(posValue, 1);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math.Round(negValue, 1);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console.WriteLine();

// Округление положительного значения к ближайшему четному числу (ToEven), затем

// к ближайшему числу от нуля (AwayFromZero).// Точность результата 1 десятичная позиция.
    result = Math.Round(posValue, 1, MidpointRounding.ToEven);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                                          result, posValue);
    result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                                          result, posValue);
    Console.WriteLine();

// Округление отрицательного числа к ближайшему четному числу (ToEven), затем

// к ближайшему числу от нуля (AwayFromZero).

// Точность результата 1 десятичная позиция.
    result = Math.Round(negValue, 1, MidpointRounding.ToEven);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                                          result, negValue);
    result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
    Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                                          result, negValue);
    Console.WriteLine();
    }
}

Этот код выведет следующее:

 3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

Используйте MidpointRounding с подходящей перезагрузкой Math.Round, чтобы предоставить больше управления процессом округления.

Операция округления берет оригинальное число с неявно или явно указанной точностью (precision). Проверяется следующая цифра, которая находится в позиции precision+1, и возвращается ближайшее число с той же точностью, что и оригинальное число. Для положительных чисел: если следующая цифра находится в диапазоне от 0 до 4, то ближайшее число находится в сторону отрицательной бесконечности. Если следующая цифра находится в диапазоне от 6 до 9, то ближайшее число находится в сторону положительной бесконечности. Для отрицательных чисел: если следующая цифра находится в диапазоне от 0 до 4, то ближайшее число находится в сторону положительной бесконечности. Если следующая цифра находится в диапазоне от 6 до 9, то ближайшее число находится в сторону отрицательной бесконечности.

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

Следующая таблица демонстрирует результаты округления нескольких отрицательных и положительных чисел совместно с значениями MidpointRounding. Точность, используемая для округления чисел в этой таблице, равна 0, что означает количество цифр после запятой после операции округления. Например, для числа -2.5, одна цифра после запятой, это 5. Из-за того, что эта цифра находится в средней точке для округления, Вы можете использовать значение MidpointRounding, чтобы определить результат округления: -2 или -3, если точность округления 0) Если указано AwayFromZero, то округление вернет -3, потому что это число ближе всего при уходе от нуля. Если указано ToEven, то будет возвращено -2, потому что это ближайшее четное число.

Спецификатор валюты "C" (от слова currency, валюта) преобразует число в строку, представляющую количество денег. Спецификатор точности показывает желаемое количество позиций цифр в строке результата преобразования. Если спецификатор точности опущен, то точность по умолчанию определяется свойством NumberFormatInfo.CurrencyDecimalDigits.

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

На строку результата влияет информация форматирования текущего объекта NumberFormatInfo. Следующая таблица перечисляет свойства NumberFormatInfo, которые управляют форматирование возвращаемой строки.

Следующий пример форматирует значение Double [7] со спецификатором валюты.

double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));
Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));
Console.WriteLine(value.ToString("C3", 
                  CultureInfo.CreateSpecificCulture("da-DK")));

// Пример отобразит следующий вывод на системе, где текущая культура

// установлена в English (United States, США):

//       $12,345.68

//       $12,345.679

//       kr 12.345,679

Спецификатор формата десятичного числа "D" (от decimal) преобразует число в строку десятичных цифр (0-9), с префиксом знака минус, если число отрицательное. Этот формат поддерживается только для целочисленных типов.

Спецификатор формата показывает минимальное количество цифр, которое нужно получить в строке результата. Если требуется, количество цифр дополняется слева нулями, чтобы в результате получилось столько цифр, сколько задано в спецификаторе точности (precision specifier). Если спецификатор точности не указан, то в строке результата будет минимально необходимое количество цифр без лидирующих нулей.

На строку результата влияет информация форматирования текущего объекта NumberFormatInfo. Как показывает следующая таблица, одно свойство влияет на форматирование строки.

Следующий пример форматирует значение Int32 с десятичным спецификатором формата.

int value;

value = 12345;
Console.WriteLine(value.ToString("D"));

// Отобразит 12345
Console.WriteLine(value.ToString("D8"));

// Отобразит 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));

// Отобразит -12345
Console.WriteLine(value.ToString("D8"));

// Отобразит -00012345

Экспоненциальный спецификатор формата ("E", от слова exponential) преобразует число в строку формы "-d.ddd...E+ddd" или "-d.ddd...e+ddd", где каждая буква "d" показывает цифру (0-9). Строка начинается со знака минус, если число отрицательное. Десятичной точке всегда предшествует одна цифра.

Спецификатор точности (precision specifier) показывает желаемое количество цифр после десятичной точки. Если спецификатор точности опущен, то по умолчанию используется 6 цифр после десятичной точки.

Регистр спецификатора формата показывает, какой должен быть префикс экспоненты, "E" или "e". Экспонента всегда состоит из символа плюса или минуса, и минимум трех цифр. Если необходимо, то экспонента добавляется нулями, чтобы удовлетворить этому минимуму.

На строку результата влияет информация форматирования текущего объекта NumberFormatInfo. В следующей таблице перечислены свойства NumberFormatInfo, которые управляют форматированием возвращаемой строки.

Следующий пример форматирует значение Double в экспоненциальном формате.

double value = 12345.6789;

Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));

// Отобразит 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));

// Отобразит 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));

// Отобразит 1.2346e+004

Console.WriteLine(value.ToString("E", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));

// Отобразит 1,234568E+004

Спецификатор формата фиксированной точки ("F", от слова fixed-point) преобразует число в строку вида "-ddd.ddd...", где каждый символ "d" показывает число (0-9). Строка начинается со знака минус, если число отрицательное.

Спецификатор точности (precision specifier) показывает желаемое количество позиций десятичных цифр. Если спецификатор формата опущен, то текущее свойство NumberFormatInfo.NumberDecimalDigits предоставляет точность.

На строку результата влияет информация форматирования текущего объекта NumberFormatInfo. В следующей таблице перечислены свойства NumberFormatInfo, которые управляют форматированием возвращаемой строки.

Следующий пример форматирует значение Double и Int32 со спецификатором формата фиксированной точки.

int integerNumber;

integerNumber = 17843;

Console.WriteLine(integerNumber.ToString("F", 
                  CultureInfo.InvariantCulture));

// Отобразит 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3", 
                  CultureInfo.InvariantCulture));

// Отобразит -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));

// Отобразит 18934.19
Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));

// Отобразит 18934
doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));

// Отобразит -1898300.2
Console.WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo.CreateSpecificCulture("es-ES")));

// Отобразит -1898300,199

Спецификатор общего формата "G" (от слова general, общий) преобразует число в более компактное представление, либо с фиксированной точкой, либо с научной нотацией, в зависимости от типа числа и в зависимости от того, присутствует ли спецификатор точности (precision specifier). Спецификатор точности задает максимальное количество значащих цифр, которые появятся в строке результата. Если спецификатор точности опущен, или равен нулю, то тип числа определит точность по умолчанию, как показано в следующей таблице.

Используется нотация с фиксированной точкой, если экспонента, которая следовала бы из выражения числа в научном представлении, была больше чем -5 и меньше, чем спецификатор точности; иначе используется научная нотация. Результат содержит, если это необходимо, десятичную точку, или завершающие нули после пропущенной десятичной точки. Если присутствует спецификатор точности, и количество значащих цифр в результате превышает указанную точность, лишние завершающие цифру удаляются округлением.

Однако, если число десятичное, и спецификатор точности опущен, то всегда используется нотация с фиксированной точкой, и завершающие нули сохраняются.

Если используется научная нотация, то экспонента в результате снабжается префиксом "E", если спецификатор формата "G", или "e", если спецификатор формата "g". Экспонента содержит минимум 2 цифры. Ото отличается от формата для научной нотации, которое производится с экспоненциальным спецификатором формата, включающим минимум 3 цифры в экспоненте.

Обратите внимание, что когда используется значение Double, спецификатор формата "G17" гарантирует, что оригинальное значение Double успешно пройдет прямое и обратное преобразование (round-trips). Причина в том, что Double совместимо со стандартом IEEE 754-2008 чисел двойной точности (double-precision, binary64) с плавающей запятой, которые дают 17 значащих цифр точности. Рекомендуется использовать вместо спецификатора формата "R" (см. далее), потому что в некоторых случаях "R" не может успешно выполнить прямое и обратное преобразование значений с плавающей точкой двойной точности. Следующий пример иллюстрирует один такой случай.

using System;

public class Example
{
   public static void Main()
   {
      double original = 0.84551240822557006;
      var rSpecifier = original.ToString("R");
      var g17Specifier = original.ToString("G17");
      
      var rValue = Double.Parse(rSpecifier);
      var g17Value = Double.Parse(g17Specifier);
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}");
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}");
   }
}

Пример отобразит следующее:

     0.84551240822557006 = 0.84551240822557: False
     0.84551240822557006 = 0.84551240822557006: True

При использовании со значением Single [6] спецификатор формата "G9" гарантирует, что оригинальное значение Single может быть успешно преобразовано в обе стороны. Это потому, что Single совместимо со стандартом IEEE 754-2008 чисел одинарной точности (single-precision, binary32) с плавающей запятой, которые дают точность 9 значащих цифр. Рекомендуется использовать это вместо спецификатора формата "R" потому что в некоторых случаях "R" не дает правильно выполнить преобразование в обе стороны чисел одинарной точности с плавающей запятой.

На строку результата влияет информация форматирования текущего объекта NumberFormatInfo. В следующей таблице перечислены свойства NumberFormatInfo, которые управляют форматированием возвращаемой строки.

Следующие форматы в качестве примера показывают числа с плавающей точкой с помощью спецификатора общего формата.

double number;

number = 12345.6789;      
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));

// Отобразит  12345.6789
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));

// Отобразит 12345,6789
Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));

// Отобразит 12345.68 

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));

// Отобразит 2.3E-06       
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));

// Отобразит 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));

// Отобразит 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));

// Отобразит 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));

// Отобразит 3.1416

Числовой спецификатор формата ("N", от слова numeric) преобразует число в строку формы "-d,ddd,ddd.ddd...", где символ "-" показывает при необходимости отрицательное число, "d" показывает цифру (0-9), "," показывает разделитель группы, и "." показывает символ десятичной точки. Спецификатор точности (precision specifier) показывает желаемое количество цифр после десятичной точки. Если спецификатор точности опущен, If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

На строку результата влияет информация форматирования текущего объекта NumberFormatInfo. В следующей таблице перечислены свойства NumberFormatInfo, которые управляют форматированием возвращаемой строки.

Следующий пример форматирует несколько значений с плавающей точкой с помощью спецификатора числового формата.

double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));

// Отобразит -12,445.68
Console.WriteLine(dblValue.ToString("N1", 
                  CultureInfo.CreateSpecificCulture("sv-SE")));

// Отобразит -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));

// Отобразит 123,456,789.0

Спецификатор формата процентов ("P") умножает число на 100, и преобразует результат в строку, представляющую проценты. Спецификатор точности (precision specifier) показывает желаемое количество позиций десятичных цифр. Если спецификатор формата опущен, то числовая точность по умолчанию предоставляется используемым текущим свойством PercentDecimalDigits.

В следующей таблице перечислены свойства NumberFormatInfo, которые управляют форматированием возвращаемой строки.

Следующий пример форматирует числа с плавающей точкой процентным спецификатором формата.

double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));

// Отобразит 24.68 %
Console.WriteLine(number.ToString("P", 
                  CultureInfo.CreateSpecificCulture("hr-HR")));

// Отобразит 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));

// Отобразит 24.7 %

Спецификатор формата "туда-и-обратно" ("R", от слова round-trip) делает попытку гарантировать, что числовое значение можно преобразовать в текст и обратно без потерь, т. е. должно получится то же самое число. Этот формат поддерживается только для типов Single, Double и BigInteger.

Для значений Double и Single спецификатор формата "R" в некоторых случаях ошибается, так что не получается выполнить принцип "туда и обратно" без потерь, и также показывает относительно невысокую производительность. Поэтому рекомендуется вместо этого использовать для успешного преобразования спецификатор формата "G17" для значений типа Double и спецификатор формата "G9" для значений типа Single.

Когда спецификатором R форматируется значение BigInteger, то строковое значение результата содержит все значащие цифры в значении BigInteger.

Хотя Вы можете добавить спецификатор точности (precision specifier), он все равно будет игнорироваться. Принципу "туда и обратно"Round trips are given precedence over precision when using this specifier.

На строку результата влияет информация форматирования текущего объекта NumberFormatInfo. В следующей таблице перечислены свойства NumberFormatInfo, которые управляют форматированием возвращаемой строки.

Следующий пример форматирует значение BigInteger со спецификатором формата round-trip.

using System;

using System.Numerics;

public class Example
{
   public static void Main()
   { 
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}

Этот пример отобразит следующее:

      85070591730234615847396907784232501249

Важное замечание: в некоторых случаях значения типа Double, отформатированные стандартным спецификатором "R", не отвечают принципу round-trip, если программа скомпилирована с использованием опций компилятора /platform:x64 или /platform:anycpu, и запущена на 64-битных системах.

Чтобы обойти проблему со значениями Double, отформатированными стандартным форматом "R", Вы можете вместо этого выполнить форматирование значений Double использованием стандартного формата "G17". Следующий пример использует строку формата "R" со значением Double, где видно не соблюдения принципа round-trip, и также показано использование формата "G17" для успешного преобразования с выполнением условия round-trip, когда можно успешно выполнить преобразование к оригинальному значению.

using System;

using System.Globalization;

public class Example
{
   static void Main(string[] args)
   {
      Console.WriteLine("Попытка выполнить round-trip преобразование Double с помощью 'R':");
      double initialValue = 0.6822871999174;
      string valueString = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture);
      double roundTripped = double.Parse(valueString,
                                         CultureInfo.InvariantCulture);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped, initialValue.Equals(roundTripped));
      Console.WriteLine("Попытка выполнить round-trip преобразование Double с помощью 'G17':");
      string valueString17 = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture);
      double roundTripped17 = double.Parse(valueString17,
                                           CultureInfo.InvariantCulture);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped17, initialValue.Equals(roundTripped17));
   }
}

// Если приложение предназначено на любой процессор (anycpu), или на 64-битную

// платформу (x64), и запущено на системе x64, то пример выведет следующее:

//       Попытка выполнить round-trip преобразование Double с помощью 'R':

//       0.6822871999174 = 0.68228719991740006: False

//

//       Попытка выполнить round-trip преобразование Double с помощью 'G17':

//       0.6822871999174 = 0.6822871999174: True

Спецификатор шестнадцатеричного формата ("X", hexadecimal) преобразует число в строку hex-цифр. Для шестнадцатеричных цифр, которые больше 9, будут использоваться алфавитные HEX-цифры в верхнем или нижнем регистре, в зависимости от регистра спецификатора. Например, используйте "X" для генерации символов "ABCDEF", и "x" для генерации "abcdef". Этот формат поддерживается только для целочисленных типов.

Спецификатор формата (precision specifier) показывает минимальное количество цифр, которое желательно иметь в строке результата. Если необходимо, число будет дополнено слева нулями, чтобы сгенерировать количество цифр, указанное спецификатором точности.

На строку результата никак не влияет информация форматирования текущего объекта NumberFormatInfo.

Следующий пример форматирует значения Int32 со спецификатором шестнадцатеричного формата.

int value;

value = 0x2045e;
Console.WriteLine(value.ToString("x"));

// Отобразит 2045e
Console.WriteLine(value.ToString("X"));

// Отобразит 2045E
Console.WriteLine(value.ToString("X8"));

// Отобразит 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));

// Отобразит 75BCD15
Console.WriteLine(value.ToString("X2"));

// Отобразит 75BCD15