Decimal.Round Decimal.Round Decimal.Round Decimal.Round Method

Definizione

Arrotonda un valore all'intero più vicino o al numero specificato di posizioni decimali.Rounds a value to the nearest integer or specified number of decimal places.

Overload

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Arrotonda un valore decimale all'intero più vicino.Rounds a decimal value to the nearest integer.

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Arrotonda un valore Decimal al numero di cifre decimali specificato.Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Arrotonda un valore decimale all'intero più vicino.Rounds a decimal value to the nearest integer. Un parametro specifica come arrotondare il valore se si trova a metà tra due numeri.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Arrotonda un valore decimale a una precisione specificata.Rounds a decimal value to a specified precision. Un parametro specifica come arrotondare il valore se si trova a metà tra due numeri.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal)

Arrotonda un valore decimale all'intero più vicino.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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to round.

Restituisce

Intero più vicino al parametro d.The integer that is nearest to the d parameter. Se d è contenuto tra due interi, di cui per definizione uno è pari e l'altro dispari, verrà restituito il numero pari.If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

Eccezioni

Il risultato non è compreso nell'intervallo di un valore Decimal.The result is outside the range of a Decimal value.

Esempi

Nell'esempio seguente un intervallo di Decimal valori compreso tra 100 e 102 viene arrotondato al numero intero più vicino.The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Poiché il metodo usa l'arrotondamento del Banker, si noti che 100,5 arrotonda a 100 e 101,5 arrotonda a 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

Commenti

Il comportamento di questo metodo segue lo standard IEEE 754, sezione 4.The behavior of this method follows IEEE Standard 754, section 4. Questo tipo di arrotondamento viene talvolta denominato arrotondamento metà a pari o arrotondamento del banco.This kind of rounding is sometimes called round half to even or banker's rounding. Riduce al minimo gli errori di arrotondamento risultanti dall'arrotondamento coerente di un valore medio in un'unica direzione.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. Equivale a chiamare il Round(Decimal, MidpointRounding) metodo con un mode argomento di MidpointRounding.ToEven.It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

Vedi anche

Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32)

Arrotonda un valore Decimal al numero di cifre decimali specificato.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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to round.

decimals
Int32 Int32 Int32 Int32

Valore compreso tra 0 e 28 che specifica il numero di posizioni decimali a cui arrotondare.A value from 0 to 28 that specifies the number of decimal places to round to.

Restituisce

Numero decimale equivalente a d arrotondato al numero decimals di posizioni decimali.The decimal number equivalent to d rounded to decimals number of decimal places.

Eccezioni

decimals non è un valore compreso tra 0 e 28.decimals is not a value from 0 to 28.

Esempi

Nell'esempio seguente vengono arrotondati diversi Decimal valori a un numero specificato di posizioni decimali utilizzando il Round metodo.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

Commenti

Questo metodo equivale a chiamare il Round(Decimal, Int32, MidpointRounding) metodo con un mode argomento di MidpointRounding.ToEven. Quando d è esattamente a metà tra due valori arrotondati, il risultato è il valore arrotondato con una cifra pari nella posizione decimale estrema destra.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. Se arrotondato a due numeri decimali, ad esempio, il valore 2,345 diventa 2,34 e il valore 2,355 diventa 2,36.For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. Questo processo è noto come arrotondamentoper eccesso o per l' arrotondamento dei banchieri.This process is known as rounding toward even, or banker's rounding. Riduce al minimo gli errori di arrotondamento risultanti dall'arrotondamento coerente di un valore medio in un'unica direzione.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

Vedi anche

Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding)

Arrotonda un valore decimale all'intero più vicino.Rounds a decimal value to the nearest integer. Un parametro specifica come arrotondare il valore se si trova a metà tra due numeri.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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to round.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Valore che specifica come arrotondare d se si trova a metà tra due numeri.A value that specifies how to round d if it is midway between two other numbers.

Restituisce

Intero più vicino al parametro d.The integer that is nearest to the d parameter. Se d è a metà tra due numeri interi, di cui per definizione uno è pari e l'altro dispari, il parametro mode determina quale dei due numeri deve essere restituito.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.

Eccezioni

Il risultato non è compreso nell'intervallo di un oggetto Decimal.The result is outside the range of a Decimal object.

Esempi

Nell'esempio seguente vengono visualizzati i valori restituiti Round(Decimal) dal metodo, Round(Decimal, MidpointRounding) il metodo con mode un argomento ToEvendi e il Round(Decimal, MidpointRounding) metodo con un mode argomento di 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.0       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.0       13         13         13

Commenti

In un valore medio, il valore dopo la cifra meno significativa nel risultato è esattamente a metà tra due numeri.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Ad esempio, 7,5 è un valore medio se deve essere arrotondato a un numero intero.For example, 7.5 is a midpoint value if it is to be rounded to an integer. Per i valori intermedi, il valore più vicino non può essere facilmente identificato senza una convenzione di arrotondamento, specificata mode dall'argomento.For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Il Round metodo supporta due convenzioni di arrotondamento per la gestione dei valori intermedi.The Round method supports two rounding conventions for handling midpoint values.

