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

Definition

Rundet einen Wert auf die nächste Ganzzahl oder auf die angegebene Anzahl von Bruchstellen.Rounds a value to the nearest integer or to the specified number of fractional digits.

Überlädt

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

Rundet einen Dezimalwert auf die angegebene Anzahl Dezimalstellen und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.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)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf die angegebene Anzahl Dezimalstellen und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.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)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf die nächstgelegene ganze Zahl und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.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)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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)

Rundet einen Dezimalwert auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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)

Rundet einen Dezimalwert auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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)

Rundet einen Dezimalwert auf die nächstgelegene ganze Zahl und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

Beispiele

Zusätzlich zu den Beispielen im Abschnitt " Hinweise " enthält dieser Artikel Beispiele, die die folgenden über Ladungen Math.Round der-Methode veranschaulichen: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)

Hinweis

Die C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt.The C# examples in this article run in the Try.NET inline code runner and playground. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen.Select the Run button to run an example in an interactive window. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code durch erneutes Anklicken der Schaltfläche Ausführen ausführen.Once you execute the code, you can modify it and run the modified code by selecting Run again. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Hinweise

In diesem AbschnittIn this section:

Welche Methode rufe ich auf?Which method do I call?

Mithilfe der folgenden Tabelle können Sie eine geeignete Rundungs Methode auswählen.You can use the following table to select an appropriate rounding method. Zusätzlich zu den Math.Round -Methoden enthält Math.Ceiling es auch und Math.Floor.In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

BeschreibungTo CallCall
Rundet eine Zahl auf eine ganze Zahl mit der Rundung bis zum nächsten Konvention auf.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

- oder --or-

Round(Double)
Rundet eine Zahl mithilfe einer angegebenen Rundungs Konvention auf eine ganze Zahl auf.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

- oder --or-

Round(Double, MidpointRounding)
Rundet eine Zahl auf eine angegebene Anzahl von Bruch Ziffern ab, indem die Rundungs bis zum nächstgelegene Konvention verwendet wird.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

- oder --or-

Round(Double, Int32)
Rundet eine Zahl auf eine angegebene Anzahl von Bruch Ziffern ab, indem eine angegebene Rundungs Konvention verwendet wird.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

- oder --or-

Round(Double, Int32, MidpointRounding)
Rundet einen Single Wert auf eine angegebene Anzahl von Bruch Ziffern ab, indem eine angegebene Rundungs Konvention verwendet und der Genauigkeits Verlust minimiert wird.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Konvertieren Sie in einen Decimal -und Round(Decimal, Int32, MidpointRounding)einen-Befehl. SingleConvert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
Rundet eine Zahl auf eine angegebene Anzahl von Bruch Ziffern auf und minimiert gleichzeitig die Genauigkeits Genauigkeit bei der Rundung von Mittelpunkt Werten.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. Ruft eine Rundungs Methode auf, die einen "größer oder ungefähr gleich"-Vergleich implementiert.Call a rounding method that implements a "greater than or approximately equal to" comparison. Siehe Rundung und Genauigkeit.See Rounding and precision.
Rundet einen Dezimalwert auf eine Ganzzahl, die größer als der Bruch Wert ist.Round a fractional value to an integer that is greater than the fractional value. Beispielsweise rundet 3,1 auf 4.For example, round 3.1 to 4. Ceiling
Rundet einen Dezimalwert auf eine Ganzzahl, die kleiner als der Bruch Wert ist.Round a fractional value to an integer that is less than the fractional value. Beispielsweise rundet 3,9 auf 3.For example, round 3.9 to 3. Floor

Mittelpunkt Werte und Rundungs KonventionenMidpoint values and rounding conventions

