Język

Decimal.Round Metoda

Definicja

Przestrzeń nazw:
System
Zestawy:
netstandard.dll, System.Runtime.dll
Zestaw:
System.Runtime.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Zaokrągla wartość do najbliższej liczby całkowitej lub określonej liczby miejsc dziesiętnych.

Przeciążenia

Nazwa Opis
Round(Decimal, Int32, MidpointRounding)

Zaokrągla wartość dziesiętną do określonej dokładności przy użyciu określonej strategii zaokrąglania.
Round(Decimal, MidpointRounding)

Zaokrągla wartość dziesiętną do liczby całkowitej przy użyciu określonej strategii zaokrąglania.
Round(Decimal, Int32)

Zaokrągla Decimal wartość do określonej liczby miejsc dziesiętnych.
Round(Decimal)

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej.

Round(Decimal, Int32, MidpointRounding)

Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs

Zaokrągla wartość dziesiętną do określonej dokładności przy użyciu określonej strategii zaokrąglania.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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ąglenie.

decimals
Int32

Liczba znaczących miejsc dziesiętnych (precyzja) w wartości zwracanej.

mode
MidpointRounding

Jedna z wartości wyliczenia określająca, która strategia zaokrąglania ma być używana.

Zwraca

Decimal

Liczba zaokrąglona d do użycia mode strategii zaokrąglania i z dokładnością do decimals. Jeśli precyzja parametru d jest mniejsza niż decimals, d jest zwracana bez zmian.

Implementuje

Round(TSelf, Int32, MidpointRounding)

Wyjątki

ArgumentOutOfRangeException

decimals wartość jest mniejsza niż 0 lub większa niż 28.

ArgumentException

mode nie jest wartością MidpointRounding .

OverflowException

Wynik znajduje się poza zakresem Decimal obiektu.

Przykłady

W poniższym przykładzie pokazano, jak używać Round(Decimal, Int32, MidpointRounding) metody z wyliczeniem MidpointRounding .

decimal result;

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(-3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n");

/*
This code example produces the following results:

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

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(-3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n"

// This code example produces the following results:

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

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

Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' Round a positive value using different strategies.
' 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)
result = Math.Round(posValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, posValue)
Console.WriteLine()

' Round a negative value using different strategies.
' 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)
result = Math.Round(negValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:
'
'        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.ToZero)
'
'        -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.ToZero)
'

Uwagi

Parametr decimals określa liczbę znaczących miejsc dziesiętnych w wartości zwracanej i zakresy od 0 do 28. Jeśli decimals ma wartość zero, zwracana jest liczba całkowita.

Jeśli określisz ToEven parametr lub AwayFromZero dla parametru mode , te strategie zaokrąglania są stosowane tylko dla wartości punktu środkowego, czyli wartości, których najmniej znacząca cyfra to 5.

Zobacz też

Dotyczy

Round(Decimal, MidpointRounding)

Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs

Zaokrągla wartość dziesiętną do liczby całkowitej przy użyciu określonej strategii zaokrąglania.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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ąglenie.

mode
MidpointRounding

Jedna z wartości wyliczenia określająca, która strategia zaokrąglania ma być używana.

Zwraca

Decimal

Liczba całkowita zaokrąglona d do użycia mode strategii zaokrąglania.

Implementuje

Round(TSelf, MidpointRounding)

Wyjątki

ArgumentException

mode nie jest wartością MidpointRounding .

OverflowException

Wynik znajduje się poza zakresem Decimal obiektu.

Przykłady

Poniższy przykład przedstawia wartości zwracane przez metodę Round(Decimal, MidpointRounding) z różnymi mode argumentami.

Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
    Console.WriteLine($"{value,-10} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13.0       13         13         13               13

Uwagi

Jeśli określisz ToEven parametr lub AwayFromZero dla parametru mode , te strategie zaokrąglania są stosowane tylko dla wartości punktu środkowego, czyli wartości, których najmniej znacząca cyfra to 5.

Zobacz też

Dotyczy

Round(Decimal, Int32)

Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs

Zaokrągla Decimal wartość do określonej liczby miejsc dziesiętnych.

public:
 static System::Decimal Round(System::Decimal d, int decimals) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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ąglenie.

decimals
Int32

Wartość z zakresu od 0 do 28, która określa liczbę miejsc dziesiętnych do zaokrąglenia do.

Zwraca

Decimal

Liczba dziesiętna równoważna d zaokrągleniu do decimals miejsc dziesiętnych.

Implementuje

Round(TSelf, Int32)

Wyjątki

ArgumentOutOfRangeException

decimals nie jest wartością z zakresu od 0 do 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 .

using System;

class Example12
{
   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

open System

// Define a set of Decimal values.
let values = 
    [ 1.45m; 1.55m; 123.456789m; 123.456789m
      123.456789m; -123.456m
      Decimal(1230000000, 0, 0, true, 7uy)
      Decimal(1230000000, 0, 0, true, 7uy)
      -9999999999.9999999999m
      -9999999999.9999999999m ]

// Define a set of integers to for decimals argument.
let decimals = 
    [ 1; 1; 4; 6; 8; 0; 3; 11; 9; 10 ]

printfn $"""{"Argument",26}{"Digits",8}{"Result",26}"""
printfn $"""{"--------",26}{"------",8}{"------",26}"""

for i = 0 to values.Length - 1 do
    printfn $"{values[i],26}{decimals[i],8}{Decimal.Round(values[i], decimals[i]),26}"

// 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 Example12
    Public Sub Run()
        ' 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 argumentem modeMidpointRounding.ToEven. Gdy d jest dokładnie w połowie między dwiema zaokrąglonymi wartościami, wynik jest zaokrągloną wartością, która ma parzystą cyfrę w prawej pozycji dziesiętnej. Na przykład po zaokrągleniu do dwóch dziesiętnych wartość 2,345 staje się 2,344, a wartość 2,355 staje się 2,36. Ten proces jest znany jako zaokrąglanie w kierunku równomiernego lub zaokrąglania bankiera. Minimalizuje błędy zaokrąglania, które wynikają z spójnego zaokrąglania wartości punktu środkowego w jednym kierunku.

Zobacz też

Dotyczy

Round(Decimal)

Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs
Źródło:
Decimal.cs

Zaokrągla wartość dziesiętną do najbliższej liczby całkowitej.

public:
 static System::Decimal Round(System::Decimal d) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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ąglenie.

Zwraca

Decimal

Liczba całkowita najbliższa parametrowi d . Jeśli d jest w połowie między dwiema liczbami całkowitymi, z których jedna jest parzysta, a drugą nieparzystą, zwracana jest liczba parzysta.

Implementuje

Round(TSelf)

Wyjątki

OverflowException

Wynik znajduje się poza zakresem Decimal wartości.

Przykłady

Poniższy przykład zaokrągla zakres Decimal wartości z zakresu od 100 do 102 do najbliższej liczby całkowitej. Ponieważ metoda używa zaokrąglania bankiera, 100,5 rund do 100 i 101,5 rund do 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

open System

for value in 100m .. 0.1m .. 102m do
    printfn $"{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 Run()
        For value As Decimal = 100D To 102D Step 0.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 Standard 754, sekcja 4. Tego rodzaju zaokrąglanie jest czasami nazywane zaokrąglaną połową do nawet lub zaokrąglenia bankiera. Minimalizuje błędy zaokrąglania, które wynikają z spójnego zaokrąglania wartości punktu środkowego w jednym kierunku. Jest to równoważne wywołaniu Round(Decimal, MidpointRounding) metody z argumentem modeMidpointRounding.ToEven.

Zobacz też

Dotyczy