Decimal.Round Metoda

Definicja

Zaokrągla wartość do najbliższej liczby całkowitej lub określonej liczby miejsc dziesiętnych.Rounds a value to the nearest integer or specified number of decimal places.

Przeciążenia

Round(Decimal)

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej.Rounds a decimal value to the nearest integer.

Round(Decimal, Int32)

Zaokrągla Decimal wartość do określonej liczby miejsc dziesiętnych.Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding)

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej.Rounds a decimal value to the nearest integer. Parametr określa sposób zaokrąglania wartości, jeśli jest ona w połowie między dwiema innymi liczbami.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding)

Zaokrągla wartość dziesiętną do określonej precyzji.Rounds a decimal value to a specified precision. Parametr określa sposób zaokrąglania wartości, jeśli jest ona w połowie między dwiema innymi liczbami.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal)

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej.Rounds a decimal value to the nearest integer.

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 do zaokrąglenia.A decimal number to round.

Zwraca

Decimal

Liczba całkowita znajdująca się najbliżej d parametru.The integer that is nearest to the d parameter. Jeśli d jest w połowie między dwoma liczbami całkowitymi, a jedna z nich jest parzysta, a druga nieparzysta, zwracana jest liczba parzysta.If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

Wyjątki

Wynik jest poza zakresem Decimal wartości.The result is outside the range of a Decimal value.

Przykłady

Poniższy przykład zaokrągla zakres wartości z zakresu Decimal od 100 do 102 do najbliższej liczby całkowitej.The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Ponieważ metoda używa zaokrągleń przez Bank, należy pamiętać, że 100,5 zaokrągla do 100 i 101,5 zaokrągla do 102.Because the method uses banker's rounding, note that 100.5 rounds to 100 and 101.5 rounds to 102.

using System;

public class Example
{
   public static void Main()
   {
      for (decimal value = 100m; value <= 102m; value += .1m)
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value));
   }
}
// The example displays the following output:
//     100 --> 100
//     100.1 --> 100
//     100.2 --> 100
//     100.3 --> 100
//     100.4 --> 100
//     100.5 --> 100
//     100.6 --> 101
//     100.7 --> 101
//     100.8 --> 101
//     100.9 --> 101
//     101.0 --> 101
//     101.1 --> 101
//     101.2 --> 101
//     101.3 --> 101
//     101.4 --> 101
//     101.5 --> 102
//     101.6 --> 102
//     101.7 --> 102
//     101.8 --> 102
//     101.9 --> 102
//     102.0 --> 102
Module Example
   Public Sub Main()
      For value As Decimal = 100d To 102d Step .1d
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value))
      Next
   End Sub
End Module
' The example displays the following output:
'     100 --> 100
'     100.1 --> 100
'     100.2 --> 100
'     100.3 --> 100
'     100.4 --> 100
'     100.5 --> 100
'     100.6 --> 101
'     100.7 --> 101
'     100.8 --> 101
'     100.9 --> 101
'     101.0 --> 101
'     101.1 --> 101
'     101.2 --> 101
'     101.3 --> 101
'     101.4 --> 101
'     101.5 --> 102
'     101.6 --> 102
'     101.7 --> 102
'     101.8 --> 102
'     101.9 --> 102
'     102.0 --> 102

Uwagi

Zachowanie tej metody jest zgodne ze standardem IEEE 754, sekcja 4.The behavior of this method follows IEEE Standard 754, section 4. Tego rodzaju zaokrąglenie jest czasami nazywane zaokrąglaniem połowę do nawet lub Zaokrąglenie w banku.This kind of rounding is sometimes called round half to even or banker's rounding. Minimalizuje błędy zaokrąglania wynikające ze spójnego zaokrąglania wartości punktu środkowego w jednym kierunku.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. Jest równoważne wywołaniu Round(Decimal, MidpointRounding) metody z mode argumentem MidpointRounding.ToEven .It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

Zobacz też

Round(Decimal, Int32)

Zaokrągla Decimal wartość do określonej liczby miejsc dziesiętnych.Rounds a Decimal value to a specified number of decimal places.

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 do zaokrąglenia.A decimal number to round.

decimals
Int32

Wartość z przenoszącą od 0 do 28 określająca liczbę miejsc dziesiętnych do zaokrąglenia.A value from 0 to 28 that specifies the number of decimal places to round to.

Zwraca

Decimal

Liczba dziesiętna odpowiadająca liczbie miejsc dziesiętnych d decimals .The decimal number equivalent to d rounded to decimals number of decimal places.

Wyjątki

decimals nie jest wartością z przenosią od 0 do 28.decimals is not a value from 0 to 28.

Przykłady

Poniższy przykład zaokrągla kilka Decimal wartości do określonej liczby miejsc dziesiętnych przy użyciu Round metody.The following example rounds several Decimal values to a specified number of decimal places using the Round method.

using System;

class Example
{
   public static void Main()
   {
      // Define a set of Decimal values.
      decimal[] values = { 1.45m, 1.55m, 123.456789m, 123.456789m,
                           123.456789m, -123.456m,
                           new Decimal(1230000000, 0, 0, true, 7 ),
                           new Decimal(1230000000, 0, 0, true, 7 ),
                           -9999999999.9999999999m,
                           -9999999999.9999999999m };
      // Define a set of integers to for decimals argument.
      int[] decimals = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10};

      Console.WriteLine("{0,26}{1,8}{2,26}",
                        "Argument", "Digits", "Result" );
      Console.WriteLine("{0,26}{1,8}{2,26}",
                        "--------", "------", "------" );
      for (int ctr = 0; ctr < values.Length; ctr++)
        Console.WriteLine("{0,26}{1,8}{2,26}",
                          values[ctr], decimals[ctr],
                          Decimal.Round(values[ctr], decimals[ctr]));
    }
}
// The example displays the following output:
//                   Argument  Digits                    Result
//                   --------  ------                    ------
//                       1.45       1                       1.4
//                       1.55       1                       1.6
//                 123.456789       4                  123.4568
//                 123.456789       6                123.456789
//                 123.456789       8                123.456789
//                   -123.456       0                      -123
//               -123.0000000       3                  -123.000
//               -123.0000000      11              -123.0000000
//     -9999999999.9999999999       9    -10000000000.000000000
//     -9999999999.9999999999      10    -9999999999.9999999999
Public Module Example
   Public Sub Main()
      ' Define a set of Decimal values.
      Dim values() As Decimal = { 1.45d, 1.55d, 123.456789d, 123.456789d, 
                                  123.456789d, -123.456d, 
                                  New Decimal(1230000000, 0, 0, true, 7 ),
                                  New Decimal(1230000000, 0, 0, true, 7 ), 
                                  -9999999999.9999999999d, 
                                  -9999999999.9999999999d }
      ' Define a set of integers to for decimals argument.
      Dim decimals() As Integer = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10}
      
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "Argument", "Digits", "Result" )
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "--------", "------", "------" )
      For ctr As Integer = 0 To values.Length - 1
        Console.WriteLine("{0,26}{1,8}{2,26}", 
                          values(ctr), decimals(ctr), 
                          Decimal.Round(values(ctr), decimals(ctr)))
      Next
   End Sub
End Module
' The example displays the following output:
'                   Argument  Digits                    Result
'                   --------  ------                    ------
'                       1.45       1                       1.4
'                       1.55       1                       1.6
'                 123.456789       4                  123.4568
'                 123.456789       6                123.456789
'                 123.456789       8                123.456789
'                   -123.456       0                      -123
'               -123.0000000       3                  -123.000
'               -123.0000000      11              -123.0000000
'     -9999999999.9999999999       9    -10000000000.000000000
'     -9999999999.9999999999      10    -9999999999.9999999999

Uwagi

Ta metoda jest równoważna wywołaniu Round(Decimal, Int32, MidpointRounding) metody z mode argumentem MidpointRounding.ToEven . Gdy d jest dokładnie połowa między dwoma wartościami zaokrąglonymi, wynik jest wartością zaokrągloną, która ma parzystą cyfrę w prawej pozycji dziesiętnej.This method is equivalent to calling the Round(Decimal, Int32, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.When d is exactly halfway between two rounded values, the result is the rounded value that has an even digit in the far right decimal position. Na przykład po zaokrągleniu do dwóch miejsc dziesiętnych wartość 2,345 jest 2,34, a wartość 2,355 to 2,36.For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. Ten proces jest znany jako Zaokrąglenie w kierunku parzystościlub zaokrąglenia przez Bank.This process is known as rounding toward even, or banker's rounding. Minimalizuje błędy zaokrąglania wynikające ze spójnego zaokrąglania wartości punktu środkowego w jednym kierunku.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

Zobacz też

Round(Decimal, MidpointRounding)

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej.Rounds a decimal value to the nearest integer. Parametr określa sposób zaokrąglania wartości, jeśli jest ona w połowie między dwiema innymi liczbami.A parameter specifies how to round the value if it is midway between two other numbers.

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 do zaokrąglenia.A decimal number to round.

mode
MidpointRounding

Wartość, która określa, jak zaokrąglić, d Jeśli jest w połowie między dwiema innymi liczbami.A value that specifies how to round d if it is midway between two other numbers.

Zwraca

Decimal

Liczba całkowita znajdująca się najbliżej d parametru.The integer that is nearest to the d parameter. Jeśli d wartość jest w połowie między dwoma liczbami, a jedna z nich jest parzysta, a druga nieparzysta, mode parametr określa, które z dwóch liczb są zwracane.If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned.

Wyjątki

mode nie jest MidpointRounding wartością.mode is not a MidpointRounding value.

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

Przykłady

Poniższy przykład wyświetla wartości zwracane przez Round(Decimal) metodę, Round(Decimal, MidpointRounding) metodę z mode argumentem ToEven i Round(Decimal, MidpointRounding) metodę z mode argumentem 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

Uwagi

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 7,5 jest wartością punktu środkowego, jeśli ma zostać zaokrąglona do liczby całkowitej.For example, 7.5 is a midpoint value if it is to be rounded to an integer. W przypadku wartości punktu środkowego Najbliższa wartość nie może być łatwo zidentyfikowana bez konwencji zaokrąglania, która jest określona przez mode argument.For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. RoundMetoda 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ąglanie od zera.Rounding 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,5 zaokrągla do 4, 4,5 zaokrągla do 5,-3,5 zaokrągla do-4, a-4,5 zaokrągla do-5.For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. Ta forma zaokrąglania jest reprezentowana przez MidpointRounding.AwayFromZero element członkowski wyliczenia.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ąglanie do parzystego lub zaokrągleń w bankuRounding to even, 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,5, jak i 4,5, do 4 i oba-3,5 i-4,5, do-4.For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. Ta forma zaokrąglania jest reprezentowana przez MidpointRounding.ToEven element członkowski wyliczenia.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.

Zobacz też

Round(Decimal, Int32, MidpointRounding)

Zaokrągla wartość dziesiętną do określonej precyzji.Rounds a decimal value to a specified precision. Parametr określa sposób zaokrąglania wartości, jeśli jest ona w połowie między dwiema innymi liczbami.A parameter specifies how to round the value if it is midway between two other numbers.

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 do zaokrąglenia.A decimal number to round.

decimals
Int32

Liczba znaczących miejsc dziesiętnych (precyzja) w zwracanej wartości.The number of significant decimal places (precision) in the return value.

mode
MidpointRounding

Wartość, która określa, jak zaokrąglić, d Jeśli jest w połowie między dwiema innymi liczbami.A value that specifies how to round d if it is midway between two other numbers.

Zwraca

Decimal

Liczba znajdująca się najbliżej d parametru z dokładnością równą decimals parametrowi.The number that is nearest to the d parameter with a precision equal to the decimals parameter. Jeśli d wartość jest w połowie między dwoma liczbami, a jedna z nich jest parzysta, a druga nieparzysta, mode parametr określa, które z dwóch liczb są zwracane.If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned. Jeśli dokładność d jest mniejsza niż decimals , d jest zwracana bez zmian.If the precision of d is less 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 MidpointRounding wartością.mode is not a MidpointRounding value.

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

Przykłady

Poniższy przykład ilustruje sposób użycia Round(Decimal, Int32, MidpointRounding) metody z MidpointRounding wyliczeniem.The following example demonstrates how to use the Round(Decimal, Int32, MidpointRounding) 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 positiveValue = 3.45m;
decimal negativeValue = -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(positiveValue, 1);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1)");
result = Math.Round(negativeValue, 1);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1)");
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(positiveValue, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1, MidpointRounding.ToEven)");
result = Math.Round(positiveValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1, MidpointRounding.AwayFromZero)");
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(negativeValue, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1, MidpointRounding.ToEven)");
result = Math.Round(negativeValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1, MidpointRounding.AwayFromZero)");
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)
'

Uwagi

decimalsParametr określa liczbę znaczących miejsc dziesiętnych w wartości zwracanej oraz zakres od 0 do 28.The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. Jeśli decimals jest równa zero, zwracana jest liczba całkowita.If decimals is zero, an integer is returned.

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, która jest określona przez mode argument.In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Round(Decimal, Int32, MidpointRounding)Metoda obsługuje dwie konwencje zaokrągleń do obsługi wartości punktu środkowego.The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Zaokrąglanie od zera.Rounding 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 MidpointRounding.AwayFromZero element członkowski wyliczenia.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ąglanie do parzystego lub zaokrągleń w bankuRounding to even, 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 MidpointRounding.ToEven element członkowski wyliczenia.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.

Zobacz też

Dotyczy