Arrotondamento a zero.Rounding away from zero.
I valori intermedi vengono arrotondati al numero successivo a partire da zero.Midpoint values are rounded to the next number away from zero. 3,5, ad esempio, viene arrotondato a 4, 4,5 viene arrotondato a 5,-3,5 viene arrotondato a-4 e-4,5 viene arrotondato a-5.For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. Questa forma di arrotondamento è rappresentata dal MidpointRounding.AwayFromZero membro di enumerazione.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

L'arrotondamento da zero è il tipo di arrotondamento più noto.Rounding away from zero is the most widely known form of rounding.

Arrotondamento a even o arrotondamento del bancoRounding to even, or banker's rounding
I valori intermedi vengono arrotondati al numero pari più vicino.Midpoint values are rounded to the nearest even number. Ad esempio, 3,5 e 4,5 arrotondano a 4 e entrambi-3,5 e-4,5 arrotondati a-4.For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. Questa forma di arrotondamento è rappresentata dal MidpointRounding.ToEven membro di enumerazione.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

L'arrotondamento al più vicino è il tipo di arrotondamento standard utilizzato nelle operazioni finanziarie e statistiche.Rounding to nearest is the standard form of rounding used in financial and statistical operations. È conforme allo standard IEEE 754, sezione 4.It conforms to IEEE Standard 754, section 4. Quando viene usato in più operazioni di arrotondamento, viene ridotto l'errore di arrotondamento causato da un arrotondamento uniforme di valori intermedi in un'unica direzione.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. In alcuni casi, questo errore di arrotondamento può essere significativo.In some cases, this rounding error can be significant.

Vedi anche

Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding)

Arrotonda un valore decimale a una precisione specificata.Rounds a decimal value to a specified precision. Un parametro specifica come arrotondare il valore se si trova a metà tra due numeri.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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to round.

decimals
Int32 Int32 Int32 Int32

Numero di posizioni decimali significative (precisione) nel valore restituito.The number of significant decimal places (precision) in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Valore che specifica come arrotondare d se si trova a metà tra due numeri.A value that specifies how to round d if it is midway between two other numbers.

Restituisce

Numero più vicino al parametro d con una precisione pari al parametro decimals.The number that is nearest to the d parameter with a precision equal to the decimals parameter. Se d è a metà tra due numeri interi, di cui per definizione uno è pari e l'altro dispari, il parametro mode determina quale dei due numeri deve essere restituito.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. Se la precisione di d è minore di decimals, d verrà restituito invariato.If the precision of d is less than decimals, d is returned unchanged.

Eccezioni

decimals è minore di 0 o maggiore di 28.decimals is less than 0 or greater than 28.

Il risultato non è compreso nell'intervallo di un oggetto Decimal.The result is outside the range of a Decimal object.

Esempi

Nell'esempio seguente viene illustrato come utilizzare il Round(Decimal, Int32, MidpointRounding) metodo con l' MidpointRounding enumerazione.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 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)
'

Commenti

Il decimals parametro specifica il numero di posizioni decimali significative nel valore restituito e viene compreso tra 0 e 28.The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. Se decimals è zero, viene restituito un valore integer.If decimals is zero, an integer is returned.

In un valore medio, il valore dopo la cifra meno significativa nel risultato è esattamente a metà tra due numeri.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Ad esempio, 3,47500 è un valore medio se è necessario arrotondare due posizioni decimali e 7,500 è un valore medio se deve essere arrotondato a un numero intero.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. In questi casi, il valore più vicino non può essere facilmente identificato senza una convenzione di arrotondamento, specificata dall' mode argomento.In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Il Round(Decimal, Int32, MidpointRounding) metodo supporta due convenzioni di arrotondamento per la gestione dei valori intermedi.The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Arrotondamento a zero.Rounding away from zero.
I valori intermedi vengono arrotondati al numero successivo a partire da zero.Midpoint values are rounded to the next number away from zero. 3,75, ad esempio, viene arrotondato a 3,8, 3,85 arrotondato a 3,9,-3,75 viene arrotondato a-3,8 e-3,85 viene arrotondato a-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. Questa forma di arrotondamento è rappresentata dal MidpointRounding.AwayFromZero membro di enumerazione.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

L'arrotondamento da zero è il tipo di arrotondamento più noto.Rounding away from zero is the most widely known form of rounding.

Arrotondamento a even o arrotondamento del bancoRounding to even, or banker's rounding
I valori intermedi vengono arrotondati al numero pari più vicino.Midpoint values are rounded to the nearest even number. Ad esempio, sia 3,75 che 3,85 round a 3,8 e both-3,75 e-3,85 round a-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. Questa forma di arrotondamento è rappresentata dal MidpointRounding.ToEven membro di enumerazione.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

L'arrotondamento al più vicino è il tipo di arrotondamento standard utilizzato nelle operazioni finanziarie e statistiche.Rounding to nearest is the standard form of rounding used in financial and statistical operations. È conforme allo standard IEEE 754, sezione 4.It conforms to IEEE Standard 754, section 4. Quando viene usato in più operazioni di arrotondamento, viene ridotto l'errore di arrotondamento causato da un arrotondamento uniforme di valori intermedi in un'unica direzione.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. In alcuni casi, questo errore di arrotondamento può essere significativo.In some cases, this rounding error can be significant.

Vedi anche

Si applica a