Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Math.Round méthode

 

Date de publication : novembre 2016

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

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

NomDescription
System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal)

Arrondit une valeur décimale à la valeur entière la plus proche.

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, Int32)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié.

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, Int32, MidpointRounding)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié. Un paramètre spécifie comment arrondir la valeur qui se trouve à égale distance des deux nombres.

System_CAPS_pubmethodSystem_CAPS_staticRound(Decimal, MidpointRounding)

Arrondit une valeur décimale à l'entier le plus proche. Un paramètre spécifie comment arrondir la valeur qui se trouve à égale distance des deux nombres.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double)

Arrondit une valeur à virgule flottante double précision à la valeur entière la plus proche.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, Int32)

Arrondit une valeur à virgule flottante double précision au nombre de chiffres fractionnaires spécifié.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, Int32, MidpointRounding)

Arrondit une valeur à virgule flottante double précision au nombre de chiffres fractionnaires spécifié. Un paramètre spécifie comment arrondir la valeur qui se trouve à égale distance des deux nombres.

System_CAPS_pubmethodSystem_CAPS_staticRound(Double, MidpointRounding)

Arrondit une valeur à virgule flottante double précision à l'entier le plus proche. Un paramètre spécifie comment arrondir la valeur qui se trouve à égale distance des deux nombres.

Pour plus d’informations sur le choix d’une surcharge, consultez quelle méthode appeler ?

Decimal Math.Round(Decimald)

Arrondit une valeur décimale à l’entier le plus proche et arrondit les valeurs du milieu au nombre pair le plus proche (exemple).

Double Math.Round(Doublea)

Arrondit une valeur à virgule flottante double précision à l’entier le plus proche et arrondit les valeurs du milieu au nombre pair le plus proche (exemple).

Decimal Math.Round(Decimald, Int32 decimals)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié et arrondit les valeurs du milieu au nombre pair le plus proche (exemple).

Double Math.Round(Doublevalue, Int32 digits)

Arrondit une valeur à virgule flottante double précision au nombre de chiffres fractionnaires spécifié et arrondit les valeurs du milieu au nombre pair le plus proche (exemple).

Decimal Math.Round(Decimald, MidpointRounding mode)

Arrondit une valeur décimale à l’entier le plus proche et utilise la convention d’arrondi spécifiée pour les valeurs du milieu (exemple).

Double Math.Round(Doublevalue, MidpointRounding mode)

Arrondit une valeur à virgule flottante double précision à l’entier le plus proche et utilise la convention d’arrondi spécifiée pour les valeurs du milieu (exemple).

Decimal Math.Round(Decimald, Int32 decimals, MidpointRounding mode)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié et utilise la convention d’arrondi spécifiée pour les valeurs du milieu (exemple).

Double Math.Round(Doublevalue, Int32 digits, MidpointRounding mode)

Arrondit une valeur à virgule flottante double précision au nombre de chiffres fractionnaires spécifié et utilise la convention d’arrondi spécifiée pour les valeurs du milieu (exemple).

Il s’agit d’une liste complète des paramètres pour le Round (méthode). Pour les paramètres utilisés par chaque surcharge, consultez la syntaxe de la surcharge.

Paramètre

Type

Description

d

Decimal

Nombre à arrondir.

a

ou

value

Double

Nombre à virgule flottante double précision à arrondir.

decimals

ou

digits

Int32

Nombre de chiffres fractionnaires de la valeur de retour. Pour Decimal les valeurs, il peut varier entre 0 et 28. Pour Double les valeurs, il peut varier entre 0 et 15. Notez que 15 est le nombre maximal de chiffres entiers et fractionnaires pris en charge par le Double type.

Valeur par défaut : 0, ce qui est arrondi à un entier

mode

MidpointRounding

Un indicateur qui spécifie la convention à utiliser pour arrondir les valeurs du milieu. Consultez la page valeurs du milieu et conventions arrondies.

Valeur par défaut : MidpointRounding.ToEven

Type : Decimal ou Double, selon le type de la valeur à arrondir.
Valeur numérique du même type que d, a, ou value, mais est arrondi à l’entier ou au nombre spécifié de chiffres décimaux.
Consultez la page valeurs du milieu et conventions arrondies pour plus d’informations sur arrondir les nombres avec les valeurs du milieu.

System_CAPS_warningAvertissement

Pour arrondir les valeurs du milieu, l’algorithme arrondi effectue un test d’égalité. À cause de problèmes de précision dans le format à virgule flottante et de la représentation binaire de la valeur retournée par la méthode peut être inattendue. Pour plus d’informations, consultez arrondi et précision.

Si une surcharge avec un Double paramètre est appelé avec Double.NaN, la méthode retourne Double.NaN. Si elle est appelée avec Double.PositiveInfinity ou Double.NegativeInfinity, la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity, respectivement.

Vers

Call

Arrondit un nombre en entier à l’aide de l’arrondi à la convention le plus proche.

Round(Decimal)

ou

Round(Double)

Arrondit un nombre en entier en utilisant une convention d’arrondi.

Round(Decimal, MidpointRounding)

ou

Round(Double, MidpointRounding)

Arrondir un nombre au nombre de chiffres fractionnaires spécifié à l’aide de l’arrondi à la convention le plus proche.

Round(Decimal, Int32)

ou

Round(Double, Int32)

Arrondit un nombre à un nombre spécifié de chiffres fractionnaires en utilisant une convention d’arrondi.

Round(Decimal, Int32, MidpointRounding)

ou

Round(Double, Int32, MidpointRounding)

Arrondi un Single un nombre spécifié de chiffres fractionnaires en utilisant une convention d’arrondi et le minimiser la perte de précision spécifié.

Convertir le Single à un Decimal et appelez Round(Decimal, Int32, MidpointRounding).

Arrondir un nombre au nombre de chiffres fractionnaires spécifié tout en réduisant les problèmes de précision pour arrondir les valeurs du milieu.

Appeler une méthode d’arrondi qui implémente une comparaison « supérieure ou égale à environ ». Consultez la page arrondi et précision.

Arrondit une valeur décimale en un entier qui est supérieur à la valeur de fraction. Par exemple, arrondir 3.1 à 4.

Ceiling

Arrondit une valeur décimale en un entier qui est inférieur à la valeur de fraction. Par exemple, arrondir 3.9 à 3.

Floor

Arrondi implique la conversion d’une valeur numérique avec une précision spécifiée à la valeur la plus proche avec une précision inférieure. Par exemple, vous pouvez utiliser la Round(Double) méthode pour arrondir une valeur de 3.4 à 3.0 et le Round(Double, Int32) méthode pour arrondir une valeur de 3 579 à 3,58.

La valeur après le chiffre le moins significatif dans le résultat est une valeur du milieu, précisément mi-chemin entre deux nombres. Par exemple, 3.47500 est une valeur du milieu s’il doit être arrondie à deux décimales et 7.500 est une valeur du milieu s’il doit être arrondi à un entier. Dans ce cas, la valeur la plus proche ne peut pas être facilement identifiée sans une convention d’arrondi.

Le Round méthode prend en charge les deux conventions d’arrondi pour la gestion des valeurs du milieu :

Arrondissement à zéro

Valeurs du milieu sont arrondies au nombre supérieur à zéro. Par exemple, 3,75 arrondi à 3.8, 3.85 arrondit à 3.9,-3.75 est arrondi à-3.8, et-3.85 est arrondi à-3.9. Cet écran de l’arrondi est représenté par le MidpointRounding.AwayFromZero membre de l’énumération.

Arrondissement à zéro est la forme la plus connue de l’arrondi.

Arrondi au plus près, ou arrondi bancaire

Valeurs du milieu sont arrondies au nombre pair le plus proche. Par exemple, 3,75 et 3.85 arrondi à 3.8, et-3.75 et-3.85 à-3.8. Cet écran de l’arrondi est représenté par le MidpointRounding.ToEven membre de l’énumération.

Arrondi au plus près est le format standard d’arrondi utilisé dans les opérations financières et statistiques. Il est conforme à la norme IEEE 754, section 4. Lorsqu’il est utilisé dans plusieurs opérations d’arrondi, elle réduit l’erreur d’arrondi provoquée par l’arrondissement de valeurs du milieu dans un seul sens. Dans certains cas, cette erreur d’arrondi peut être significative.

L’exemple suivant illustre le décalage résultant de l’arrondissement des valeurs du milieu dans un seul sens. L’exemple calcule la moyenne d’un tableau de true Decimal valeurs, puis calcule la moyenne lorsque les valeurs du tableau sont arrondies en utilisant les deux conventions. Dans cet exemple, la moyenne de la valeur true et la moyenne obtenue lors de la plus proche sont les mêmes. Toutefois, la moyenne obtenue lors de l’arrondissement à zéro diffère à 05 (ou à 3,6 %) à partir de la moyenne de la valeur true.

using System;

public class Example
{
   public static void Main()
   {
      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

Par défaut, le Round méthode utilise l’arrondi à la convention le plus proche. Le tableau suivant répertorie les surcharges de la Round méthode et la convention d’arrondi que chacune utilise.

Surcharge

Convention d’arrondi

Round(Decimal)

ToEven

Round(Double)

ToEven

Round(Decimal, Int32)

ToEven

Round(Double, Int32)

ToEven

Round(Decimal, MidpointRounding)

Déterminé par mode paramètre.

Round(Double, MidpointRounding)

Déterminé par mode paramètre

Round(Decimal, Int32, MidpointRounding)

Déterminé par mode paramètre

Round(Double, Int32, MidpointRounding)

Déterminé par mode paramètre

Afin de déterminer si une opération d’arrondi implique une valeur du milieu, la Round méthode multiplie la valeur d’origine à arrondir par 10n, où n est le nombre de chiffres fractionnaires dans la valeur de retour souhaité, puis détermine si la partie fractionnaire restante de la valeur est supérieure ou égale à 5. Il s’agit d’une variante sur un test d’égalité et comme nous l’avons vu dans la section « Test d’égalité » de la Double rubrique de référence, les tests de l’égalité des valeurs à virgule flottante sont problématiques en raison de problèmes au format à virgule flottante dont la représentation binaire et la précision. Cela signifie que toute partie fractionnaire du nombre qui est légèrement inférieur à 5 (en raison d’une perte de précision) ne sera pas arrondie vers le haut.

L'exemple de code suivant illustre le problème. À plusieurs reprises, il ajoute.1 à 11.0 et arrondit le résultat à l’entier le plus proche. Quelle que soit la convention d’arrondi, 11.5 doivent être arrondies à 12. Toutefois, comme la sortie de l’exemple, il n’existe pas. L’exemple utilise des « R » chaîne de format numérique standard pour afficher la virgule flottante précision la valeur et indique que la valeur à arrondir a perdu la précision lors des additions répétées, et sa valeur est en fait 11.499999999999998. .499999999999998 étant inférieur à 5, la valeur n’est pas arrondie à l’entier le plus élevé. Comme dans l’exemple également, ce problème ne se produit pas si nous attribuons simplement la valeur de constante 11.5 à une 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

Les problèmes de précision pour arrondir les valeurs du milieu sont plus susceptibles de survenir dans les conditions suivantes :

  • Lorsqu’une valeur fractionnaire ne peuvent pas être exprimée précisément dans un format binaire du type à virgule flottante.

  • Lorsque la valeur à arrondir est calculée à partir d’une ou plusieurs opérations à virgule flottante.

  • Lorsque la valeur à arrondir est un Single plutôt que Double ou Decimal. Pour plus d’informations, consultez la section suivante, arrondi et valeurs à virgule flottante simple précision.

Dans les cas où le manque de précision dans les opérations d’arrondi est problématique, vous pouvez procédez comme suit :

  • Si l’opération d’arrondi appelle une surcharge qui arrondit un Double valeur, vous pouvez modifier le Double à un Decimal de valeur et d’appeler une surcharge qui arrondit un Decimal plutôt sa valeur. Bien que le Decimal type de données comporte également des problèmes de représentation et une perte de précision, ces problèmes sont nettement moins courants.

  • Définir un algorithme d’arrondi personnalisé qui exécute un test « presque égal » pour déterminer si la valeur à arrondir est raisonnablement proche d’une valeur du milieu. L’exemple suivant définit un RoundApproximate méthode examine si une valeur fractionnaire est suffisamment près d’une valeur du milieu soit soumis à l’arrondi du milieu. Comme le montre la sortie de l’exemple, il corrige le problème d’arrondi indiqué dans l’exemple précédent.

    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
    

Le Round méthode comprend des surcharges qui acceptent des arguments de type Decimal et Double. Il n’existe aucune méthode arrondit des valeurs de type Single. Si vous passez un Single valeur à une des surcharges de la Round (méthode), il est un cast (en c#) ou convertie (en Visual Basic) en un Double, et correspondant Round surcharge avec un Double paramètre, est appelée. Bien qu’il s’agit d’une conversion étendue, elle implique souvent une perte de précision, comme l’illustre l’exemple suivant. Lorsqu’un Single la valeur de 16.325 est passée à la Round (méthode) et arrondie à deux décimales à l’aide de l’arrondi à la convention le plus proche, le résultat est un résultat 16.33 et non attendu de 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

Le résultat inattendu est dû à une perte de précision lors de la conversion de la Single de valeur pour un Double. Étant donné que résultant Double valeur 16.325000762939453 n’est pas une valeur du milieu et est supérieure à 16.325, il est toujours arrondi vers le haut.

Dans de nombreux cas, comme le montre l’exemple, la perte de précision peut être réduite ou éliminée en conversion ou en convertissant le Single valeur à un Decimal. Notez que, comme il s’agit d’une conversion restrictive, il nécessite à l’aide d’un opérateur de cast ou en appelant une méthode de conversion.

L’exemple suivant illustre la Round(Decimal) méthode. Notez que le Decimal valeur 4,5 est arrondi à 4 plutôt que 5, étant donné que cette surcharge utilise la valeur par défaut ToEven convention.

using System;

class Example
{
   static void Main()
   {
      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

L’exemple suivant illustre l’arrondi au nombre entier le plus proche.

using System;

class Program
{
    static void Main()
    {
    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
    }
}

L’exemple suivant arrondit les valeurs décimales avec deux chiffres fractionnaires aux valeurs qui ont un seul chiffre de fractions de seconde.

using System;

public class Sample {
   static void Main() {
      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

L’exemple suivant arrondit les valeurs doubles avec deux chiffres fractionnaires doubles qui ont un seul chiffre de fractions de seconde.

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

L’exemple suivant affiche les valeurs retournées par la Round(Decimal) (méthode), la Round(Decimal, MidpointRounding) méthode avec un mode argument de ToEven, et le Round(Decimal, MidpointRounding) méthode avec un mode argument de AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      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

L’exemple suivant affiche les valeurs retournées par la Round(Double) (méthode), la Round(Double, MidpointRounding) méthode avec un mode argument de ToEven, et le Round(Double, MidpointRounding) méthode avec un mode argument de 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

L’exemple suivant montre comment utiliser le Round méthode avec la MidpointRounding énumération.

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

class Sample 
{
    public static void Main() 
    {
    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)

*/

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

using System;

class Sample 
{
    public static void Main() 
    {
       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)

.NET Framework

Surcharges sans un MidpointRounding paramètre sont pris en charge dans : 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0
surcharge avec un MidpointRounding paramètre sont pris en charge dans : 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Toutes les surcharges sont prises en charge: 4, 3.5 SP1

Bibliothèque de classes portable

Toutes les surcharges sont pris en charge.

.NET pour les applications du Windows Store

Toutes les surcharges sont prises en charge : Windows 8

Retour au début
Afficher: