Math.Round Math.Round Math.Round Math.Round Method

Definizione

Arrotonda un valore all'intero più vicino o al numero specificato di cifre frazionarie.Rounds a value to the nearest integer or to the specified number of fractional digits.

Overload

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

Arrotonda un valore decimale del numero di cifre frazionarie specificato e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

Arrotonda un valore a virgola mobile e precisione doppia del numero di cifre frazionarie specificato e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

Arrotonda un valore a virgola mobile e precisione doppia all'intero più vicino e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

Arrotonda un valore a virgola mobile e precisione doppia del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Double) Round(Double) Round(Double) Round(Double)

Arrotonda un valore a virgola mobile e precisione doppia al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Arrotonda un valore decimale del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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

Arrotonda un valore decimale al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Arrotonda un valore decimale all'intero più vicino e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

Esempi

Oltre agli esempi nella sezione osservazioni , questo articolo include esempi che illustrano gli overload seguenti del Math.Round metodo:In addition to the examples in the Remarks section, this article includes examples that illustrate the following overloads of the Math.Round method:

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

Nota

Gli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.Select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Commenti

Contenuto della sezione:In this section:

Quale metodo viene chiamato?Which method do I call?

È possibile utilizzare la tabella seguente per selezionare un metodo di arrotondamento appropriato.You can use the following table to select an appropriate rounding method. Oltre ai Math.Round metodi, include Math.Ceiling anche e Math.Floor.In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

ATo CallCall
Arrotondare un numero a un Integer utilizzando l'arrotondamento alla convenzione più vicina.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

-oppure--or-

Round(Double)
Arrotondare un numero a un Integer utilizzando una convenzione di arrotondamento specificata.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

-oppure--or-

Round(Double, MidpointRounding)
Arrotondare un numero a un numero specificato di cifre frazionarie utilizzando l'arrotondamento alla convenzione più vicina.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

-oppure--or-

Round(Double, Int32)
Arrotondare un numero a un numero specificato di cifre frazionarie utilizzando una convenzione di arrotondamento specificata.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

-oppure--or-

Round(Double, Int32, MidpointRounding)
Arrotondare Single un valore a un numero specificato di cifre frazionarie utilizzando una convenzione di arrotondamento specificata e riducendo al minimo la perdita di precisione.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Convertire l' Single oggetto in Decimal un oggetto Round(Decimal, Int32, MidpointRounding)e chiamare.Convert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
Arrotondare un numero a un numero specificato di cifre frazionarie riducendo al minimo i problemi di precisione nei valori intermedi di arrotondamento.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. Chiamare un metodo di arrotondamento che implementi un confronto "maggiore o uguale a".Call a rounding method that implements a "greater than or approximately equal to" comparison. Vedere arrotondamento e precisione.See Rounding and precision.
Arrotondare un valore frazionario a un intero maggiore del valore frazionario.Round a fractional value to an integer that is greater than the fractional value. Ad esempio, arrotondare 3,1 a 4.For example, round 3.1 to 4. Ceiling
Arrotondare un valore frazionario a un numero intero minore del valore frazionario.Round a fractional value to an integer that is less than the fractional value. Ad esempio, arrotondare 3,9 a 3.For example, round 3.9 to 3. Floor

Valori intermedi e convenzioni di arrotondamentoMidpoint values and rounding conventions

L'arrotondamento comporta la conversione di un valore numerico con una precisione specificata nel valore più vicino con una precisione minore.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. Ad esempio, è possibile usare il Round(Double) metodo per arrotondare un valore 3,4 a 3,0 e il Round(Double, Int32) metodo per arrotondare un valore di 3,579 a 3,58.For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.

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.In these cases, the nearest value can't be easily identified without a rounding convention.

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 zeroRounding 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 al più vicino o arrotondamento del bancoRounding to nearest, 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.

    Nell'esempio seguente viene illustrata la distorsione che può derivare dall'arrotondamento uniforme di valori intermedi in un'unica direzione.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. Nell'esempio viene calcolata la media reale di una matrice Decimal di valori, quindi viene calcolata la media quando i valori nella matrice vengono arrotondati utilizzando le due convenzioni.The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. In questo esempio, la media vera e la media risultante dall'arrotondamento al più vicino sono uguali.In this example, the true mean and the mean that results when rounding to nearest are the same. Tuttavia, la media risultante dall'arrotondamento da zero è diversa da 0,05 (o dal 3,6%) dal valore true.However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.

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

