Math.Round Metoda

Definicja

Zaokrągla wartość do najbliższej liczby całkowitej lub do określonej liczby cyfr ułamkowych.Rounds a value to the nearest integer or to the specified number of fractional digits.

Przeciążenia

Round(Decimal, Int32, MidpointRounding)

Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych i używa określonej konwencji zaokrąglania dla wartości punktu środkowego.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, Int32, MidpointRounding)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych i używa określonej konwencji zaokrąglania dla wartości punktu środkowego.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, MidpointRounding)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do najbliższej liczby całkowitej i używa określonej konwencji zaokrąglania dla wartości środkowych.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

Round(Double, Int32)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Double)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, Int32)

Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Decimal)

Zaokrągla wartość dziesiętną do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, MidpointRounding)

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej i używa określonej konwencji zaokrąglania dla wartości punktu środkowego.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

Przykłady

Oprócz przykładów w sekcji uwagi ten artykuł zawiera przykłady ilustrujące następujące przeciążenia metody Math.Round:In addition to the examples in the Remarks section, this article includes examples that illustrate the following overloads of the Math.Round method:

Math. Round (Decimal)Math.Round(Decimal)
Math. Round (Double)Math.Round(Double)
Math. Round (Decimal, Int32)Math.Round(Decimal, Int32)
Math. Round (Decimal, MidpointRounding)Math.Round(Decimal, MidpointRounding)
Math. Round (Double, Int32)Math.Round(Double, Int32)
Math. Round (Double, MidpointRounding)Math.Round(Double, MidpointRounding)
Math. Round (Decimal, Int32, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)
Math. Round (Double, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Uwagi

W tej sekcji:In this section:

Jaką metodę wywołać?Which method do I call?

Aby wybrać odpowiednią metodę zaokrąglania, można użyć poniższej tabeli.You can use the following table to select an appropriate rounding method. Oprócz metod Math.Round zawiera również Math.Ceiling i Math.Floor.In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

DoTo CallCall
Zaokrąglij liczbę do liczby całkowitej, używając zaokrąglenia do najbliższej Konwencji.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

— lub —-or-

Round(Double)
Zaokrąglij liczbę do liczby całkowitej przy użyciu określonej konwencji zaokrąglania.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

— lub —-or-

Round(Double, MidpointRounding)
Zaokrąglij liczbę do określonej liczby cyfr ułamkowych, używając zaokrąglenia do najbliższej Konwencji.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

— lub —-or-

Round(Double, Int32)
Zaokrąglij liczbę do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

— lub —-or-

Round(Double, Int32, MidpointRounding)
Zaokrąglij wartość Single do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania i minimalizując utratę precyzji.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Przekonwertuj Single na Decimal i Wywołaj Round(Decimal, Int32, MidpointRounding).Convert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
Zaokrąglij liczbę do określonej liczby cyfr ułamkowych, jednocześnie minimalizując problemy dokładności w wartościach punktu środkowego.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. Wywołaj metodę rounding, która implementuje porównanie "większe niż lub w przybliżeniu równe".Call a rounding method that implements a "greater than or approximately equal to" comparison. Zobacz zaokrąglenie i dokładność.See Rounding and precision.
Zaokrąglij wartość ułamkową do liczby całkowitej, która jest większa niż wartość ułamkowa.Round a fractional value to an integer that is greater than the fractional value. Na przykład Zaokrąglij 3,1 do 4.For example, round 3.1 to 4. Ceiling
Zaokrąglij wartość ułamkową do liczby całkowitej, która jest mniejsza niż wartość ułamkowa.Round a fractional value to an integer that is less than the fractional value. Na przykład Zaokrąglij 3,9 do 3.For example, round 3.9 to 3. Floor

Wartości punktu środkowego i konwencje zaokrąglaniaMidpoint values and rounding conventions

Zaokrąglenie obejmuje konwersję wartości liczbowej z określoną dokładnością do najbliższej wartości z mniejszą dokładnością.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. Można na przykład użyć metody Round(Double), aby zaokrąglić wartość 3,4 do 3,0, i metodę Round(Double, Int32), aby zaokrąglić wartość 3,579 do 3,58.For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.

W wartości punktu środkowego wartość po najmniejszej liczbie znaczących w wyniku jest dokładnie połowa między dwoma liczbami.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Na przykład 3,47500 jest wartością punktu środkowego, jeśli ma zostać zaokrąglona dwóch miejsc dziesiętnych, a 7,500 jest wartością punktu środkowego, jeśli ma zostać zaokrąglona do liczby całkowitej.For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. W takich przypadkach Najbliższa wartość nie może być łatwo zidentyfikowana bez konwencji zaokrąglania.In these cases, the nearest value can't be easily identified without a rounding convention.

Metoda Round obsługuje dwie konwencje zaokrągleń do obsługi wartości punktu środkowego:The Round method supports two rounding conventions for handling midpoint values:

  • Zaokrąglenie w kierunku od zeraRounding away from zero

    Wartości punktu środkowego są zaokrąglane do kolejnej liczby z dala od zera.Midpoint values are rounded to the next number away from zero. Na przykład 3,75 zaokrągla do 3,8, 3,85 zaokrągla do 3,9,-3,75 zaokrągla do-3,8, a-3,85 zaokrągla do-3,9.For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. Ta forma zaokrąglania jest reprezentowana przez element członkowski wyliczenia MidpointRounding.AwayFromZero.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

    Zaokrąglanie od zera to najczęściej znana postać zaokrąglania.Rounding away from zero is the most widely known form of rounding.

  • Zaokrąglenie do najbliższej lub zaokrąglania w bankuRounding to nearest, or banker's rounding

    Wartości punktu środkowego są zaokrąglane do najbliższej parzystej liczby.Midpoint values are rounded to the nearest even number. Na przykład zarówno 3,75, jak i 3,85, do 3,8 i oba-3,75 i-3,85 zaokrąglić do-3,8.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. Ta forma zaokrąglania jest reprezentowana przez element członkowski wyliczenia MidpointRounding.ToEven.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

    Zaokrąglanie do najbliższe jest standardowym formą zaokrąglania używanego w operacjach finansowych i statystycznych.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Jest zgodna ze standardem IEEE 754, sekcja 4.It conforms to IEEE Standard 754, section 4. Gdy jest używany w wielu operacjach zaokrąglania, zmniejsza to błąd zaokrąglania, który jest spowodowany przez spójne Zaokrąglanie wartości punktu środkowego w jednym kierunku.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. W niektórych przypadkach ten błąd zaokrąglania może być znaczący.In some cases, this rounding error can be significant.

    Poniższy przykład ilustruje odchylenia, które mogą wynikać ze spójnego zaokrąglania wartości punktu środkowego w jednym kierunku.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. W przykładzie jest obliczana wartość rzeczywista średniej tablicy wartości Decimal, a następnie obliczana jest średnia, gdy wartości w tablicy są zaokrąglane przy użyciu dwóch Konwencji.The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. W tym przykładzie prawdziwe znaczenie i średni wynik, gdy Zaokrąglenie do najbliższej jest takie samo.In this example, the true mean and the mean that results when rounding to nearest are the same. Jednak oznacza to, że wartość jest zaokrąglana w kierunku od zera do .05 (lub przez 3,6%) od prawdziwego znaczenia.However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.

    decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
    decimal sum = 0;
    
    // Calculate true mean.
    foreach (var value in values)
       sum += value;
    
    Console.WriteLine("True mean:     {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding away from zero.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
    
    Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length);
    
    // Calculate mean with rounding to nearest.
    sum = 0;
    foreach (var value in values)
       sum += Math.Round(value, 1, MidpointRounding.ToEven);
    
    Console.WriteLine("ToEven:        {0:N2}", sum/values.Length);
    // The example displays the following output:
    //       True mean:     1.40
    //       AwayFromZero:  1.45
    //       ToEven:        1.40
    
    Module Example
       Public Sub Main()
          Dim values() As Decimal = { 1.15d, 1.25d, 1.35d, 1.45d, 1.55d, 1.65d }
          Dim sum As Decimal
          
          ' Calculate true mean.
          For Each value In values
             sum += value
          Next
          Console.WriteLine("True mean:     {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding away from zero.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
          Next
          Console.WriteLine("AwayFromZero:  {0:N2}", sum/values.Length)
          
          ' Calculate mean with rounding to nearest.
          sum = 0
          For Each value In values
             sum += Math.Round(value, 1, MidpointRounding.ToEven)
          Next
          Console.WriteLine("ToEven:        {0:N2}", sum/values.Length)
       End Sub
    End Module
    ' The example displays the following output:
    '       True mean:     1.40
    '       AwayFromZero:  1.45
    '       ToEven:        1.40
    

Domyślnie metoda Round używa zaokrąglania do najbliższej Konwencji.By default, the Round method uses the rounding to nearest convention. Poniższa tabela zawiera listę przeciążeń metody Round oraz konwencji zaokrąglania używanej przez każdy z nich.The following table lists the overloads of the Round method and the rounding convention that each uses.

PrzeciążenieOverload Konwencja zaokrąglaniaRounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Określone przez parametr mode.Determined by mode parameter.
Round(Double, MidpointRounding) Określone przez mode parametrDetermined by mode parameter
Round(Decimal, Int32, MidpointRounding) Określone przez mode parametrDetermined by mode parameter
Round(Double, Int32, MidpointRounding) Określone przez mode parametrDetermined by mode parameter

Zaokrąglenia i dokładnośćRounding and precision

Aby określić, czy operacja zaokrąglania obejmuje wartość punktu środkowego, Metoda Round mnoży pierwotną wartość, która ma zostać zaokrąglona o 10n, gdzie n to wymagana liczba ułamkowych cyfr w wartości zwracanej, a następnie określa, czy pozostała część ułamkowa wartości jest większa od lub równa. 5.In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. Jest to niewielka odmiana testu pod kątem równości i opisana w sekcji "testowanie pod kątem równości" tematu referencyjnego Double, testy pod kątem równości z wartościami zmiennoprzecinkowymi są problematyczne ze względu na problemy z formatem zmiennoprzecinkowym z reprezentacją binarną i dokładnością.This is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. Oznacza to, że każda część ułamkowa liczby, która jest nieco mniejsza niż .5 (ze względu na utratę precyzji) nie zostanie zaokrąglona w górę.This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

Poniższy przykład ilustruje ten problem.The following example illustrates the problem. Wielokrotnie dodaje liczbę do 11,0 i zaokrągla wynik do najbliższej liczby całkowitej.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Niezależnie od konwencji zaokrąglania 11,5 powinna być zaokrąglana do 12.Regardless of the rounding convention, 11.5 should round to 12. Jednak jako dane wyjściowe z przykładu są wyświetlane, nie.However, as the output from the example shows, it does not. W przykładzie użyto standardowego ciągu formatu liczbowego "R", aby wyświetlić pełną precyzję wartości zmiennoprzecinkowej i pokazuje, że wartość, która ma zostać zaokrąglona, ma utraconą precyzję podczas kolejnych operacji dodawania, a jej wartość jest rzeczywiście 11.499999999999998.The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. Ponieważ. 499999999999998 jest mniejsza niż .5, wartość nie jest zaokrąglana do najbliższej najwyższej wartości całkowitej.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Jak pokazano na przykładzie, ten problem nie występuje, jeśli po prostu przypiszemy wartość stałą 11,5 do zmiennej Double.As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.

using System;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero");
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12
Module Example
   Public Sub Main()
      Dim value As Double = 11.1

      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}", 
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero")
      Console.WriteLine()
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                        value, Math.Round(value, MidpointRounding.ToEven),
                        Math.Round(value, MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Problemy z dokładnością w zaokrągleniu wartości punktu środkowego najprawdopodobniej wystąpią w następujących warunkach:Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

W przypadkach, gdy brak dokładności operacji zaokrąglania jest problematyczny, można wykonać następujące czynności:In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • Jeśli operacja zaokrąglania wywołuje Przeciążenie, które Zaokrągla wartość Double, można zmienić Double na wartość Decimal i wywoływać przeciążenie, które w zamian zaokrągli wartość Decimal.If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. Chociaż Decimal typ danych ma również problemy z reprezentacją i utratą dokładności, te problemy są znacznie mniej popularne.Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • Zdefiniuj niestandardowy algorytm zaokrąglania, który wykonuje "niemal równe" testy, aby określić, czy wartość, która ma zostać zaokrąglona, jest zadowalająco blisko wartości punktu środkowego.Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. W poniższym przykładzie zdefiniowano metodę RoundApproximate, która bada, czy wartość ułamkowa jest wystarczająco blisko wartości punktu środkowego, która ma podlegać zaokrągleniu do punktu środkowego.The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. Dane wyjściowe z przykładu pokazują, że rozwiązuje problem z zaokrąglaniem pokazanym w poprzednim przykładzie.As the output from the example shows, it corrects the rounding problem shown in the previous example.

    :::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round.overload/cs/precision2.cs" interactive="try-dotnet" id="Snippet8":::
    :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round.overload/vb/precision2.vb" id="Snippet8":::
    

Zaokrąglenia i pojedyncza precyzja wartości zmiennoprzecinkowychRounding and single-precision floating-point values

Metoda Round obejmuje przeciążenia, które akceptują argumenty typu Decimal i Double.The Round method includes overloads that accept arguments of type Decimal and Double. Nie ma metod, które zaokrąglią wartości typu Single.There are no methods that round values of type Single. W przypadku przekazania wartości Single do jednego z przeciążeń metody Round, jest rzutowana (in C#) lub przekonwertowana (w Visual Basic) do Double, a odpowiednie przeciążenia Round z parametrem Double jest wywoływana.If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. Chociaż jest to konwersja rozszerzająca, często wiąże się z utratą precyzji, jak pokazano w poniższym przykładzie.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. Gdy Single wartość 16,325 jest przekazywany do metody Round i zaokrąglana do dwóch miejsc dziesiętnych przy użyciu zaokrąglenia do najbliższej Konwencji, wynik wynosi 16,33, a nie oczekiwany wynik 16,32.When a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 16.325f;
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                        value, value.GetType().Name, (double) value,
                        ((double) (value)).GetType().Name);
      Console.WriteLine(Math.Round(value, 2));
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
      Console.WriteLine();

      Decimal decValue = (decimal) value;
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                        value, value.GetType().Name, decValue,
                        decValue.GetType().Name);
      Console.WriteLine(Math.Round(decValue, 2));
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33
Module Example
   Public Sub Main()
      Dim value As Single = 16.325
      Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ", 
                        value, value.GetType().Name, CDbl(value), 
                        CDbl(value).GetType().Name)
      Console.WriteLine(Math.Round(value, 2))
      Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
      
      Dim decValue As Decimal = CDec(value)
      Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ", 
                        value, value.GetType().Name, decValue, 
                        decValue.GetType().Name)
      Console.WriteLine(Math.Round(decValue, 2))
      Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

Nieoczekiwany wynik wynika z utraty dokładności konwersji wartości Single na Double.This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Ponieważ 16.325000762939453 wartość Double nie jest wartością punktu środkowego i jest większa niż 16,325, jest zawsze zaokrąglana w górę.Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.

W wielu przypadkach, jak pokazano w przykładzie, ubytek dokładności może być zminimalizowany lub eliminowany przez rzutowanie lub przekonwertowanie wartości Single na Decimal.In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. Należy zauważyć, że ponieważ jest to zawężana konwersja, wymaga użycia operatora rzutowania lub wywołania metody konwersji.Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.

Round(Decimal, Int32, MidpointRounding)

Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych i używa określonej konwencji zaokrąglania dla wartości punktu środkowego.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public static decimal Round (decimal d, int decimals, MidpointRounding mode);
static member Round : decimal * int * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parametry

d
Decimal

Liczba dziesiętna ma zostać zaokrąglona.A decimal number to be rounded.

decimals
Int32

Liczba miejsc dziesiętnych w wartości zwracanej.The number of decimal places in the return value.

mode
MidpointRounding

Specyfikacja sposobu zaokrąglania d, jeśli jest w połowie między dwiema innymi liczbami.Specification for how to round d if it is midway between two other numbers.

Zwraca

Decimal

Liczba Najbliższa d, która zawiera liczbę cyfr dziesiętnych równą decimals.The number nearest to d that contains a number of fractional digits equal to decimals. Jeśli d ma mniej cyfr ułamkowych niż decimals, d jest zwracany bez zmian.If d has fewer fractional digits than decimals, d is returned unchanged.

Wyjątki

decimals jest mniejsza niż 0 lub większa niż 28.decimals is less than 0 or greater than 28.

mode nie jest prawidłową wartością MidpointRounding.mode is not a valid value of MidpointRounding.

Wynik znajduje się poza zakresem Decimal.The result is outside the range of a Decimal.

Uwagi

Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

Wartość argumentu decimals może być z zakresu od 0 do 28.The value of the decimals argument can range from 0 to 28.

PrzykładExample

Poniższy przykład ilustruje sposób użycia metody Round z wyliczeniem MidpointRounding.The following example demonstrates how to use the Round method with the MidpointRounding enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    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();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    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();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    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();
}

/*
This code example produces the following results:

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)

*/
decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number.
// The precision of the result is 1 decimal place.

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();

// Round a positive value to the nearest even number, then to the nearest number away from zero.
// The precision of the result is 1 decimal place.

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();

// Round a negative value to the nearest even number, then to the nearest number away from zero.
// The precision of the result is 1 decimal place.

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();
/*
This code example produces the following results:

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)

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        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()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        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()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        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()
    
    End Sub
End Class
'
'This code example produces the following results:
'
' 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)
'

Zobacz też

Round(Double, Int32, MidpointRounding)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych i używa określonej konwencji zaokrąglania dla wartości punktu środkowego.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

public:
 static double Round(double value, int digits, MidpointRounding mode);
public static double Round (double value, int digits, MidpointRounding mode);
static member Round : double * int * MidpointRounding -> double
Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

Parametry

value
Double

Liczba zmiennoprzecinkowa podwójnej precyzji, która ma zostać zaokrąglona.A double-precision floating-point number to be rounded.

digits
Int32

Liczba cyfr ułamkowych w wartości zwracanej.The number of fractional digits in the return value.

mode
MidpointRounding

Specyfikacja sposobu zaokrąglania value, jeśli jest w połowie między dwiema innymi liczbami.Specification for how to round value if it is midway between two other numbers.

Zwraca

Double

Liczba Najbliższa value, która ma liczbę cyfr ułamkowych równą digits.The number nearest to value that has a number of fractional digits equal to digits. Jeśli value ma mniej cyfr ułamkowych niż digits, value jest zwracany bez zmian.If value has fewer fractional digits than digits, value is returned unchanged.

Wyjątki

digits jest mniejsza niż 0 lub większa niż 15.digits is less than 0 or greater than 15.

mode nie jest prawidłową wartością MidpointRounding.mode is not a valid value of MidpointRounding.

Uwagi

Wartość argumentu digits może być z zakresu od 0 do 15.The value of the digits argument can range from 0 to 15. Należy zauważyć, że 15 to maksymalna liczba cyfr całkowitych i ułamkowych obsługiwanych przez typ Double.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

Jeśli wartość argumentu value jest Double.NaN, metoda zwróci Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Jeśli value jest Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwróci odpowiednio Double.PositiveInfinity lub Double.NegativeInfinity.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

PrzykładExample

Poniższy przykład ilustruje sposób użycia metody Round(Double, Int32, MidpointRounding) z wyliczeniem MidpointRounding.The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.

 double posValue =  3.45;
 double negValue = -3.45;

 // Round a positive and a negative value using the default.
 double 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)\n", result, negValue);

 // Round a positive value using a MidpointRounding value.
 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)\n",
                   result, posValue);

 // Round a negative value using a MidpointRounding value.
 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)\n",
                   result, negValue);
// The example displays the following output:
//        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)
Module Example
    Public Sub Main() 
        Dim posValue As Double = 3.45
        Dim negValue As Double = -3.45
        
        ' Round a positive and a negative value using the default.  
        Dim result As Double = 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()
        
        ' Round a positive value using a MidpointRounding value. 
        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()
        
        ' Round a positive value using a MidpointRounding value. 
        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()
    End Sub
End Module
' The example displays the following output:
'       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)

Uwagi dotyczące wywoływania

Ze względu na utratę precyzji, która może wynikać z reprezentowania wartości dziesiętnych jako liczby zmiennoprzecinkowe lub wykonywania operacji arytmetycznych na wartościach zmiennoprzecinkowych, w niektórych przypadkach Metoda Round(Double, Int32, MidpointRounding) może nie być widoczna w wartościach punktu środkowego określonego przez parametr mode.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. Jest to zilustrowane w poniższym przykładzie, gdzie 2,135 jest zaokrąglana do 2,13 zamiast 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Dzieje się tak, ponieważ wewnętrznie metoda mnoży value o 10cyfr, a operacja mnożenia w tym przypadku spada z utraty dokładności.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

::: Code Language = "CSharp" source = "~/Samples/Snippets/CSharp/VS_Snippets_CLR_System/system.Math.Round/CS/round4.cs" Interactive = "try-dotnet-Method" ID = "Snippet3":::.:: Code Language = "VB" source = "~/Samples/Snippets/VisualBasic/VS_Snippets_CLR_System/system.Math.Round/VB/round4.vb" ID = "Snippet3"::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round4.cs" interactive="try-dotnet-method" id="Snippet3"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round4.vb" id="Snippet3":::

Zobacz też

Round(Double, MidpointRounding)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do najbliższej liczby całkowitej i używa określonej konwencji zaokrąglania dla wartości środkowych.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

public:
 static double Round(double value, MidpointRounding mode);
public static double Round (double value, MidpointRounding mode);
static member Round : double * MidpointRounding -> double
Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

Parametry

value
Double

Liczba zmiennoprzecinkowa podwójnej precyzji, która ma zostać zaokrąglona.A double-precision floating-point number to be rounded.

mode
MidpointRounding

Specyfikacja sposobu zaokrąglania value, jeśli jest w połowie między dwiema innymi liczbami.Specification for how to round value if it is midway between two other numbers.

Zwraca

Double

Najbliższa liczba całkowita value.The integer nearest value. Jeśli value jest w połowie między dwoma liczbami całkowitymi, a jedna z nich jest parzysta, a druga nieparzysta, wówczas mode określa, które z dwóch wartości są zwracane.If value is halfway between two integers, one of which is even and the other odd, then mode determines which of the two is returned. Należy zauważyć, że ta metoda zwraca Double zamiast typu całkowitego.Note that this method returns a Double instead of an integral type.

Wyjątki

mode nie jest prawidłową wartością MidpointRounding.mode is not a valid value of MidpointRounding.

Uwagi

Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

Jeśli wartość argumentu value jest Double.NaN, metoda zwróci Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Jeśli value jest Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwróci odpowiednio Double.PositiveInfinity lub Double.NegativeInfinity.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

PrzykładExample

Poniższy przykład wyświetla wartości zwracane przez metodę Round(Double), metodę Round(Double, MidpointRounding) z argumentem mode ToEvenoraz metodę Round(Double, MidpointRounding) z argumentem mode AwayFromZero.The following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                          12.7, 12.8, 12.9, 13.0 };
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default",
                        "ToEven", "AwayFromZero");
      foreach (var value in values)
         Console.WriteLine("{0,-10:R} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value),
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero));
   }
}
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13         13         13         13
Module Example
   Public Sub Main()
      Dim values() As Double = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 
                                 12.7, 12.8, 12.9, 13.0 }
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For Each value In values
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13         13         13         13

Uwagi dotyczące wywoływania

Ze względu na utratę precyzji, która może wynikać z reprezentowania wartości dziesiętnych jako liczby zmiennoprzecinkowe lub wykonywania operacji arytmetycznych na wartościach zmiennoprzecinkowych, w niektórych przypadkach Metoda Round(Double, MidpointRounding) może nie być widoczna do najbliższej parzystej liczby całkowitej.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, MidpointRounding) method may not appear to round midpoint values to the nearest even integer. W poniższym przykładzie, ponieważ wartość zmiennoprzecinkowa nie ma skończonej reprezentacji binarnej, pierwsze wywołanie metody Round(Double) z wartością 11,5 zwraca wartość 11 zamiast 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

::: Code Language = "CSharp" source = "~/Samples/Snippets/CSharp/VS_Snippets_CLR_System/system.Math.Round/CS/round5.cs" Interactive = "try-dotnet" ID = "Snippet4"::::.: Code Language = "VB" source = "~/Samples/Snippets/VisualBasic/VS_Snippets_CLR_System/system.Math.Round/VB/round5.vb" ID = "Snippet4"::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round5.cs" interactive="try-dotnet" id="Snippet4"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round5.vb" id="Snippet4":::

Zobacz też

Round(Double, Int32)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

public:
 static double Round(double value, int digits);
public static double Round (double value, int digits);
static member Round : double * int -> double
Public Shared Function Round (value As Double, digits As Integer) As Double

Parametry

value
Double

Liczba zmiennoprzecinkowa podwójnej precyzji, która ma zostać zaokrąglona.A double-precision floating-point number to be rounded.

digits
Int32

Liczba cyfr ułamkowych w wartości zwracanej.The number of fractional digits in the return value.

Zwraca

Double

Liczba Najbliższa value, która zawiera liczbę cyfr dziesiętnych równą digits.The number nearest to value that contains a number of fractional digits equal to digits.

Wyjątki

digits jest mniejsza niż 0 lub większa niż 15.digits is less than 0 or greater than 15.

Uwagi

Wartość argumentu digits może być z zakresu od 0 do 15.The value of the digits argument can range from 0 to 15. Należy zauważyć, że 15 to maksymalna liczba cyfr całkowitych i ułamkowych obsługiwanych przez typ Double.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Ta metoda używa domyślnej konwencji zaokrąglania MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

Jeśli wartość argumentu value jest Double.NaN, metoda zwróci Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Jeśli value jest Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwróci odpowiednio Double.PositiveInfinity lub Double.NegativeInfinity.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

PrzykładExample

W poniższym przykładzie są zaokrąglane podwójne wartości z dwiema cyframi dwubajtowymi, które mają pojedynczą cyfrę.The following example rounds double values with two fractional digits to doubles that have a single fractional digit.

Math::Round(3.44, 1); //Returns 3.4.
Math::Round(3.45, 1); //Returns 3.4.
Math::Round(3.46, 1); //Returns 3.5.

Math::Round(4.34, 1); // Returns 4.3
Math::Round(4.35, 1); // Returns 4.4
Math::Round(4.36, 1); // Returns 4.4
Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4
Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

Uwagi dotyczące wywoływania

Ze względu na utratę precyzji, która może wynikać z reprezentowania wartości dziesiętnych jako liczby zmiennoprzecinkowe lub wykonywania operacji arytmetycznych na wartościach zmiennoprzecinkowych, w niektórych przypadkach Metoda Round(Double, Int32) może nie być widoczna, aby zaokrąglić wartości punktu środkowego do najbliższej parzystej wartości w pozycji digits miejsca dziesiętnego.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32) method may not appear to round midpoint values to the nearest even value in the digits decimal position. Jest to zilustrowane w poniższym przykładzie, gdzie 2,135 jest zaokrąglana do 2,13 zamiast 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Dzieje się tak, ponieważ wewnętrznie metoda mnoży value o 10cyfr, a operacja mnożenia w tym przypadku spada z utraty dokładności.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

::: Code Language = "CSharp" source = "~/Samples/Snippets/CSharp/VS_Snippets_CLR_System/system.Math.Round/CS/round3.cs" Interactive = "try-dotnet" ID = "Snippet2"::::.: Code Language = "VB" source = "~/Samples/Snippets/VisualBasic/VS_Snippets_CLR_System/system.Math.Round/VB/round3.vb" ID = "Snippet2"::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round3.cs" interactive="try-dotnet" id="Snippet2"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round3.vb" id="Snippet2":::

Zobacz też

Round(Double)

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

public:
 static double Round(double a);
public static double Round (double a);
static member Round : double -> double
Public Shared Function Round (a As Double) As Double

Parametry

a
Double

Liczba zmiennoprzecinkowa podwójnej precyzji, która ma zostać zaokrąglona.A double-precision floating-point number to be rounded.

Zwraca

Double

Najbliższa liczba całkowita a.The integer nearest a. Jeśli składnik częściowy a jest w połowie między dwoma liczbami całkowitymi, a jednym z nich jest parzystość, a druga nieparzysta, zwracana jest liczba parzysta.If the fractional component of a is halfway between two integers, one of which is even and the other odd, then the even number is returned. Należy zauważyć, że ta metoda zwraca Double zamiast typu całkowitego.Note that this method returns a Double instead of an integral type.

Uwagi

Ta metoda używa domyślnej konwencji zaokrąglania MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

Jeśli wartość argumentu a jest Double.NaN, metoda zwróci Double.NaN.If the value of the a argument is Double.NaN, the method returns Double.NaN. Jeśli a jest Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwróci odpowiednio Double.PositiveInfinity lub Double.NegativeInfinity.If a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

Począwszy od Visual Basic 15,8, wydajność konwersji podwójnej do liczby całkowitej jest zoptymalizowana, jeśli przekazujesz wartość zwróconą przez metodę Round do którejkolwiek funkcji konwersjicałkowitej lub jeśli wartość podwójnej zwrócone przez Round jest automatycznie konwertowana na liczbę całkowitą z opcją Strict ustawiona na off.Starting with Visual Basic 15.8, the performance of Double-to-integer conversion is optimized if you pass the value returned by the Round method to the any of the integral conversion functions, or if the Double value returned by Round is automatically converted to an integer with Option Strict set to Off. Ta optymalizacja umożliwia szybsze uruchamianie kodu — maksymalnie dwa razy w przypadku kodu, który wykonuje dużą liczbę konwersji na typy całkowite.This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. Poniższy przykład ilustruje takie zoptymalizowane konwersje:The following example illustrates such optimized conversions:

Dim d1 As Double = 1043.75133
Dim i1 As Integer = CInt(Math.Ceiling(d1))        ' Result: 1044

Dim d2 As Double = 7968.4136
Dim i2 As Integer = CInt(Math.Ceiling(d2))        ' Result: 7968

PrzykładExample

Poniższy przykład ilustruje Zaokrąglenie do najbliższej wartości całkowitej.The following example demonstrates rounding to the nearest integer value.

using namespace System;

void main()
{
    Console::WriteLine("Classic Math.Round in CPP");
    Console::WriteLine(Math::Round(4.4));     // 4
    Console::WriteLine(Math::Round(4.5));     // 4
    Console::WriteLine(Math::Round(4.6));     // 5
    Console::WriteLine(Math::Round(5.5));     // 6
}
Console.WriteLine("Classic Math.Round in CSharp");
Console.WriteLine(Math.Round(4.4)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(4.6)); // 5
Console.WriteLine(Math.Round(5.5)); // 6
Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

Uwagi dotyczące wywoływania

Ze względu na utratę precyzji, która może wynikać z reprezentowania wartości dziesiętnych jako liczby zmiennoprzecinkowe lub wykonywania operacji arytmetycznych na wartościach zmiennoprzecinkowych, w niektórych przypadkach Metoda Round(Double) może nie być widoczna do najbliższej parzystej liczby całkowitej.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double) method may not appear to round midpoint values to the nearest even integer. W poniższym przykładzie, ponieważ wartość zmiennoprzecinkowa nie ma skończonej reprezentacji binarnej, pierwsze wywołanie metody Round(Double) z wartością 11,5 zwraca wartość 11 zamiast 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

::: Code Language = "CSharp" source = "~/Samples/Snippets/CSharp/VS_Snippets_CLR_System/system.Math.Round/CS/round2.cs" Interactive = "try-dotnet" ID = "Snippet1"::::.: Code Language = "VB" source = "~/Samples/Snippets/VisualBasic/VS_Snippets_CLR_System/system.Math.Round/VB/round2.vb" ID = "Snippet1"::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round2.cs" interactive="try-dotnet" id="Snippet1"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round2.vb" id="Snippet1":::

Zobacz też

Round(Decimal, Int32)

Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

public:
 static System::Decimal Round(System::Decimal d, int decimals);
public static decimal Round (decimal d, int decimals);
static member Round : decimal * int -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parametry

d
Decimal

Liczba dziesiętna ma zostać zaokrąglona.A decimal number to be rounded.

decimals
Int32

Liczba miejsc dziesiętnych w wartości zwracanej.The number of decimal places in the return value.

Zwraca

Decimal

Liczba Najbliższa d, która zawiera liczbę cyfr dziesiętnych równą decimals.The number nearest to d that contains a number of fractional digits equal to decimals.

Wyjątki

decimals jest mniejsza niż 0 lub większa niż 28.decimals is less than 0 or greater than 28.

Wynik znajduje się poza zakresem Decimal.The result is outside the range of a Decimal.

Uwagi

Wartość argumentu decimals może być z zakresu od 0 do 28.The value of the decimals argument can range from 0 to 28.

Ta metoda używa domyślnej konwencji zaokrąglania MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

PrzykładExample

Poniższy przykład zaokrągla wartości dziesiętne o dwie cyfry ułamkowe do wartości, które mają jedną cyfrę ułamkową.The following example rounds decimal values with two fractional digits to values that have a single fractional digit.

Console.WriteLine(Math.Round(3.44m, 1));
Console.WriteLine(Math.Round(3.45m, 1));
Console.WriteLine(Math.Round(3.46m, 1));
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1));
Console.WriteLine(Math.Round(4.35m, 1));
Console.WriteLine(Math.Round(4.36m, 1));
// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4
Public Module Example
   Sub Main()
      Console.WriteLine(Math.Round(3.44, 1)) 
      Console.WriteLine(Math.Round(3.45, 1)) 
      Console.WriteLine(Math.Round(3.46, 1)) 
      Console.WriteLine()
      
      Console.WriteLine(Math.Round(4.34, 1)) 
      Console.WriteLine(Math.Round(4.35, 1)) 
      Console.WriteLine(Math.Round(4.36, 1)) 
   End Sub  
End Module
' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Zobacz też

Round(Decimal)

Zaokrągla wartość dziesiętną do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej parzystej liczby.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

public:
 static System::Decimal Round(System::Decimal d);
public static decimal Round (decimal d);
static member Round : decimal -> decimal
Public Shared Function Round (d As Decimal) As Decimal

Parametry

d
Decimal

Liczba dziesiętna ma zostać zaokrąglona.A decimal number to be rounded.

Zwraca

Decimal

Liczba całkowita najbliżej parametru d.The integer nearest the d parameter. Jeśli składnik częściowy d jest w połowie między dwoma liczbami całkowitymi, a jednym z nich jest parzystość, a druga nieparzysta, zwracana jest liczba parzysta.If the fractional component of d is halfway between two integers, one of which is even and the other odd, the even number is returned. Należy zauważyć, że ta metoda zwraca Decimal zamiast typu całkowitego.Note that this method returns a Decimal instead of an integral type.

Wyjątki

Wynik znajduje się poza zakresem Decimal.The result is outside the range of a Decimal.

Przykłady

Poniższy przykład demonstruje metodę Round(Decimal).The following example demonstrates the Round(Decimal) method. Należy pamiętać, że wartość Decimal 4,5 zaokrągla do 4 zamiast 5, ponieważ to Przeciążenie używa domyślnej Konwencji ToEven.Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.

for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
   Console.WriteLine("{0} --> {1}", value, Math.Round(value));
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5
Module Example
   Public Sub Main()
      For value As Decimal = 4.2d To 4.8d Step .1d
         Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Next   
   End Sub                                                                 
End Module
' The example displays the following output:
'       4.2 --> 4
'       4.3 --> 4
'       4.4 --> 4
'       4.5 --> 4
'       4.6 --> 5
'       4.7 --> 5
'       4.8 --> 5

Uwagi

Ta metoda używa domyślnej konwencji zaokrąglania MidpointRounding.ToEven.This method uses the default rounding convention of MidpointRounding.ToEven. Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

Zobacz też

Round(Decimal, MidpointRounding)

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej i używa określonej konwencji zaokrąglania dla wartości punktu środkowego.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);
public static decimal Round (decimal d, MidpointRounding mode);
static member Round : decimal * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parametry

d
Decimal

Liczba dziesiętna ma zostać zaokrąglona.A decimal number to be rounded.

mode
MidpointRounding

Specyfikacja sposobu zaokrąglania d, jeśli jest w połowie między dwiema innymi liczbami.Specification for how to round d if it is midway between two other numbers.

Zwraca

Decimal

Najbliższa liczba całkowita d.The integer nearest d. Jeśli d jest w połowie między dwoma liczbami, a jedna z nich jest parzysta, a druga nieparzysta, wówczas mode określa, które z dwóch wartości są zwracane.If d is halfway between two numbers, one of which is even and the other odd, then mode determines which of the two is returned. Należy zauważyć, że ta metoda zwraca Decimal zamiast typu całkowitego.Note that this method returns a Decimal instead of an integral type.

Wyjątki

mode nie jest prawidłową wartością MidpointRounding.mode is not a valid value of MidpointRounding.

Wynik znajduje się poza zakresem Decimal.The result is outside the range of a Decimal.

Uwagi

Zobacz wartości punktu środkowego i konwencje zaokrąglania, Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktów środkowych.See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Ważne

Podczas zaokrąglania wartości punktu środkowego, algorytm zaokrąglania wykonuje testu równości.When rounding midpoint values, the rounding algorithm performs an equality test. Z powodu problemów z reprezentacji binarnej i dokładności w formacie zmiennoprzecinkowych wartość zwracana przez metoda może być nieoczekiwany.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Aby uzyskać więcej informacji, zobacz "Zaokrąglanie i dokładność".For more information, see "Rounding and precision".

PrzykładExample

Poniższy przykład wyświetla wartości zwracane przez metodę Round(Decimal), metodę Round(Decimal, MidpointRounding) z argumentem mode ToEvenoraz metodę Round(Decimal, MidpointRounding) z argumentem mode AwayFromZero.The following example displays values returned by the Round(Decimal) method, the Round(Decimal, MidpointRounding) method with a mode argument of ToEven, and the Round(Decimal, MidpointRounding) method with a mode argument of AwayFromZero.

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default",
                  "ToEven", "AwayFromZero");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
   Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                     value, Math.Round(value),
                     Math.Round(value, MidpointRounding.ToEven),
                     Math.Round(value, MidpointRounding.AwayFromZero));
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13         13         13         13
Module Example
   Public Sub Main()
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For value As Decimal = 12.0d To 13.0d Step .1d
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13         13         13         13

Zobacz też

Dotyczy