Decimal.Round Método

Definición

Espacio de nombres:
System
Ensamblados:
netstandard.dll, System.Runtime.dll
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Redondea un valor al entero más cercano o al número especificado de posiciones decimales.

Sobrecargas

Nombre Description
Round(Decimal, Int32, MidpointRounding)

Redondea un valor decimal a la precisión especificada mediante la estrategia de redondeo especificada.
Round(Decimal, MidpointRounding)

Redondea un valor decimal a un entero mediante la estrategia de redondeo especificada.
Round(Decimal)

Redondea un valor decimal al entero más cercano.
Round(Decimal, Int32)

Redondea un Decimal valor a un número especificado de posiciones decimales.

Round(Decimal, Int32, MidpointRounding)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

Redondea un valor decimal a la precisión especificada mediante la estrategia de redondeo especificada.

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

Parámetros

d
Decimal

Número decimal que se va a redondear.

decimals
Int32

Número de posiciones decimales significativas (precisión) en el valor devuelto.

mode
MidpointRounding

Uno de los valores de enumeración que especifica la estrategia de redondeo que se va a usar.

Devoluciones

Decimal

Número redondeado d al uso de la mode estrategia de redondeo y con una precisión de decimals. Si la precisión de es menor que ddecimals, d se devuelve sin cambios.

Implementaciones

Round(TSelf, Int32, MidpointRounding)

Excepciones

ArgumentOutOfRangeException

decimals es menor que 0 o mayor que 28.

ArgumentException

mode no es un MidpointRounding valor.

OverflowException

El resultado está fuera del intervalo de un Decimal objeto .

Ejemplos

En el ejemplo siguiente se muestra cómo usar el Round(Decimal, Int32, MidpointRounding) método con la MidpointRounding enumeración .

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)
'

Comentarios

El decimals parámetro especifica el número de posiciones decimales significativas en el valor devuelto y oscila entre 0 y 28. Si decimals es cero, se devuelve un entero.

Si especifica ToEven o AwayFromZero para el mode parámetro , esas estrategias de redondeo solo se aplican para los valores de punto medio, es decir, los valores cuyo dígito menos significativo es 5.

Consulte también

Se aplica a

Round(Decimal, MidpointRounding)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

Redondea un valor decimal a un entero mediante la estrategia de redondeo especificada.

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

Parámetros

d
Decimal

Número decimal que se va a redondear.

mode
MidpointRounding

Uno de los valores de enumeración que especifica la estrategia de redondeo que se va a usar.

Devoluciones

Decimal

Entero que d se redondea para usar la mode estrategia de redondeo.

Implementaciones

Round(TSelf, MidpointRounding)

Excepciones

ArgumentException

mode no es un MidpointRounding valor.

OverflowException

El resultado está fuera del intervalo de un Decimal objeto .

Ejemplos

En el ejemplo siguiente se muestran los valores devueltos por el Round(Decimal, MidpointRounding) método con distintos mode argumentos.

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

Comentarios

Si especifica ToEven o AwayFromZero para el mode parámetro , esas estrategias de redondeo solo se aplican para los valores de punto medio, es decir, los valores cuyo dígito menos significativo es 5.

Consulte también

Se aplica a

Round(Decimal)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

Redondea un valor decimal al entero más cercano.

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

Parámetros

d
Decimal

Número decimal que se va a redondear.

Devoluciones

Decimal

Entero más cercano al d parámetro . Si d está a mitad de camino entre dos enteros, uno de los cuales es par y el otro impar, se devuelve el número par.

Implementaciones

Round(TSelf)

Excepciones

OverflowException

El resultado está fuera del intervalo de un Decimal valor.

Ejemplos

En el ejemplo siguiente se redondea un intervalo de Decimal valores entre 100 y 102 al entero más cercano. Dado que el método usa el redondeo bancario, 100,5 rondas a 100 y 101,5 rondas a 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

Comentarios

El comportamiento de este método sigue el estándar IEEE 754, sección 4. A veces, este tipo de redondeo se denomina redondeo a la mitad o al redondeo bancario. Minimiza los errores de redondeo que se producen al redondear de forma coherente un valor de punto medio en una sola dirección. Equivale a llamar al Round(Decimal, MidpointRounding) método con un mode argumento de MidpointRounding.ToEven.

Consulte también

Se aplica a

Round(Decimal, Int32)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

Redondea un Decimal valor a un número especificado de posiciones decimales.

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

Parámetros

d
Decimal

Número decimal que se va a redondear.

decimals
Int32

Valor de 0 a 28 que especifica el número de posiciones decimales a las que redondear.

Devoluciones

Decimal

Número decimal equivalente a d posiciones decimales redondeadas decimals .

Implementaciones

Round(TSelf, Int32)

Excepciones

ArgumentOutOfRangeException

decimals no es un valor de 0 a 28.

Ejemplos

En el ejemplo siguiente se redondea varios Decimal valores a un número especificado de posiciones decimales mediante el Round método .

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

Comentarios

Este método es equivalente a llamar al Round(Decimal, Int32, MidpointRounding) método con un mode argumento de MidpointRounding.ToEven. Cuando d está exactamente a mitad de camino entre dos valores redondeados, el resultado es el valor redondeado que tiene un dígito par en la posición decimal derecha. Por ejemplo, cuando se redondea a dos decimales, el valor 2,345 se convierte en 2,34 y el valor 2,355 se convierte en 2,36. Este proceso se conoce como redondeo hacia incluso, o el redondeo bancario. Minimiza los errores de redondeo que se producen al redondear de forma coherente un valor de punto medio en una sola dirección.

Consulte también

Se aplica a