Decimal.Round Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Arrondit une valeur à l'entier le plus proche ou au nombre spécifié de décimales.

Surcharges

Round(Decimal, Int32, MidpointRounding)	Arrondit une valeur décimale à la précision spécifiée à l’aide de la stratégie d’arrondi spécifiée.
Round(Decimal, MidpointRounding)	Arrondit une valeur décimale à un entier à l’aide de la stratégie d’arrondi spécifiée.
Round(Decimal)	Arrondit une valeur décimale à l'entier le plus proche.
Round(Decimal, Int32)	Arrondit une valeur Decimal au nombre de décimales spécifié.

Round(Decimal, Int32, MidpointRounding)

Source:

Decimal.cs

Arrondit une valeur décimale à la précision spécifiée à l’aide de la stratégie d’arrondi spécifiée.

C#

public static decimal Round (decimal d, int decimals, MidpointRounding mode);

Paramètres

d

Decimal

Nombre décimal à arrondir.

decimals

Int32

Nombre de décimales significatives (précision) de la valeur de retour.

mode

MidpointRounding

Une des valeurs d’énumération qui spécifie la stratégie d’arrondi à utiliser.

Retours

Decimal

Nombre d arrondi à à l’aide de la mode stratégie d’arrondi et avec une précision de decimals. Si la précision de d est inférieure à decimals, d est retourné sans modification.

Implémente

Round(TSelf, Int32, MidpointRounding)

Exceptions

ArgumentOutOfRangeException

decimals est inférieur à 0 ou supérieur à 28.

ArgumentException

mode n’est pas une valeur MidpointRounding.

OverflowException

Le résultat se situe hors de la plage d’un objet Decimal.

Exemples

L’exemple suivant montre comment utiliser la Round(Decimal, Int32, MidpointRounding) méthode avec l’énumération MidpointRounding .

C#

decimal result;

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

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

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

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

/*
This code example produces the following results:

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

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

Remarques

Le decimals paramètre spécifie le nombre de décimales significatives dans la valeur de retour et est compris entre 0 et 28. Si decimals est zéro, un entier est retourné.

Si vous spécifiez ToEven ou AwayFromZero pour le paramètre , ces stratégies d’arrondi sont appliquées uniquement pour les valeurs de point intermédiaire, c’est-à-dire les valeurs dont le mode chiffre le moins significatif est 5.

Voir aussi

• Round(Decimal, Int32, MidpointRounding)

Round(Decimal, MidpointRounding)

Source:

Decimal.cs

Arrondit une valeur décimale à un entier à l’aide de la stratégie d’arrondi spécifiée.

C#

public static decimal Round (decimal d, MidpointRounding mode);

Paramètres

d

Decimal

Nombre décimal à arrondir.

mode

MidpointRounding

Une des valeurs d’énumération qui spécifie la stratégie d’arrondi à utiliser.

Retours

Decimal

Entier d arrondi à à l’aide de la stratégie d’arrondi mode .

Implémente

Round(TSelf, MidpointRounding)

Exceptions

ArgumentException

mode n’est pas une valeur MidpointRounding.

OverflowException

Le résultat se situe hors de la plage d’un objet Decimal.

Exemples

L’exemple suivant affiche les valeurs retournées par la Round(Decimal, MidpointRounding) méthode avec différents mode arguments.

C#

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

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

Remarques

Si vous spécifiez ToEven ou AwayFromZero pour le paramètre , ces stratégies d’arrondi sont appliquées uniquement pour les valeurs de point intermédiaire, c’est-à-dire les valeurs dont le mode chiffre le moins significatif est 5.

Voir aussi

• Round(Decimal, MidpointRounding)

Round(Decimal)

Source:

Decimal.cs

Arrondit une valeur décimale à l'entier le plus proche.

C#

public static decimal Round (decimal d);

Paramètres

d

Decimal

Nombre décimal à arrondir.

Retours

Decimal

Entier le plus proche du paramètre d. Si d se trouve à mi-chemin entre deux entiers, l'un pair et l'autre impair, le nombre pair est retourné.

Implémente

Round(TSelf)

Exceptions

OverflowException

Le résultat se situe hors de la plage d’une valeur Decimal.

Exemples

L’exemple suivant arrondit une plage de Decimal valeurs comprise entre 100 et 102 à l’entier le plus proche. Étant donné que la méthode utilise l’arrondi du banquier, 100,5 arrondit à 100 et 101,5 rounds à 102.

C#

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

Remarques

Le comportement de cette méthode suit la norme IEEE 754, section 4. Ce type d’arrondi est parfois appelé arrondi de moitié à pair ou d’arrondi de banquier. Il réduit les erreurs d’arrondi qui résultent de l’arrondi constant d’une valeur médiane dans une seule direction. Cela revient à appeler la Round(Decimal, MidpointRounding) méthode avec un mode argument de MidpointRounding.ToEven.

Voir aussi

• Round(Decimal)

Round(Decimal, Int32)

Source:

Decimal.cs

Arrondit une valeur Decimal au nombre de décimales spécifié.

C#

public static decimal Round (decimal d, int decimals);

Paramètres

d

Decimal

Nombre décimal à arrondir.

decimals

Int32

Valeur de 0 à 28 qui spécifie le nombre de décimales auquel arrondir le chiffre.

Retours

Decimal

Nombre décimal équivalent à d arrondi à decimals des décimales.

Implémente

Round(TSelf, Int32)

Exceptions

ArgumentOutOfRangeException

decimals n’est pas une valeur comprise entre 0 et 28.

Exemples

L’exemple suivant arrondit plusieurs Decimal valeurs à un nombre spécifié de décimales à l’aide de la Round méthode .

C#

using System;

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

      Console.WriteLine("{0,26}{1,8}{2,26}",
                        "Argument", "Digits", "Result" );
      Console.WriteLine("{0,26}{1,8}{2,26}",
                        "--------", "------", "------" );
      for (int ctr = 0; ctr < values.Length; ctr++)
        Console.WriteLine("{0,26}{1,8}{2,26}",
                          values[ctr], decimals[ctr],
                          Decimal.Round(values[ctr], decimals[ctr]));
    }
}
// The example displays the following output:
//                   Argument  Digits                    Result
//                   --------  ------                    ------
//                       1.45       1                       1.4
//                       1.55       1                       1.6
//                 123.456789       4                  123.4568
//                 123.456789       6                123.456789
//                 123.456789       8                123.456789
//                   -123.456       0                      -123
//               -123.0000000       3                  -123.000
//               -123.0000000      11              -123.0000000
//     -9999999999.9999999999       9    -10000000000.000000000
//     -9999999999.9999999999      10    -9999999999.9999999999

Remarques

Cette méthode équivaut à appeler la Round(Decimal, Int32, MidpointRounding) méthode avec un mode argument de MidpointRounding.ToEven. Quand d est exactement à mi-chemin entre deux valeurs arrondies, le résultat est la valeur arrondie qui a un chiffre pair dans la position décimale extrême droite. Par exemple, lorsqu'elle est arrondie à deux décimales, la valeur 2,345 devient 2,34 et la valeur 2,355 devient 2,36. Ce processus est connu sous le nom d’arrondi vers pair, ou arrondi bancaire. Il réduit les erreurs d’arrondi qui résultent de l’arrondi constant d’une valeur médiane dans une seule direction.

Voir aussi

• Floor(Decimal)
• Truncate(Decimal)
• Round(Decimal, Int32)