Per impostazione predefinita, Round il metodo usa l'arrotondamento alla convenzione più vicina.By default, the Round method uses the rounding to nearest convention. Nella tabella seguente sono elencati gli overload del Round metodo e la convenzione di arrotondamento utilizzata da ciascuno di essi.The following table lists the overloads of the Round method and the rounding convention that each uses.

OverloadOverload Convenzione di arrotondamentoRounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Determinato dal mode parametro.Determined by mode parameter.
Round(Double, MidpointRounding) Determinato dal mode parametroDetermined by mode parameter
Round(Decimal, Int32, MidpointRounding) Determinato dal mode parametroDetermined by mode parameter
Round(Double, Int32, MidpointRounding) Determinato dal mode parametroDetermined by mode parameter

Arrotondamento e precisioneRounding and precision

Per determinare se un'operazione di arrotondamento prevede un valore medio, il Round metodo moltiplica il valore originale per essere arrotondato di 10n, dove n è il numero desiderato di cifre frazionarie nel valore restituito, quindi determina se la parte frazionaria rimanente del valore è maggiore o uguale a 5.In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. Si tratta di una lieve variazione di un test di uguaglianza e, come illustrato nella sezione "verifica dell'uguaglianza" dell'argomento Double di riferimento, i test di uguaglianza con i valori a virgola mobile sono problematici a causa dei problemi del formato a virgola mobile con Binary rappresentazione e precisione.This is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. Ciò significa che qualsiasi parte frazionaria di un numero leggermente inferiore a 0,5 (a causa di una perdita di precisione) non verrà arrotondata verso l'alto.This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

Nell'esempio che segue viene illustrato il problema.The following example illustrates the problem. Aggiunge ripetutamente 1 a 11,0 e arrotonda il risultato al numero intero più vicino.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Indipendentemente dalla convenzione di arrotondamento, 11,5 dovrebbe arrotondare a 12.Regardless of the rounding convention, 11.5 should round to 12. Tuttavia, come illustrato nell'output dell'esempio, non lo è.However, as the output from the example shows, it does not. Nell'esempio viene usata la stringa di formato numerico standard "R" per visualizzare la precisione completa del valore a virgola mobile e viene indicato che il valore da arrotondare ha perso la precisione durante le aggiunte ripetute e il suo valore è effettivamente 11.499999999999998.The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. Poiché. 499999999999998 è minore di 0,5, il valore non viene arrotondato al numero intero più alto successivo.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Come illustrato nell'esempio, questo problema non si verifica se si assegna semplicemente il valore costante 11,5 a una Double variabile.As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.

using System;

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

      Console.WriteLine();

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

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

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

È probabile che si verifichino problemi di precisione nei valori intermedi di arrotondamento nelle condizioni seguenti:Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

  • Quando un valore frazionario non può essere espresso esattamente nel formato binario del tipo a virgola mobile.When a fractional value cannot be expressed precisely in the floating-point type's binary format.

  • Quando il valore da arrotondare viene calcolato da una o più operazioni a virgola mobile.When the value to be rounded is calculated from one or more floating-point operations.

  • Quando il valore da arrotondare è un Single oggetto anziché un Double oggetto Decimalo.When the value to be rounded is a Single rather than a Double or Decimal. Per ulteriori informazioni, vedere la sezione successiva, arrotondamento e valori a virgola mobile a precisione singola.For more information, see the next section, Rounding and single-precision floating-point values.

Nei casi in cui la mancanza di precisione nelle operazioni di arrotondamento è problematica, è possibile eseguire le operazioni seguenti:In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • Se l'operazione Double di arrotondamento chiama un overload che arrotonda Double un valore, è possibile modificare in un Decimal valore e chiamare un overload che arrotonda un Decimal valore.If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. Sebbene il Decimal tipo di dati includa anche problemi di rappresentazione e perdita di precisione, questi problemi sono molto meno comuni.Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • Definire un algoritmo di arrotondamento personalizzato che esegua un test "quasi uguale" per determinare se il valore da arrotondare è accettabile vicino a un valore medio.Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. Nell'esempio seguente viene definito RoundApproximate un metodo che esamina se un valore frazionario è sufficientemente vicino a un valore medio per essere soggetto all'arrotondamento del punto medio.The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. Come illustrato nell'output dell'esempio, viene corretto il problema di arrotondamento illustrato nell'esempio precedente.As the output from the example shows, it corrects the rounding problem shown in the previous example.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                            "Value", "Full Precision", "ToEven",
                            "AwayFromZero");
          double value = 11.1;
          for (int ctr = 0; ctr <= 5; ctr++)    
             value = RoundValueAndAdd(value);
    
          Console.WriteLine();
    
          value = 11.5;
          RoundValueAndAdd(value);
       }
       
       private static double RoundValueAndAdd(double value)
       {
          const double tolerance = 8e-14;
    
          Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                            value, 
                            RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                            RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
          return value + .1;
       }
    
       private static double RoundApproximate(double dbl, int digits, double margin, 
                                         MidpointRounding mode)
       {                                      
          double fraction = dbl * Math.Pow(10, digits);
          double value = Math.Truncate(fraction); 
          fraction = fraction - value;   
          if (fraction == 0)
             return dbl;
          
          double tolerance = margin * dbl;
          // Determine whether this is a midpoint value.
          if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance)) {
             if (mode == MidpointRounding.AwayFromZero)
                return (value + 1)/Math.Pow(10, digits);
             else
                if (value % 2 != 0)
                   return (value + 1)/Math.Pow(10, digits);
                else
                   return value/Math.Pow(10, digits);
          }
          // Any remaining fractional value greater than .5 is not a midpoint value.
          if (fraction > .5)
             return (value + 1)/Math.Pow(10, digits);
          else
             return value/Math.Pow(10, digits);
       }
    }
    // The example displays the following output:
    //       Value       Full Precision        ToEven    AwayFromZero
    //       
    //        11.1                 11.1            11              11
    //        11.2                 11.2            11              11
    //        11.3   11.299999999999999            11              11
    //        11.4   11.399999999999999            11              11
    //        11.5   11.499999999999998            12              12
    //        11.6   11.599999999999998            12              12
    //       
    //        11.5                 11.5            12              12
    
    Module Example
       Public Sub Main()
          Dim value As Double = 11.1
    
          Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n", 
                            "Value", "Full Precision", "ToEven",
                            "AwayFromZero")
          For ctr As Integer = 0 To 5    
             value = RoundValueAndAdd(value)
          Next
          Console.WriteLine()
    
          value = 11.5
          RoundValueAndAdd(value)
       End Sub
       
       Private Function RoundValueAndAdd(value As Double) As Double
          Const tolerance As Double = 8e-14
          Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}", 
                            value, 
                            RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                            RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
          Return value + .1
       End Function   
    
       Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double, 
                                         mode As MidpointRounding) As Double
          Dim fraction As Double = dbl * Math.Pow(10, digits)
          Dim value As Double = Math.Truncate(fraction) 
          fraction = fraction - value   
          If fraction = 0 Then Return dbl
          
          Dim tolerance As Double = margin * dbl
          ' Determine whether this is a midpoint value.
          If (fraction >= .5 - tolerance) And (fraction <= .5 + tolerance) Then
             If mode = MidpointRounding.AwayFromZero Then
                Return (value + 1)/Math.Pow(10, digits)
             Else
                If value Mod 2 <> 0 Then
                   Return (value + 1)/Math.Pow(10, digits)
                Else
                   Return value/Math.Pow(10, digits)
                End If
             End If
          End If
          ' Any remaining fractional value greater than .5 is not a midpoint value.
          If fraction > .5 Then
             Return (value + 1)/Math.Pow(10, digits)
          Else
             return value/Math.Pow(10, digits)
          End If      
       End Function
    End Module
    ' The example displays the following output:
    '       Value       Full Precision        ToEven    AwayFromZero
    '       
    '        11.1                 11.1            11              11
    '        11.2                 11.2            11              11
    '        11.3   11.299999999999999            11              11
    '        11.4   11.399999999999999            11              11
    '        11.5   11.499999999999998            12              12
    '        11.6   11.599999999999998            12              12
    '       
    '        11.5                 11.5            12              12
    

Arrotondamento e valori a virgola mobile a precisione singolaRounding and single-precision floating-point values

Il Round metodo include gli overload che accettano argomenti di tipo Decimal e Double.The Round method includes overloads that accept arguments of type Decimal and Double. Non esistono metodi che arrotondano i valori di Singletipo.There are no methods that round values of type Single. Se si passa un Single valore a uno degli overload Round del metodo, viene eseguito il cast (in C#) o viene convertito (in Visual Basic) in un oggetto Doublee viene chiamato l'overload corrispondente Round con un Double parametro.If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. Sebbene si tratta di una conversione verso un tipo di carattere più ampio, spesso comporta una perdita di precisione, come illustrato nell'esempio seguente.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. Quando un Single valore di 16,325 viene passato Round al metodo e arrotondato a due posizioni decimali usando la convenzione di arrotondamento alla convenzione più vicina, il risultato è 16,33 e non il risultato previsto di 16,32.When a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.

using System;

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

Questo risultato imprevisto è dovuto a una perdita di precisione nella conversione del Single valore in un oggetto. DoubleThis unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Poiché il valore Double risultante di 16.325000762939453 non è un valore medio e è maggiore di 16,325, viene sempre arrotondato per eccesso.Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.

In molti casi, come illustrato nell'esempio, la perdita di precisione può essere ridotta o eliminata mediante il cast o la conversione Single del valore in Decimalun oggetto.In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. Si noti che, poiché si tratta di una conversione verso un tipo di contenuto più piccolo, è necessario usare un operatore cast o chiamare un metodo di conversione.Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.

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

Arrotonda un valore decimale del numero di cifre frazionarie specificato e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

Numero di posizioni decimali nel valore restituito.The number of decimal places in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Spiegazione della modalità di arrotondamento di d se si trova a metà tra due numeri.Specification for how to round d if it is midway between two other numbers.

Restituisce

Numero più vicino a d contenente un numero di cifre frazionarie pari a decimals.The number nearest to d that contains a number of fractional digits equal to decimals. Se d ha meno cifre frazionarie di decimals, d viene restituito invariato.If d has fewer fractional digits than decimals, d is returned unchanged.

Eccezioni

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

mode non è un valore valido di MidpointRounding.mode is not a valid value of MidpointRounding.

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

Commenti

Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

Il valore dell' decimals argomento può variare da 0 a 28.The value of the decimals argument can range from 0 to 28.

EsempioExample

Nell'esempio seguente viene illustrato come utilizzare il Round metodo con l' MidpointRounding enumerazione.The following example demonstrates how to use the Round method with the MidpointRounding enumeration.

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

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

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = Math::Round(posValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math::Round(negValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console::WriteLine();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(posValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, posValue);
    result = Math::Round(posValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, posValue);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(negValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, negValue);
    result = Math::Round(negValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, negValue);
    Console::WriteLine();
}

/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

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

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

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

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

result = Math.Round(posValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
result = Math.Round(negValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
Console.WriteLine();

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

result = Math.Round(posValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, posValue);
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, posValue);
Console.WriteLine();

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

result = Math.Round(negValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, negValue);
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, negValue);
Console.WriteLine();
/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

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

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

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, posValue)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, negValue)
        Console.WriteLine()
    
    End Sub
End Class
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'
Vedi anche

Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding) Round(Double, Int32, MidpointRounding)

Arrotonda un valore a virgola mobile e precisione doppia del numero di cifre frazionarie specificato e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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

Parametri

value
Double Double Double Double

Numero a virgola mobile e precisione doppia da arrotondare.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Numero di cifre frazionarie nel valore restituito.The number of fractional digits in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Spiegazione della modalità di arrotondamento di value se si trova a metà tra due numeri.Specification for how to round value if it is midway between two other numbers.

Restituisce

Numero più vicino a value contenente un numero di cifre frazionarie pari a digits.The number nearest to value that has a number of fractional digits equal to digits. Se value ha meno cifre frazionarie di digits, value viene restituito invariato.If value has fewer fractional digits than digits, value is returned unchanged.

Eccezioni

digits è minore di 0 o maggiore di 15.digits is less than 0 or greater than 15.

mode non è un valore valido di MidpointRounding.mode is not a valid value of MidpointRounding.

Commenti

Il valore dell' digits argomento può essere compreso tra 0 e 15.The value of the digits argument can range from 0 to 15. Si noti che 15 è il numero massimo di cifre integrali e frazionarie supportate dal Double tipo.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

Se il valore dell' value argomento è Double.NaN, il metodo restituisce Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Se value è Double.PositiveInfinity Double.NegativeInfinityo ,Double.NegativeInfinityilmetodo Double.PositiveInfinity restituisce rispettivamente o.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

EsempioExample

Nell'esempio seguente viene illustrato come utilizzare il Round(Double, Int32, MidpointRounding) metodo con l' MidpointRounding enumerazione.The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.

 double posValue =  3.45;
 double negValue = -3.45;

 // Round a positive and a negative value using the default. 
 double result = Math.Round(posValue, 1);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
 result = Math.Round(negValue, 1);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1)\n", result, negValue);

 // Round a positive value using a MidpointRounding value. 
 result = Math.Round(posValue, 1, MidpointRounding.ToEven);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                   result, posValue);
 result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)\n", 
                   result, posValue);

 // Round a negative value using a MidpointRounding value. 
 result = Math.Round(negValue, 1, MidpointRounding.ToEven);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                   result, negValue);
 result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
 Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)\n", 
                   result, negValue);
// The example displays the following output:
//        3.4 = Math.Round( 3.45, 1)
//       -3.4 = Math.Round(-3.45, 1)
//       
//        3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
//        3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
//       
//       -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
Module Example
    Public Sub Main() 
        Dim posValue As Double = 3.45
        Dim negValue As Double = -3.45
        
        ' Round a positive and a negative value using the default.  
        Dim result As Double = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value using a MidpointRounding value. 
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", 
                           result, posValue)
        Console.WriteLine()
        
        ' Round a positive value using a MidpointRounding value. 
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", 
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", 
                           result, negValue)
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'       3.4 = Math.Round( 3.45, 1)
'       -3.4 = Math.Round(-3.45, 1)
'       
'       3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
'       3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'       
'       -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

Note per i chiamanti

A causa della perdita di precisione che può derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o esecuzione di operazioni aritmetiche su valori Round(Double, Int32, MidpointRounding) a virgola mobile, in alcuni casi il metodo non può apparire come specificato nei valori del punto medio arrotondato mode dal parametro.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. Questo è illustrato nell'esempio seguente, in cui 2,135 viene arrotondato a 2,13 anziché 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Ciò si verifica perché il metodo viene moltiplicato value internamente per 10cifree l'operazione di moltiplicazione in questo caso subisce una perdita di precisione.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3][!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3]

Vedi anche

Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding) Round(Double, MidpointRounding)

Arrotonda un valore a virgola mobile e precisione doppia all'intero più vicino e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

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

Parametri

value
Double Double Double Double

Numero a virgola mobile e precisione doppia da arrotondare.A double-precision floating-point number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Spiegazione della modalità di arrotondamento di value se si trova a metà tra due numeri.Specification for how to round value if it is midway between two other numbers.

Restituisce

Il value più vicino all'intero.The integer nearest value. Se value è contenuto tra due interi, di cui per definizione uno è pari e l'altro dispari, mode determina quale dei due numeri deve essere restituito.If value is halfway between two integers, one of which is even and the other odd, then mode determines which of the two is returned. Si noti che questo metodo restituisce Double anziché un tipo integrale.Note that this method returns a Double instead of an integral type.

Eccezioni

mode non è un valore valido di MidpointRounding.mode is not a valid value of MidpointRounding.

Commenti

Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

Se il valore dell' value argomento è Double.NaN, il metodo restituisce Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Se value è Double.PositiveInfinity Double.NegativeInfinityo ,Double.NegativeInfinityilmetodo Double.PositiveInfinity restituisce rispettivamente o.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

EsempioExample

Nell'esempio seguente vengono visualizzati i valori restituiti Round(Double) dal metodo, Round(Double, MidpointRounding) il metodo con mode un argomento ToEvendi e il Round(Double, MidpointRounding) metodo con un mode argomento di AwayFromZero.The following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

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

Note per i chiamanti

A causa della perdita di precisione che può derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o esecuzione di operazioni aritmetiche su valori Round(Double, MidpointRounding) a virgola mobile, in alcuni casi il metodo non può sembrare i valori del punto medio arrotondati al numero intero pari più vicino.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, MidpointRounding) method may not appear to round midpoint values to the nearest even integer. Nell'esempio seguente, poiché il valore a virgola mobile 1 non ha una rappresentazione binaria finita, la prima chiamata Round(Double) al metodo con un valore di 11,5 restituisce 11 invece di 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4][!code-csharpSystem.Math.Round#4] [!code-vbSystem.Math.Round#4]

Vedi anche

Round(Double, Int32) Round(Double, Int32) Round(Double, Int32) Round(Double, Int32)

Arrotonda un valore a virgola mobile e precisione doppia del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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

Parametri

value
Double Double Double Double

Numero a virgola mobile e precisione doppia da arrotondare.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Numero di cifre frazionarie nel valore restituito.The number of fractional digits in the return value.

Restituisce

Numero più vicino a value contenente un numero di cifre frazionarie pari a digits.The number nearest to value that contains a number of fractional digits equal to digits.

Eccezioni

digits è minore di 0 o maggiore di 15.digits is less than 0 or greater than 15.

Commenti

Il valore dell' digits argomento può essere compreso tra 0 e 15.The value of the digits argument can range from 0 to 15. Si noti che 15 è il numero massimo di cifre integrali e frazionarie supportate dal Double tipo.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Questo metodo usa la convenzione di arrotondamento predefinita MidpointRounding.ToEvendi.This method uses the default rounding convention of MidpointRounding.ToEven. Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

Se il valore dell' value argomento è Double.NaN, il metodo restituisce Double.NaN.If the value of the value argument is Double.NaN, the method returns Double.NaN. Se value è Double.PositiveInfinity Double.NegativeInfinityo ,Double.NegativeInfinityilmetodo Double.PositiveInfinity restituisce rispettivamente o.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

EsempioExample

Nell'esempio seguente vengono arrotondati i valori Double con due cifre frazionarie a valori Double con una sola cifra frazionaria.The following example rounds double values with two fractional digits to doubles that have a single fractional digit.

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

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

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

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

Note per i chiamanti

A causa della perdita di precisione che può derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o esecuzione di operazioni aritmetiche su valori Round(Double, Int32) a virgola mobile, in alcuni casi il metodo non può sembrare i valori del punto medio arrotondati al valore pari più vicino nella digits posizione decimale.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32) method may not appear to round midpoint values to the nearest even value in the digits decimal position. Questo è illustrato nell'esempio seguente, in cui 2,135 viene arrotondato a 2,13 anziché 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Ciò si verifica perché il metodo viene moltiplicato value internamente per 10cifree l'operazione di moltiplicazione in questo caso subisce una perdita di precisione.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

[!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2][!code-csharpSystem.Math.Round#2] [!code-vbSystem.Math.Round#2]

Vedi anche

Round(Double) Round(Double) Round(Double) Round(Double)

Arrotonda un valore a virgola mobile e precisione doppia al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Parametri

a
Double Double Double Double

Numero a virgola mobile e precisione doppia da arrotondare.A double-precision floating-point number to be rounded.

Restituisce

Il a più vicino all'intero.The integer nearest a. Se il componente frazionario di a è compreso tra due interi, di cui uno è pari e l'altro dispari, allora viene restituito il numero pari.If the fractional component of a is halfway between two integers, one of which is even and the other odd, then the even number is returned. Si noti che questo metodo restituisce Double anziché un tipo integrale.Note that this method returns a Double instead of an integral type.

Commenti

Questo metodo usa la convenzione di arrotondamento predefinita MidpointRounding.ToEvendi.This method uses the default rounding convention of MidpointRounding.ToEven. Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

Se il valore dell' a argomento è Double.NaN, il metodo restituisce Double.NaN.If the value of the a argument is Double.NaN, the method returns Double.NaN. Se a è Double.PositiveInfinity Double.NegativeInfinityo ,Double.NegativeInfinityilmetodo Double.PositiveInfinity restituisce rispettivamente o.If a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

A partire da Visual Basic 15,8, le prestazioni della conversione da Double a integer sono ottimizzate se si passa il valore restituito dal Round metodo a qualsiasi funzione di conversione integraleo se il valore Double restituito da Round viene automaticamente convertito in un integer con Option Strict impostato su off.Starting with Visual Basic 15.8, the performance of Double-to-integer conversion is optimized if you pass the value returned by the Round method to the any of the integral conversion functions, or if the Double value returned by Round is automatically converted to an integer with Option Strict set to Off. Questa ottimizzazione consente un'esecuzione più rapida del codice, fino a due volte più rapida nei casi di esecuzione di un numero elevato di conversioni a tipi Integer.This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. Nell'esempio seguente vengono illustrate le conversioni ottimizzate seguenti:The following example illustrates such optimized conversions:

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

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

EsempioExample

Nell'esempio seguente viene illustrato l'arrotondamento al valore intero più vicino.The following example demonstrates rounding to the nearest integer value.

using namespace System;

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

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

End Module

Note per i chiamanti

A causa della perdita di precisione che può derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o esecuzione di operazioni aritmetiche su valori Round(Double) a virgola mobile, in alcuni casi il metodo non può sembrare i valori del punto medio arrotondati al numero intero pari più vicino.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double) method may not appear to round midpoint values to the nearest even integer. Nell'esempio seguente, poiché il valore a virgola mobile 1 non ha una rappresentazione binaria finita, la prima chiamata Round(Double) al metodo con un valore di 11,5 restituisce 11 invece di 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

[!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1][!code-csharpSystem.Math.Round#1] [!code-vbSystem.Math.Round#1]

Vedi anche

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

Arrotonda un valore decimale del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

Numero di posizioni decimali nel valore restituito.The number of decimal places in the return value.

Restituisce

Numero più vicino a d contenente un numero di cifre frazionarie pari a decimals.The number nearest to d that contains a number of fractional digits equal to decimals.

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.

Commenti

Il valore dell' decimals argomento può variare da 0 a 28.The value of the decimals argument can range from 0 to 28.

Questo metodo usa la convenzione di arrotondamento predefinita MidpointRounding.ToEvendi.This method uses the default rounding convention of MidpointRounding.ToEven. Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

EsempioExample

Nell'esempio seguente vengono arrotondati i valori decimali con due cifre frazionarie ai valori con una sola cifra frazionaria.The following example rounds decimal values with two fractional digits to values that have a single fractional digit.

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

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

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

Arrotonda un valore decimale al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to be rounded.

Restituisce

Intero più vicino al parametro d.The integer nearest the d parameter. Se il componente frazionario di d è a metà fra due interi, uno pari e uno dispari, viene restituito il numero pari.If the fractional component of d is halfway between two integers, one of which is even and the other odd, the even number is returned. Si noti che questo metodo restituisce Decimal anziché un tipo integrale.Note that this method returns a Decimal instead of an integral type.

Eccezioni

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

Commenti

Questo metodo usa la convenzione di arrotondamento predefinita MidpointRounding.ToEvendi.This method uses the default rounding convention of MidpointRounding.ToEven. Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

EsempioExample

Nell'esempio seguente viene illustrato Round(Decimal) il metodo.The following example demonstrates the Round(Decimal) method. Si noti che Decimal il valore di 4,5 viene arrotondato a 4 anziché 5, perché questo overload USA ToEven la convenzione predefinita.Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.

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

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

Arrotonda un valore decimale all'intero più vicino e usa la convenzione di arrotondamento specificata per i valori che si trovano a metà tra due numeri.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

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

Parametri

d
Decimal Decimal Decimal Decimal

Numero decimale da arrotondare.A decimal number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Spiegazione della modalità di arrotondamento di d se si trova a metà tra due numeri.Specification for how to round d if it is midway between two other numbers.

Restituisce

Il d più vicino all'intero.The integer nearest d. Se d è contenuto tra due numeri, di cui per definizione uno è pari e l'altro dispari, 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, then mode determines which of the two is returned. Si noti che questo metodo restituisce Decimal anziché un tipo integrale.Note that this method returns a Decimal instead of an integral type.

Eccezioni

mode non è un valore valido di MidpointRounding.mode is not a valid value of MidpointRounding.

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

Commenti

Per informazioni sull'arrotondamento di numeri con valori intermedi , vedere valori intermedi e convenzioni di arrotondamento .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza.When rounding midpoint values, the rounding algorithm performs an equality test. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Per altre informazioni, vedere Arrotondamento e la precisione.For more information, see "Rounding and precision".

EsempioExample

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
Vedi anche

Si applica a