Bei der Rundung wird ein numerischer Wert mit einer angegebenen Genauigkeit in den nächstgelegenen Wert mit geringerer Genauigkeit umgerechnet.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. Beispielsweise können Sie die Round(Double) -Methode verwenden, um einen Wert von 3,4 auf 3,0 zu runden, und die-Methode, um den Round(Double, Int32) Wert 3,579 auf 3,58 zu runden.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 einem Mittelpunkt Wert entspricht der Wert nach der am wenigsten signifikanten Ziffer im Ergebnis genau der Hälfte zwischen zwei Zahlen.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. 3,47500 ist z. b. ein Mittelpunkt Wert, wenn zwei Dezimalstellen gerundet werden sollen, und 7,500 ist ein Mittelpunkt Wert, wenn der Wert auf eine ganze Zahl gerundet werden soll.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 diesen Fällen kann der nächstgelegene Wert ohne Rundungs Konvention nicht einfach identifiziert werden.In these cases, the nearest value can't be easily identified without a rounding convention.

Die Round -Methode unterstützt zwei Rundungs Konventionen für die Verarbeitung von Mittelpunkt Werten:The Round method supports two rounding conventions for handling midpoint values:

  • Rundung von NULLRounding away from zero

    Mittelpunkt Werte werden auf die nächste Zahl von NULL gerundet.Midpoint values are rounded to the next number away from zero. 3,75 rundet beispielsweise auf 3,8, 3,85 auf 3,9,-3,75 auf-3,8 und-3,85 auf-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. Diese Form der Rundung wird durch den MidpointRounding.AwayFromZero Enumerationsmember dargestellt.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

    Rundung von NULL ist die bekannteste Form der Rundung.Rounding away from zero is the most widely known form of rounding.

  • Rundung auf das nächste oder die Rundung des BankersRounding to nearest, or banker's rounding

    Mittelpunkt Werte werden auf die nächste gerade Zahl gerundet.Midpoint values are rounded to the nearest even number. Beispielsweise werden sowohl 3,75 als auch 3,85 auf 3,8 und sowohl-3,75 als auch-3,85 auf-3,8 abgerundet.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. Diese Form der Rundung wird durch den MidpointRounding.ToEven Enumerationsmember dargestellt.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

    Rundung zum nächsten ist die Standardform der Rundung, die bei Finanz-und statistischen Vorgängen verwendet wird.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Sie entspricht dem IEEE-Standard 754, Abschnitt 4.It conforms to IEEE Standard 754, section 4. Wenn Sie in mehreren Rundungs Vorgängen verwendet wird, wird der Rundungsfehler verringert, der durch die konsistente Rundung von Mittelpunkt Werten in einer einzelnen Richtung verursacht wird.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. In einigen Fällen kann dieser Rundungsfehler signifikant sein.In some cases, this rounding error can be significant.

    Im folgenden Beispiel wird die Voreingenommenheit veranschaulicht, die sich aus der konsistenten Rundung von Mittelpunkt Werten in einer einzigen Richtung ergeben kann.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. Im Beispiel wird der tatsächliche Mittelwert eines Arrays von Decimal -Werten berechnet. Anschließend wird der Mittelwert berechnet, wenn die Werte im Array mithilfe der beiden Konventionen gerundet werden.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 diesem Beispiel bedeutet der wahre Mittelwert und das, dass sich Ergebnisse ergeben, wenn die Rundung auf den nächsten Wert gleich ist.In this example, the true mean and the mean that results when rounding to nearest are the same. Das bedeutet jedoch, dass sich Ergebnisse beim Rundungs Weg von NULL durch 0,05 (oder durch 3,6%) unterscheiden. vom true-Mittelwert.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
    

Standardmäßig verwendet die Round -Methode die Rundung auf die nächstgelegene Konvention.By default, the Round method uses the rounding to nearest convention. In der folgenden Tabelle werden die über Ladungen Round der-Methode und die-Rundungs Konvention aufgelistet, die jeweils verwendet werden.The following table lists the overloads of the Round method and the rounding convention that each uses.

ÜberladungOverload Rundungs KonventionRounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Wird durch mode den-Parameter bestimmt.Determined by mode parameter.
Round(Double, MidpointRounding) Bestimmt durch mode ParameterDetermined by mode parameter
Round(Decimal, Int32, MidpointRounding) Bestimmt durch mode ParameterDetermined by mode parameter
Round(Double, Int32, MidpointRounding) Bestimmt durch mode ParameterDetermined by mode parameter

Rundung und GenauigkeitRounding and precision

Um zu ermitteln, ob ein Rundungs Vorgang einen Mittelpunkt Wert einschließt, Round multipliziert die Methode den ursprünglichen Wert, der um 10ngerundet werden soll, wobei n die gewünschte Anzahl von Dezimalstellen im Rückgabewert ist, und dann bestimmt, ob der verbleibende Bruch Teil des Werts größer oder gleich. 5 ist.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. Dies ist eine geringfügige Abweichung von einem Test auf Gleichheit, und wie im Abschnitt "Testen auf Gleichheit" des Double Referenz Themas erläutert, sind Tests auf Gleichheit mit Gleit Komma Werten aufgrund der Probleme im Gleit Komma Format mit Binärdateien problematisch. Darstellung und Genauigkeit.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. Dies bedeutet, dass alle Bruchteile einer Zahl, die etwas kleiner als 0,5 (aufgrund eines Genauigkeits Verlusts) ist, nicht abgerundet werden.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.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

Das Problem wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates the problem. Es fügt wiederholt den Wert von 1 bis 11,0 und rundet das Ergebnis auf die nächste ganze Zahl auf.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Unabhängig von der Rundungs Konvention sollte 11,5 auf 12 gerundet werden.Regardless of the rounding convention, 11.5 should round to 12. Wie die Ausgabe aus dem Beispiel zeigt, ist dies jedoch nicht der Fall.However, as the output from the example shows, it does not. Im Beispiel wird die standardmäßige numerische Format Zeichenfolge "R" verwendet, um die vollständige Genauigkeit des Gleit Komma Werts anzuzeigen, und zeigt an, dass der zu abgerundende Wert bei wiederholten Ergänzungen die Genauigkeit verloren hat und sein Wert tatsächlich 11.499999999999998 ist.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. Da. 499999999999998 kleiner als 0,5 ist, wird der Wert nicht auf die nächsthöhere Ganzzahl gerundet.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Wie das Beispiel zeigt, tritt dieses Problem nicht auf, wenn der Konstante Wert 11,5 einfach einer Double Variablen zugewiesen wird.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

Genauigkeits Probleme bei der Rundung von Mittelpunkt Werten werden wahrscheinlich unter den folgenden Bedingungen auftreten:Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

  • Wenn ein Bruchteil des Werts nicht exakt im Binärformat des Gleit Komma Typs ausgedrückt werden kann.When a fractional value cannot be expressed precisely in the floating-point type's binary format.

  • Wenn der zu abgerundende Wert aus einem oder mehreren Gleit Komma Vorgängen berechnet wird.When the value to be rounded is calculated from one or more floating-point operations.

  • Wenn der zu abgerundende Wert ein und Single Double kein oder Decimalist.When the value to be rounded is a Single rather than a Double or Decimal. Weitere Informationen finden Sie im nächsten Abschnitt Rundungs-und Gleit Komma Wertemit einfacher Genauigkeit.For more information, see the next section, Rounding and single-precision floating-point values.

In Fällen, in denen die fehlende Genauigkeit bei Rundungs Vorgängen problematisch ist, können Sie Folgendes tun:In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • Wenn beim Rundungs Double Vorgang eine Double Überladung aufgerufen wird, die einen Wert rundet, können Sie Decimal in einen-Wert ändern und eine- Decimal Überladung aufrufen, die stattdessen einen Wert rundet.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. Obwohl der Decimal Datentyp auch Probleme mit der Darstellung und dem Genauigkeits Verlust hat, sind diese Probleme weitaus weniger häufig.Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • Definieren eines benutzerdefinierten Rundungs Algorithmus, der einen "nahezu gleich"-Test ausführt, um zu bestimmen, ob der zu abgerundende Wert in der Nähe eines Mittelpunkts liegt.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. Im folgenden Beispiel wird eine RoundApproximate -Methode definiert, die überprüft, ob ein Bruchteil in naher Nähe eines Mittelpunkt Werts liegt, der der Mittelpunkt Rundung unterliegt.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. Wie die Ausgabe des Beispiels zeigt, wird das Rundungs Problem, das im vorherigen Beispiel gezeigt wurde, korrigiert.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
    

Rundungs-und Gleit Komma Werte mit einfacher GenauigkeitRounding and single-precision floating-point values

Die Round -Methode enthält über Ladungen, die Argumente vom Decimal Typ Doubleund akzeptieren.The Round method includes overloads that accept arguments of type Decimal and Double. Es gibt keine Methoden zum Runden von Werten vom SingleTyp.There are no methods that round values of type Single. Wenn Sie Single einen Wert an eine der über Ladungen Round der-Methode übergeben, wird dieser in einen Doubleumgewandelt ( C#in) oder konvertiert (in Visual Basic), und die entsprechende Round Überladung mit einem Double -Parameter wird aufgerufen.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. Obwohl dies eine erweiternde Konvertierung ist, beinhaltet es häufig einen Genauigkeits Verlust, wie im folgenden Beispiel veranschaulicht.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. Round Wenn der Single Wert 16,325 an die-Methode übermittelt und auf zwei Dezimalstellen gerundet wird, wobei die nächste Konvention gerundet wird, ist das Ergebnis 16,33 und nicht das erwartete Ergebnis von 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

Dieses unerwartete Ergebnis ist auf einen Genauigkeits Verlust bei der Konvertierung des Single Werts in eine Doublezurückzuführen.This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Da der resultierende Double Wert von 16.325000762939453 kein Mittelpunkt Wert ist und größer als 16,325 ist, wird er immer nach oben gerundet.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 vielen Fällen kann der Genauigkeits Verlust durch umwandeln oder Konvertieren des Single Werts in einen Decimalminimiert oder eliminiert werden, wie im Beispiel veranschaulicht.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. Beachten Sie, dass dies eine einschränkende Konvertierung erfordert, indem Sie einen Cast-Operator oder eine Konvertierungsmethode aufrufen.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)

Rundet einen Dezimalwert auf die angegebene Anzahl Dezimalstellen und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.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

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Dezimalzahl.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

Die Anzahl von Dezimalstellen im Rückgabewert.The number of decimal places in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Angabe, wie d gerundet werden soll, wenn der Wert genau in der Mitte zwischen zwei anderen Zahlen liegt.Specification for how to round d if it is midway between two other numbers.

Gibt zurück

Die Zahl, die d am nächsten liegt und deren Anzahl von Bruchziffern decimals entspricht.The number nearest to d that contains a number of fractional digits equal to decimals. Wenn d weniger Dezimalstellen als decimals hat, wird d unverändert zurückgegeben.If d has fewer fractional digits than decimals, d is returned unchanged.

Ausnahmen

decimals ist kleiner als 0 (null) oder größer als 28.decimals is less than 0 or greater than 28.

mode ist kein gültiger Wert von MidpointRounding.mode is not a valid value of MidpointRounding.

Das Ergebnis liegt außerhalb des Bereichs von Decimal.The result is outside the range of a Decimal.

Hinweise

Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

Der Wert des decimals Arguments kann zwischen 0 und 28 liegen.The value of the decimals argument can range from 0 to 28.

BeispielExample

Im folgenden Beispiel wird veranschaulicht, wie die Round -Methode mit MidpointRounding der-Enumeration verwendet wird.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)
'
Siehe auch

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

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf die angegebene Anzahl Dezimalstellen und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.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

Parameter

value
Double Double Double Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Die Anzahl der Bruchziffern im Rückgabewert.The number of fractional digits in the return value.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Angabe, wie value gerundet werden soll, wenn der Wert genau in der Mitte zwischen zwei anderen Zahlen liegt.Specification for how to round value if it is midway between two other numbers.

Gibt zurück

Die Zahl, die value am nächsten liegt und deren Anzahl von Bruchziffern digits entspricht.The number nearest to value that has a number of fractional digits equal to digits. Wenn value weniger Dezimalstellen als digits hat, wird value unverändert zurückgegeben.If value has fewer fractional digits than digits, value is returned unchanged.

Ausnahmen

digits ist kleiner als 0 (null) oder größer als 15.digits is less than 0 or greater than 15.

mode ist kein gültiger Wert von MidpointRounding.mode is not a valid value of MidpointRounding.

Hinweise

Der Wert des digits Arguments kann zwischen 0 und 15 liegen.The value of the digits argument can range from 0 to 15. Beachten Sie, dass 15 die maximale Anzahl von ganzzahligen und Bruch Ziffern ist Double , die vom-Typ unterstützt werden.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

Wenn der Wert des value -Arguments ist Double.NaN, gibt die Methode zurück. Double.NaNIf the value of the value argument is Double.NaN, the method returns Double.NaN. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

BeispielExample

Im folgenden Beispiel wird veranschaulicht, wie die Round(Double, Int32, MidpointRounding) -Methode mit MidpointRounding der-Enumeration verwendet wird.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)

Hinweise für Aufrufer

Aufgrund der Genauigkeits Verluste, die sich aus der Darstellung von Dezimalwerten als Gleit Komma Zahlen oder der Durchführung arithmetischer Operationen für Gleit Komma Werte ergeben können Round(Double, Int32, MidpointRounding) , scheint die Methode in einigen Fällen keine roundpointwerte wie angegeben anzuzeigen. durch den mode -Parameter.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. Dies wird im folgenden Beispiel veranschaulicht, wobei 2,135 auf 2,13 anstatt auf 2,14 gerundet wird.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Dies liegt value daran, dass die Methode intern mit 10Ziffernmultipliziert wird und der Multiplikations Vorgang in diesem Fall von einem Genauigkeits Verlust abweicht.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 Nr. 3] [! Code-vbSystem. Math. Round Nr. 3][!code-csharpSystem.Math.Round#3] [!code-vbSystem.Math.Round#3]

Siehe auch

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

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf die nächstgelegene ganze Zahl und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.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

Parameter

value
Double Double Double Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.A double-precision floating-point number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Angabe, wie value gerundet werden soll, wenn der Wert genau in der Mitte zwischen zwei anderen Zahlen liegt.Specification for how to round value if it is midway between two other numbers.

Gibt zurück

Die zu value nächste Ganzzahl.The integer nearest value. Wenn value genau in der Mitte zwischen zwei Zahlen liegt, von denen eine gerade und die andere ungerade ist, bestimmt der mode-Parameter, welche der beiden Zahlen zurückgegeben wird.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. Beachten Sie, dass diese Methode einen Double anstelle eines ganzzahligen Typs zurückgibt.Note that this method returns a Double instead of an integral type.

Ausnahmen

mode ist kein gültiger Wert von MidpointRounding.mode is not a valid value of MidpointRounding.

Hinweise

Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

Wenn der Wert des value -Arguments ist Double.NaN, gibt die Methode zurück. Double.NaNIf the value of the value argument is Double.NaN, the method returns Double.NaN. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

BeispielExample

Das folgende Beispiel zeigt Werte an, die Round(Double) von der- Round(Double, MidpointRounding) Methode zurückgegeben mode werden, ToEvendie-Methode Round(Double, MidpointRounding) mit dem- mode Argument und AwayFromZerodie-Methode mit dem-Argument.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

Hinweise für Aufrufer

Aufgrund der Genauigkeits Verluste, die sich aus der Darstellung von Dezimalwerten als Gleit Komma Zahlen oder der Durchführung arithmetischer Operationen für Gleit Komma Werte ergeben können Round(Double, MidpointRounding) , scheint die Methode in einigen Fällen keine Mittelpunkt Werte auf die nächste gerade ganze Zahl.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. Im folgenden Beispiel, da der Gleit Komma Wert 1 keine begrenzte binäre Darstellung hat, gibt der erste Aufrufder Round(Double) -Methode mit dem Wert 11,5 11 anstelle von 12 zurück.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]

Siehe auch

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

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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

Parameter

value
Double Double Double Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.A double-precision floating-point number to be rounded.

digits
Int32 Int32 Int32 Int32

Die Anzahl von Dezimalstellen im Rückgabewert.The number of fractional digits in the return value.

Gibt zurück

Die Zahl, die value am nächsten liegt und deren Anzahl von Nachkommastellen gleich digits ist.The number nearest to value that contains a number of fractional digits equal to digits.

Ausnahmen

digits ist kleiner als 0 (null) oder größer als 15.digits is less than 0 or greater than 15.

Hinweise

Der Wert des digits Arguments kann zwischen 0 und 15 liegen.The value of the digits argument can range from 0 to 15. Beachten Sie, dass 15 die maximale Anzahl von ganzzahligen und Bruch Ziffern ist Double , die vom-Typ unterstützt werden.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Diese Methode verwendet die Standard Rundungs Konvention MidpointRounding.ToEvenvon.This method uses the default rounding convention of MidpointRounding.ToEven. Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

Wenn der Wert des value -Arguments ist Double.NaN, gibt die Methode zurück. Double.NaNIf the value of the value argument is Double.NaN, the method returns Double.NaN. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

BeispielExample

Im folgenden Beispiel werden Double-Werte mit zwei Dezimalstellen auf Double-Werte mit einer einzelnen Bruch Ziffern gerundet.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

Hinweise für Aufrufer

Aufgrund der Genauigkeits Verluste, die sich aus der Darstellung von Dezimalwerten als Gleit Komma Zahlen oder der Durchführung arithmetischer Operationen für Gleit Komma Werte ergeben können Round(Double, Int32) , scheint die Methode in einigen Fällen keine Mittelpunkt Werte auf die der nächstgelegene gerade Wert digits in der Dezimal Position.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. Dies wird im folgenden Beispiel veranschaulicht, wobei 2,135 auf 2,13 anstatt auf 2,14 gerundet wird.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Dies liegt value daran, dass die Methode intern mit 10Ziffernmultipliziert wird und der Multiplikations Vorgang in diesem Fall von einem Genauigkeits Verlust abweicht.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]

Siehe auch

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

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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

Parameter

a
Double Double Double Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.A double-precision floating-point number to be rounded.

Gibt zurück

Der der Ganzzahl am nächsten liegende a.The integer nearest a. Wenn der Nachkommawert von a genau in der Mitte zwischen zwei Ganzzahlen liegt, von denen eine gerade und die andere ungerade ist, wird die gerade Zahl zurückgegeben.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. Beachten Sie, dass diese Methode einen Double anstelle eines ganzzahligen Typs zurückgibt.Note that this method returns a Double instead of an integral type.

Hinweise

Diese Methode verwendet die Standard Rundungs Konvention MidpointRounding.ToEvenvon.This method uses the default rounding convention of MidpointRounding.ToEven. Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

Wenn der Wert des a -Arguments ist Double.NaN, gibt die Methode zurück. Double.NaNIf the value of the a argument is Double.NaN, the method returns Double.NaN. Wenn a ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.If a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

Ab Visual Basic 15,8 wird die Leistung der Konvertierung von Double in Integer optimiert, wenn Sie den von der Round -Methode zurückgegebenen Wert an die ganzzahligen Konvertierungs Funktionenübergeben, oder wenn der Double-Wert von Round zurückgegeben wird. wird automatisch in eine ganze Zahl konvertiert, bei der Option Strict auf OFF festgelegt ist.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. Dank dieser Optimierung kann Code schneller ausgeführt werden. Code, der viele Ganzzahltypen konvertiert, wird bis zu doppelt so schnell ausgeführt.This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. Im folgenden Beispiel werden solche optimierten Konvertierungen veranschaulicht: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

BeispielExample

Im folgenden Beispiel wird die Rundung auf den nächsten ganzzahligen Wert veranschaulicht.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

Hinweise für Aufrufer

Aufgrund der Genauigkeits Verluste, die sich aus der Darstellung von Dezimalwerten als Gleit Komma Zahlen oder der Durchführung arithmetischer Operationen für Gleit Komma Werte ergeben können Round(Double) , scheint die Methode in einigen Fällen keine Mittelpunkt Werte auf die nächste gerade ganze Zahl.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. Im folgenden Beispiel, da der Gleit Komma Wert 1 keine begrenzte binäre Darstellung hat, gibt der erste Aufrufder Round(Double) -Methode mit dem Wert 11,5 11 anstelle von 12 zurück.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]

Siehe auch

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

Rundet einen Dezimalwert auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Dezimalzahl.A decimal number to be rounded.

decimals
Int32 Int32 Int32 Int32

Die Anzahl der Dezimalstellen im Rückgabewert.The number of decimal places in the return value.

Gibt zurück

Die Zahl, die d am nächsten liegt und deren Anzahl von Nachkommastellen gleich decimals ist.The number nearest to d that contains a number of fractional digits equal to decimals.

Ausnahmen

decimals ist kleiner als 0 (null) oder größer als 28.decimals is less than 0 or greater than 28.

Das Ergebnis liegt außerhalb des Bereichs von Decimal.The result is outside the range of a Decimal.

Hinweise

Der Wert des decimals Arguments kann zwischen 0 und 28 liegen.The value of the decimals argument can range from 0 to 28.

Diese Methode verwendet die Standard Rundungs Konvention MidpointRounding.ToEvenvon.This method uses the default rounding convention of MidpointRounding.ToEven. Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

BeispielExample

Im folgenden Beispiel werden Dezimalwerte mit zwei Dezimalstellen auf Werte mit einer einzelnen Bruch Ziffern gerundet.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
Siehe auch

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

Rundet einen Dezimalwert auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.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

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Dezimalzahl.A decimal number to be rounded.

Gibt zurück

Die dem d-Parameter nächstgelegene ganze Zahl.The integer nearest the d parameter. Wenn der Nachkommawert von d genau in der Mitte zwischen zwei Ganzzahlen liegt, von denen eine gerade und die andere ungerade ist, wird die gerade Zahl zurückgegeben.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. Beachten Sie, dass diese Methode einen Decimal anstelle eines ganzzahligen Typs zurückgibt.Note that this method returns a Decimal instead of an integral type.

Ausnahmen

Das Ergebnis liegt außerhalb des Bereichs von Decimal.The result is outside the range of a Decimal.

Hinweise

Diese Methode verwendet die Standard Rundungs Konvention MidpointRounding.ToEvenvon.This method uses the default rounding convention of MidpointRounding.ToEven. Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

BeispielExample

Das folgende Beispiel veranschaulicht die Round(Decimal) Methode.The following example demonstrates the Round(Decimal) method. Beachten Sie, Decimal dass der Wert 4,5 auf 4 anstatt auf 5 gerundet, da diese Überladung ToEven die Standard Konvention verwendet.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
Siehe auch

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

Rundet einen Dezimalwert auf die nächstgelegene ganze Zahl und verwendet den angegebenen Rundungsmodus für Mittelpunktwerte.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

Parameter

d
Decimal Decimal Decimal Decimal

Eine zu rundende Dezimalzahl.A decimal number to be rounded.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

Angabe zum Runden von d, wenn er genau in der Mitte zwischen zwei anderen Zahlen liegt.Specification for how to round d if it is midway between two other numbers.

Gibt zurück

Die zu d nächste Ganzzahl.The integer nearest d. Wenn d genau in der Mitte zwischen zwei Zahlen liegt, von denen eine gerade und die andere ungerade ist, bestimmt der mode-Parameter, welche der beiden Zahlen zurückgegeben wird.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. Beachten Sie, dass diese Methode einen Decimal anstelle eines ganzzahligen Typs zurückgibt.Note that this method returns a Decimal instead of an integral type.

Ausnahmen

mode ist kein gültiger Wert von MidpointRounding.mode is not a valid value of MidpointRounding.

Das Ergebnis liegt außerhalb des Bereichs von Decimal.The result is outside the range of a Decimal.

Hinweise

Weitere Informationen zum Runden von Zahlen mit Mittelpunkt Werten finden Sie unter Mittelpunkt Werte und Rundungs Konventionen .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch.When rounding midpoint values, the rounding algorithm performs an equality test. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Weitere Informationen finden Sie unter „Rundung und Genauigkeit“.For more information, see "Rounding and precision".

BeispielExample

Das folgende Beispiel zeigt Werte an, die Round(Decimal) von der- Round(Decimal, MidpointRounding) Methode zurückgegeben mode werden, ToEvendie-Methode Round(Decimal, MidpointRounding) mit dem- mode Argument und AwayFromZerodie-Methode mit dem-Argument.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
Siehe auch

Gilt für: