Math.Round Methode

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Rundet einen Wert auf die nächste Ganzzahl oder auf die angegebene Anzahl von Bruchstellen.

Überlädt

Round(Double, Int32, MidpointRounding)

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine angegebene Anzahl von Bruchstellen.
Round(Decimal, Int32, MidpointRounding)

Rundet einen Dezimalwert unter Verwendung der angegebenen Rundungskonvention auf eine angegebene Anzahl von Bruchstellen.
Round(Double, MidpointRounding)

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine ganze Zahl.
Round(Double, Int32)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.
Round(Decimal, Int32)

Rundet einen Dezimalwert auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.
Round(Double)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.
Round(Decimal)

Rundet einen Dezimalwert auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.
Round(Decimal, MidpointRounding)

Rundet einen Dezimalwert mit der angegebenen Rundungskonvention um eine ganze Zahl.

Beispiele

Zusätzlich zu den Beispielen im Abschnitt Hinweise enthält dieser Artikel Beispiele, die die folgenden Überladungen der Math.Round -Methode veranschaulichen:

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

Hinweise

In diesem Abschnitt

Welche Methode rufe ich auf?

Sie können die folgende Tabelle verwenden, um eine geeignete Rundungsmethode auszuwählen. Zusätzlich zu den Math.Round Methoden enthält Math.Ceiling es auch und Math.Floor.

Beschreibung Aufruf
Runden Sie eine Zahl mithilfe der Aufrundungskonvention auf eine ganze Zahl. Round(Decimal)
- oder -
Round(Double)
Runden Sie eine Zahl mithilfe einer angegebenen Rundungskonvention auf eine ganze Zahl. Round(Decimal, MidpointRounding)
- oder -
Round(Double, MidpointRounding)
Runden Sie eine Zahl auf eine angegebene Anzahl von Bruchstellen, indem Sie die Rundung auf die nächste Konvention verwenden. Round(Decimal, Int32)
- oder -
Round(Double, Int32)
Runden Sie eine Zahl mithilfe einer angegebenen Rundungskonvention auf eine angegebene Anzahl von Bruchstellen. Round(Decimal, Int32, MidpointRounding)
- oder -
Round(Double, Int32, MidpointRounding)
Runden Sie einen Single Wert auf eine angegebene Anzahl von Bruchstellen, indem Sie eine angegebene Rundungskonvention verwenden und den Genauigkeitsverlust minimieren. Konvertieren sie in Single ein Decimal , und rufen Sie auf Round(Decimal, Int32, MidpointRounding).
Runden Sie eine Zahl auf eine angegebene Anzahl von Bruchstellen, während Sie Probleme mit der Genauigkeit beim Runden von Mittelpunktwerten minimieren. Rufen Sie eine Rundungsmethode auf, die einen Vergleich "größer als oder ungefähr gleich" implementiert. Siehe Rundung und Genauigkeit.
Runden Sie einen Bruchwert auf eine ganze Zahl, die größer als der Bruchwert ist. Beispielsweise runden Sie 3.1 auf 4. Ceiling
Runden Sie einen Bruchwert auf eine ganze Zahl, die kleiner als der Bruchwert ist. Beispiel: Rundung von 3,9 auf 3. Floor

Mittelpunktwerte und Rundungskonventionen

Bei der Rundung wird ein numerischer Wert mit einer angegebenen Genauigkeit in einen Wert mit geringerer Genauigkeit konvertiert. Beispielsweise können Sie die Round(Double) -Methode verwenden, um einen Wert von 3,4 auf 3,0 zu runden, und die Round(Double, Int32) Methode, um einen Wert von 3,579 auf 3,58 zu runden.

In einem Mittelwert befindet sich der Wert nach der am wenigsten signifikanten Ziffer im Ergebnis genau auf halbem Weg zwischen zwei Zahlen. Beispielsweise ist 3.47500 ein Mittelwert, wenn er auf zwei Dezimalstellen gerundet werden soll, und 7.500 ist ein Mittelwert, wenn er auf eine ganze Zahl gerundet werden soll. In diesen Fällen kann der nächstgelegene Wert ohne Eine Rundungskonvention nicht einfach identifiziert werden, wenn die Strategie "Round-to-Nearest" verwendet wird.

Die Round -Methode unterstützt zwei Rundungskonventionen für die Behandlung von Mittelpunktwerten:

  • Abrunden von 0

    Die Mittelwerte werden auf die nächste Zahl von 0 gerundet. Beispiel: 3,75 Runden auf 3,8, 3,85 Runden auf 3,9, -3,75 Runden auf -3,8 und -3,85 Runden auf -3,9. Diese Form der Rundung wird durch den Enumerationsmember MidpointRounding.AwayFromZero dargestellt.

  • Rundung auf die nächstgelegene Gerade oder Aufrundung des Bankiers

    Die Mittelpunktwerte werden auf die nächste gerade Zahl gerundet. Beispielsweise runden sowohl 3,75 als auch 3,85 auf 3,8 und beide -3,75 und -3,85 auf -3,8. Diese Form der Rundung wird durch den Enumerationsmember MidpointRounding.ToEven dargestellt.

Hinweis

In .NET Core 3.0 und höheren Versionen sind drei zusätzliche Rundungsstrategien über die MidpointRounding Enumeration verfügbar. Diese Strategien werden in allen Fällen verwendet, nicht nur für Mittelpunktwerte wie MidpointRounding.ToEven und MidpointRounding.AwayFromZero .

Das Abrunden von null ist die am weitesten bekannte Form der Rundung, während das Aufrunden auf die nächste Gerade der Standard in finanz- und statistischen Vorgängen ist. Er entspricht dem IEEE-Standard 754, Abschnitt 4. Bei Verwendung in mehreren Rundungsvorgängen reduziert die Rundung auf den nächsten sogar den Rundungsfehler, der durch das konsistente Runden von Mittelpunktwerten in eine einzelne Richtung verursacht wird. In einigen Fällen kann dieser Rundungsfehler erheblich sein.

Das folgende Beispiel veranschaulicht die Verzerrung, die sich aus einer konsistenten Rundung von Mittelpunktwerten in einer einzelnen Richtung ergeben kann. Das Beispiel berechnet den wahren Mittelwert eines Arrays von Decimal Werten und berechnet dann den Mittelwert, wenn die Werte im Array mithilfe der beiden Konventionen gerundet werden. In diesem Beispiel sind der wahre Mittelwert und der Mittelwert, der beim Runden auf den nächsten ergebnisgleich ist. Der Mittelwert, dass Ergebnisse beim Abrunden von null abweichen, unterscheidet sich jedoch um 0,05 (oder um 3,6 %) vom tatsächlichen Mittelwert.

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

open System

let values = [| 1.15m; 1.25m; 1.35m; 1.45m; 1.55m; 1.65m |]
let mutable sum = 0m

// Calculate true mean.
for value in values do
    sum <- sum + value

printfn $"True mean:     {sum / decimal values.Length:N2}"

// Calculate mean with rounding away from zero.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.AwayFromZero)

printfn $"AwayFromZero:  {sum / decimal values.Length:N2}"

// Calculate mean with rounding to nearest.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.ToEven)

printfn $"ToEven:        {sum / decimal values.Length:N2}"

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

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)

' The example displays the following output:
'       True mean:     1.40
'       AwayFromZero:  1.45
'       ToEven:        1.40

Standardmäßig verwendet die Round -Methode die Aufrundung auf die nächste gerade Konvention. In der folgenden Tabelle sind die Überladungen der Round -Methode und die jeweils verwendete Rundungskonvention aufgeführt.

Überladung Rundungskonvention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Bestimmt durch mode den Parameter.
Round(Double, MidpointRounding) mode Durch Parameter bestimmt
Round(Decimal, Int32, MidpointRounding) mode Durch Parameter bestimmt
Round(Double, Int32, MidpointRounding) mode Durch Parameter bestimmt

Rundung und Genauigkeit

Um zu bestimmen, ob ein Rundungsvorgang einen Mittelwert umfasst, multipliziert die Round Methode den ursprünglich zu rundenden Wert mit 10n, wobei n die gewünschte Anzahl von Bruchstellen im Rückgabewert ist, und bestimmt dann, ob der verbleibende Teil des Werts größer oder gleich 0,5 ist. Dies ist eine geringfügige Variation eines Gleichheitstests, und wie im Abschnitt "Testen auf Gleichheit" des Double Referenzthemas erläutert, sind Tests auf Gleichheit mit Gleitkommawerten aufgrund der Probleme des Gleitkommaformats mit binärer Darstellung und Genauigkeit problematisch. Dies bedeutet, dass jeder Bruchteil einer Zahl, der etwas kleiner als 0,5 (aufgrund eines Genauigkeitsverlusts) ist, nicht nach oben gerundet wird.

Das Problem wird anhand des folgenden Beispiels veranschaulicht. Es fügt wiederholt .1 zu 11,0 hinzu und rundet das Ergebnis auf die nächste ganze Zahl. 11.5 sollte mithilfe einer der Mittelpunkt-Rundungskonventionen (ToEven oder AwayFromZero) auf 12 abgerundet werden. Wie die Ausgabe aus dem Beispiel zeigt, ist dies jedoch nicht der Fall. Im Beispiel wird die standardmäßige numerische Formatzeichenfolge "R" verwendet, um die volle Genauigkeit des Gleitkommawerts anzuzeigen, und zeigt, dass der zu rundende Wert bei wiederholten Hinzufügungen an Genauigkeit verloren hat, und sein Wert ist tatsächlich 11,499999999999998. Da .499999999999998 kleiner als 0,5 ist, kommen die Midpoint-Rounding-Konventionen nicht ins Spiel, und der Wert wird abgerundet. Wie das Beispiel auch zeigt, tritt dieses Problem nicht auf, wenn Sie einer Double Variablen den konstanten Wert 11,5 zuweisen.

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

open System

let roundValueAndAdd (value: double) =
    printfn $"{value,5:N1} {value,20:R}  {Math.Round(value, MidpointRounding.ToEven),12} {Math.Round(value, MidpointRounding.AwayFromZero),15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// 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

Public Sub Example()
    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 + 0.1
End Function

' 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

Probleme der Genauigkeit bei abgerundeten Mittelpunktwerten treten am wahrscheinlichsten unter den folgenden Bedingungen auf:

  • Wenn ein Bruchwert nicht genau im Binärformat des Gleitkommatyps ausgedrückt werden kann.

  • Wenn der zu rundende Wert aus einer oder mehreren Gleitkommavorgängen berechnet wird.

  • Wenn der zu rundende Wert eher ein Single als ein Double oder Decimalist. Weitere Informationen finden Sie im nächsten Abschnitt Rundung und Gleitkommawerte mit einfacher Genauigkeit.

In Fällen, in denen die fehlende Genauigkeit bei Rundungsvorgängen problematisch ist, können Sie wie folgt vorgehen:

  • Wenn der Rundungsvorgang eine Überladung aufruft, die einen Double Wert rundet, können Sie die Double in einen Decimal Wert ändern und stattdessen eine Überladung aufrufen, die einen Decimal Wert rundet. Obwohl der Decimal Datentyp auch Probleme mit der Darstellung und dem Verlust der Genauigkeit aufweist, treten diese Probleme weitaus seltener auf.

  • Definieren Sie einen benutzerdefinierten Rundungsalgorithmus, der einen "fast gleich"-Test durchführt, um zu bestimmen, ob der zu rundende Wert in der Nähe eines Mittelwerts liegt. Im folgenden Beispiel wird eine RoundApproximate Methode definiert, die untersucht, ob sich ein Bruchwert ausreichend nahe an einem Mittelwert befindet, um einer Mittelpunktrundung unterzogen zu werden. Wie die Ausgabe des Beispiels zeigt, wird das im vorherigen Beispiel gezeigte Rundungsproblem korrigiert.

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

    open System

let roundApproximate dbl digits margin mode =
    let fraction = dbl * Math.Pow(10, digits)
    let value = Math.Truncate fraction
    let fraction = fraction - value
    if fraction = 0 then
        dbl
    else
        let tolerance = margin * dbl
        // Determine whether this is a midpoint value.
        if (fraction >= 0.5 - tolerance) && (fraction <= 0.5 + tolerance) then
            if mode = MidpointRounding.AwayFromZero then
                (value + 1.) / Math.Pow(10, digits)
            elif value % 2. <> 0 then
                (value + 1.) / Math.Pow(10, digits)
            else
                value / Math.Pow(10, digits)
        // Any remaining fractional value greater than .5 is not a midpoint value.
        elif fraction > 0.5 then
            (value + 1.) / Math.Pow(10, digits)
        else
            value / Math.Pow(10, digits)


let roundValueAndAdd value =
    let tolerance = 8e-14
    let round = roundApproximate value 0 tolerance

    printfn $"{value,5:N1} {value,20:R}  {round MidpointRounding.ToEven,12} {round MidpointRounding.AwayFromZero,15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value 
|> ignore

// 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

    Public Sub Example()
    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 = 0.00000000000008
    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 + 0.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 >= 0.5 - tolerance) And (fraction <= 0.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 > 0.5 Then
        Return (value + 1) / Math.Pow(10, digits)
    Else
        Return value / Math.Pow(10, digits)
    End If
End Function

' 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

Rundung und Gleitkommawerte mit einfacher Genauigkeit

Die Round -Methode enthält Überladungen, die Argumente vom Typ Decimal und Doubleakzeptieren. Es gibt keine Methoden, die Werte vom Typ Singlerunden. Wenn Sie einen Single Wert an eine der Überladungen der Round -Methode übergeben, wird er (in C#) umgewandelt oder (in Visual Basic) in ein Doublekonvertiert, und die entsprechende Round Überladung mit einem Double Parameter wird aufgerufen. Dies ist zwar eine Erweiterungskonvertierung, aber häufig mit einem Genauigkeitsverlust verbunden, wie im folgenden Beispiel veranschaulicht. Wenn der Single Wert 16,325 an die Round -Methode übergeben und mithilfe der Rundung auf die nächste Konvention auf zwei Dezimalstellen gerundet wird, ist das Ergebnis 16,33 und nicht das erwartete Ergebnis von 16,32.

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

// In F#, 'float', 'float64', and 'double' are aliases for System.Double...
// 'float32' and 'single' are aliases for System.Single
open System

let value = 16.325f
printfn $"Widening Conversion of {value:R} (type {value.GetType().Name}) to {double value:R} (type {(double value).GetType().Name}): "
printfn $"{Math.Round(decimal value, 2)}"
printfn $"{Math.Round(decimal value, 2, MidpointRounding.AwayFromZero)}"
printfn ""

let decValue = decimal value
printfn $"Cast of {value:R} (type {value.GetType().Name}) to {decValue} (type {decValue.GetType().Name}): "
printfn $"{Math.Round(decValue, 2)}"
printfn $"{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

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()

' 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 Genauigkeitsverlust bei der Konvertierung des Single Werts in einen Doublezurückzuführen. Da der resultierende Double Wert von 16,325000762939453 kein Mittelwert ist und größer als 16,325 ist, wird er immer nach oben gerundet.

In vielen Fällen, wie das Beispiel veranschaulicht, kann der Genauigkeitsverlust minimiert oder vermieden werden, indem der Single Wert umgewandelt oder in einen Decimalkonvertiert wird. Beachten Sie, dass dies eine einschränkende Konvertierung ist, die Verwendung eines Castoperators oder das Aufrufen einer Konvertierungsmethode erforderlich ist.

Round(Double, Int32, MidpointRounding)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine angegebene Anzahl von Bruchstellen.

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

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

digits
Int32

Die Anzahl der Bruchziffern im Rückgabewert.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Double

Die Zahl, auf die Gerundet wird, die value Bruchstellen aufweistdigits. Wenn value weniger Dezimalstellen als digits hat, wird value unverändert zurückgegeben.

Ausnahmen

ArgumentOutOfRangeException

digits ist kleiner als 0 (null) oder größer als 15.

ArgumentException

mode ist kein gültiger Wert von MidpointRounding.

Hinweise

Der Wert des digits Arguments kann zwischen 0 und 15 liegen. Die maximale Anzahl der vom Double Typ unterstützten integralen Ziffern und Bruchstellen ist 15.

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen .

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des value Arguments ist, gibt Double.NaNdie -Methode zurück Double.NaN. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie die Round(Double, Int32, MidpointRounding) -Methode mit der MidpointRounding -Enumeration verwendet wird.


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

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

// Round a negative value using a MidpointRounding value.
result = Math.Round(-3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n");

// 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.47, 1, MidpointRounding.ToZero)

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

// Round a positive and a negative value using the default.
let result = Math.Round(3.45, 1)
printfn $"{result,4} = Math.Round({3.45,5}, 1)"
let result = Math.Round(-3.45, 1)
printfn $"{result,4} = Math.Round({-3.45,5}, 1)\n"

// Round a positive value using a MidpointRounding value.
let result = Math.Round(3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using a MidpointRounding value.
let result = Math.Round(-3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n"

// 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.47, 1, MidpointRounding.ToZero)

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

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()

'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)

Hinweise für Aufrufer

Aufgrund des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder dem Ausführen arithmetischer Operationen für Gleitkommawerte ergeben kann, scheint die Round(Double, Int32, MidpointRounding) Methode in einigen Fällen möglicherweise nicht, wie vom -Parameter angegeben, mittelpunktige Werte abzurunden mode . Dies wird im folgenden Beispiel veranschaulicht, in dem 2.135 auf 2.13 anstelle von 2.14 gerundet wird. Dies liegt daran, dass intern die Methode mit 10Ziffern multipliziertvalue, und der Multiplikationsvorgang in diesem Fall einen Genauigkeitsverlust aufweist.

double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
foreach (double value in values)
   Console.WriteLine("{0} --> {1}", value,
                     Math.Round(value, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2, MidpointRounding.AwayFromZero)}"
// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, 
                           Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.13
'       2.135 --> 2.13
'       2.145 --> 2.15
'       3.125 --> 3.13
'       3.135 --> 3.14
'       3.145 --> 3.15

Weitere Informationen

Gilt für:

Round(Decimal, Int32, MidpointRounding)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Dezimalwert unter Verwendung der angegebenen Rundungskonvention auf eine angegebene Anzahl von Bruchstellen.

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

Eine zu rundende Dezimalzahl.

decimals
Int32

Die Anzahl von Dezimalstellen im Rückgabewert.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Decimal

Die Zahl mit decimals Bruchstellen, die d auf gerundet wird. Wenn d weniger Dezimalstellen als decimals hat, wird d unverändert zurückgegeben.

Ausnahmen

ArgumentOutOfRangeException

decimals ist kleiner als 0 (null) oder größer als 28.

ArgumentException

mode ist kein gültiger Wert von MidpointRounding.

OverflowException

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Hinweise

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen .

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Der Wert des decimals Arguments kann zwischen 0 und 28 liegen.

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie die Round -Methode mit der MidpointRounding -Enumeration verwendet wird.

decimal result;

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

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

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

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

/*
This code example produces the following results:

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

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

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

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

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

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

// This code example produces the following results:

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

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

Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' Round a positive value using different strategies.
' 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)
result = Math.Round(posValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, posValue)
Console.WriteLine()

' Round a negative value using different strategies.
' 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)
result = Math.Round(negValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:
'
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
'        3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToZero)
'
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'        -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToZero)
'

Weitere Informationen

Gilt für:

Round(Double, MidpointRounding)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine ganze Zahl.

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

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Double

Die ganze Zahl, auf die value gerundet wird. Diese Methode gibt einen Double anstelle eines integralen Typs zurück.

Ausnahmen

ArgumentException

mode ist kein gültiger Wert von MidpointRounding.

Hinweise

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen .

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des value Arguments ist, gibt Double.NaNdie -Methode zurück Double.NaN. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Beispiel

Im folgenden Beispiel werden von der Round(Double, MidpointRounding) -Methode zurückgegebene Werte mit unterschiedlichen mode Werten angezeigt.

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($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");

foreach (var value in values)
    Console.WriteLine($"{value,-10:R} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

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

open System

let values = 
    [| 12.; 12.1; 12.2; 12.3; 12.4; 12.5
       12.6; 12.7; 12.8; 12.9; 13. |]

printfn "%-10s %-10s %-10s %-15s %-15s" "Value" "Default" "ToEven" "AwayFromZero" "ToZero"

for value in values do
    $"{value,-10:R} {Math.Round(value),-10} " +
    $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
    $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
    $"{Math.Round(value, MidpointRounding.ToZero),-15}"
    |> printfn "%s"
    
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

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} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For Each value In values
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

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

Hinweise für Aufrufer

Aufgrund des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder dem Ausführen arithmetischer Operationen für Gleitkommawerte ergeben kann, scheint die Round(Double, MidpointRounding) Methode in einigen Fällen möglicherweise nicht den Mittelwert auf die nächste gerade ganze Zahl abzurunden. Da der Gleitkommawert .1 im folgenden Beispiel keine endliche binäre Darstellung aufweist, gibt der erste Aufruf der Round(Double) -Methode mit dem Wert 11,5 11 statt 12 zurück.

using System;

public class Example
{
   public static void Main()
   {
      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} --> {1}", value, Math.Round(value,
                        MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
      printfn $"{value} --> {Math.Round(value, MidpointRounding.AwayFromZero)}"
      value + 0.1

let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      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} --> {1}", value, Math.Round(value, 
                        MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

Weitere Informationen

Gilt für:

Round(Double, Int32)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

digits
Int32

Die Anzahl der Bruchziffern im Rückgabewert.

Gibt zurück

Double

Die Zahl, die value am nächsten liegt und deren Anzahl von Bruchziffern digits entspricht.

Ausnahmen

ArgumentOutOfRangeException

digits ist kleiner als 0 (null) oder größer als 15.

Hinweise

Der Wert des digits Arguments kann zwischen 0 und 15 liegen. Die maximale Anzahl der vom Double Typ unterstützten integralen Ziffern und Bruchstellen ist 15.

Diese Methode verwendet die Standardrundungskonvention von MidpointRounding.ToEven. Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen .

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des value Arguments ist, gibt Double.NaNdie -Methode zurück Double.NaN. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Beispiel

Im folgenden Beispiel werden doppelte Werte mit zwei Bruchstellen auf Doppelte gerundet, die eine einzelne Bruchziffer aufweisen.

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

open System

printfn $"{Math.Round(3.44, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.45, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.46, 1)}" //Returns 3.5.

printfn $"{Math.Round(4.34, 1)}" // Returns 4.3
printfn $"{Math.Round(4.35, 1)}" // Returns 4.4
printfn $"{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 des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder dem Ausführen arithmetischer Operationen für Gleitkommawerte ergeben kann, scheint die Round(Double, Int32) Methode in einigen Fällen möglicherweise nicht den Mittelpunkt auf den nächsten geraden Wert in der digits Dezimalposition zu runden. Dies wird im folgenden Beispiel veranschaulicht, in dem 2.135 auf 2.13 anstelle von 2.14 gerundet wird. Dies liegt daran, dass intern die Methode mit 10Ziffern multipliziertvalue, und der Multiplikationsvorgang in diesem Fall einen Genauigkeitsverlust aufweist.

using System;

public class Example
{
   public static void Main()
   {
      double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
      foreach (double value in values)
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2));
   }
}
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2)}"
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.12
'       2.135 --> 2.13
'       2.145 --> 2.14
'       3.125 --> 3.12
'       3.135 --> 3.14
'       3.145 --> 3.14

Weitere Informationen

Gilt für:

Round(Decimal, Int32)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Dezimalwert auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Eine zu rundende Dezimalzahl.

decimals
Int32

Die Anzahl von Dezimalstellen im Rückgabewert.

Gibt zurück

Decimal

Die Zahl, die d am nächsten liegt und deren Anzahl von Bruchziffern decimals entspricht.

Ausnahmen

ArgumentOutOfRangeException

decimals ist kleiner als 0 (null) oder größer als 28.

OverflowException

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Hinweise

Der Wert des decimals Arguments kann zwischen 0 und 28 liegen.

Diese Methode verwendet die Standard-Rundungskonvention von MidpointRounding.ToEven. Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Beispiel

Im folgenden Beispiel werden Dezimalwerte mit zwei Bruchstellen auf Werte mit einer einzelnen Bruchziffer abgerundet.

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

open System

printfn 
    $"""{Math.Round(3.44m, 1)}
{Math.Round(3.45m, 1)}
{Math.Round(3.46m, 1)}

{Math.Round(4.34m, 1)}
{Math.Round(4.35m, 1)}
{Math.Round(4.36m, 1)}"""

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

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))

' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Weitere Informationen

Gilt für:

Round(Double)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

Gibt zurück

Double

Die zu a nächste Ganzzahl. 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. Beachten Sie, dass diese Methode einen Double anstelle eines ganzzahligen Typs zurückgibt.

Hinweise

Diese Methode verwendet die Standard-Rundungskonvention von MidpointRounding.ToEven. Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des a Arguments ist, gibt Double.NaNdie -Methode zurück Double.NaN. Wenn a ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Ab Visual Basic 15.8 wird die Leistung der Double-to-Integer-Konvertierung optimiert, wenn Sie den von der Round Methode zurückgegebenen Wert an eine der integralen Konvertierungsfunktionen übergeben oder wenn der von Round zurückgegebene Double-Wert automatisch in eine ganze Zahl konvertiert wird, wobei Option Strict auf Off festgelegt ist. Dank dieser Optimierung kann Code schneller ausgeführt werden. Code, der viele Ganzzahltypen konvertiert, wird bis zu doppelt so schnell ausgeführt. Das folgende Beispiel veranschaulicht solche optimierten Konvertierungen:

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

Beispiel

Im folgenden Beispiel wird die Rundung auf den nächsten ganzzahligen Wert veranschaulicht.

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

open System

printfn "Classic Math.Round in F#"
printfn $"{Math.Round(4.4)}" // 4
printfn $"{Math.Round(4.5)}" // 4
printfn $"{Math.Round(4.6)}" // 5
printfn $"{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 des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder der Durchführung arithmetischer Vorgänge für Gleitkommawerte ergeben kann, scheint die Round(Double) Methode in einigen Fällen nicht die Mittleren Werte auf die nächste gerade ganze Zahl zu runden. Da der Gleitkommawert .1 im folgenden Beispiel keine endliche binäre Darstellung aufweist, gibt der erste Aufruf der Methode mit dem Round(Double) Wert 11,5 11 statt 12 zurück.

using System;

public class Example
{
   public static void Main()
   {
      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} --> {1}", value, Math.Round(value));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
    printfn $"{value} --> {Math.Round value}"
    value + 0.1

let mutable value = 11.1

for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      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} --> {1}", value, Math.Round(value))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

Weitere Informationen

Gilt für:

Round(Decimal)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Dezimalwert auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Eine zu rundende Dezimalzahl.

Gibt zurück

Decimal

Die dem d-Parameter nächstgelegene ganze Zahl. 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. Beachten Sie, dass diese Methode einen Decimal anstelle eines ganzzahligen Typs zurückgibt.

Ausnahmen

OverflowException

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Beispiele

Das folgende Beispiel veranschaulicht die Round(Decimal) Methode. Der Decimal Wert von 4,5 rundet auf 4 statt auf 5, da diese Überladung die Standardkonvention ToEven verwendet.

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

open System

for value in 4.2m .. 0.1m .. 4.8m do
    printfn $"{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

Hinweise

Diese Methode verwendet die Standard-Rundungskonvention von MidpointRounding.ToEven. Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Weitere Informationen

Gilt für:

Round(Decimal, MidpointRounding)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Rundet einen Dezimalwert mit einer ganzen Zahl unter Verwendung der angegebenen Rundungskonvention ab.

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

Eine zu rundende Dezimalzahl.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Decimal

Die ganze Zahl, auf die d gerundet wird. Diese Methode gibt einen Decimal anstelle eines integralen Typs zurück.

Ausnahmen

ArgumentException

mode ist kein gültiger Wert von MidpointRounding.

OverflowException

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Hinweise

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Mittelpunktwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Beispiel

Im folgenden Beispiel werden von der Round(Decimal, MidpointRounding) -Methode zurückgegebene Werte mit unterschiedlichen mode Werten angezeigt.

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

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

printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

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

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

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

Weitere Informationen

Gilt für: