Math.Round Methode

Definition

Namespace:: System

Assemblys:: mscorlib.dll, System.Runtime.Extensions.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Rundet einen Wert auf die nächste ganze Zahl oder auf die angegebene Anzahl von Dezimalstellen ab.

Überlädt

Name	Beschreibung
Round(Double, Int32, MidpointRounding)	Rundet mithilfe der angegebenen Rundungskonvention einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl von Bruchstellen ab.
Round(Decimal, Int32, MidpointRounding)	Rundet einen Dezimalwert auf eine angegebene Anzahl von Dezimalstellen mithilfe der angegebenen Rundungskonvention ab.
Round(Double, MidpointRounding)	Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine ganze Zahl mithilfe der angegebenen Rundungskonvention ab.
Round(Double, Int32)	Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl von Dezimalstellen ab und rundet die Mittelpunktswerte auf die nächste gerade Zahl.
Round(Decimal, Int32)	Rundet einen Dezimalwert auf eine angegebene Anzahl von Dezimalstellen ab und rundet Mittelpunktswerte auf die nächste gerade Zahl ab.
Round(Double)	Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächsten integralen Wert ab und rundet Mittelpunktswerte auf die nächste gerade Zahl.
Round(Decimal)	Rundet einen Dezimalwert auf den nächstgelegenen integralen Wert und rundet Die Mittelpunktswerte auf die nächste gerade Zahl ab.
Round(Decimal, MidpointRounding)	Rundet einen Dezimalwert auf eine ganze Zahl mithilfe der angegebenen Rundungskonvention.

Beispiele

Zusätzlich zu den Beispielen im Abschnitt "Hinweise " gibt es Beispiele in jeder Überladung der Math.Round Methode.

Hinweise

Inhalt dieses Abschnitts:

Welche Methode wird aufgerufen?
Mittelpunktswerte und Rundungskonventionen
Rundung und Genauigkeit
Rundung und Gleitkommawerte mit einfacher Genauigkeit

Welche Methode soll ich aufrufen?

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

To	Call
Runden Sie eine Zahl auf eine ganze Zahl, indem Sie die nächstliegende Konvention verwenden.	Round(Decimal) - oder - Round(Double)
Runden Sie eine Zahl auf eine ganze Zahl, indem Sie eine angegebene Rundungskonvention verwenden.	Round(Decimal, MidpointRounding) - oder - Round(Double, MidpointRounding)
Runden Sie eine Zahl auf eine angegebene Anzahl von Dezimalstellen, indem Sie die Abrundung auf die nächste Konvention verwenden.	Round(Decimal, Int32) - oder - Round(Double, Int32)
Runden Sie eine Zahl auf eine angegebene Anzahl von Dezimalstellen, indem Sie eine angegebene Rundungskonvention verwenden.	Round(Decimal, Int32, MidpointRounding) - oder - Round(Double, Int32, MidpointRounding)
Runden Sie einen Single Wert auf eine angegebene Anzahl von Bruchzahlen, indem Sie eine angegebene Rundungskonvention verwenden und den Genauigkeitsverlust minimieren.	Konvertieren sie in Single ein Decimal und einen Anruf Round(Decimal, Int32, MidpointRounding).
Runden Sie eine Zahl auf eine angegebene Anzahl von Bruchziffern, während Sie Probleme mit der Genauigkeit beim Runden von Mittelpunktswerten 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 rundet 3,1 auf 4.	Ceiling
Runden Sie einen Bruchwert auf eine ganze Zahl, die kleiner als der Bruchwert ist. Beispielsweise rundet 3,9 auf 3.	Floor

Mittelpunktswerte und Rundungskonventionen

Das Runden umfasst das Konvertieren eines numerischen Werts mit einer angegebenen Genauigkeit in einen Wert mit geringerer Genauigkeit. Sie können beispielsweise 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 Mittelpunktswert ist der Wert nach der am wenigsten signifikanten Ziffer im Ergebnis genau die halbe Strecke zwischen zwei Zahlen. Beispielsweise ist 3,47500 ein Mittelpunktswert, wenn er auf zwei Dezimalstellen gerundet werden soll, und 7,500 ein Mittelpunktswert ist, wenn er auf eine ganze Zahl gerundet werden soll. In diesen Fällen kann der nächste Wert, wenn die round-to-nearest-Strategie verwendet wird, ohne eine Rundungskonvention nicht leicht identifiziert werden.

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

Abrunden von Null

Mittelpunktswerte werden auf die nächste Zahl von Null gerundet. Beispielsweise rundet 3,75 auf 3,8, 3,85 Runden auf 3,9, -3,75 Runden auf -3,8 und -3,85 Runden auf -3,9 ab. Diese Form der Rundung wird durch das MidpointRounding.AwayFromZero Enumerationselement dargestellt.
Rundung auf die nächste gerade oder banker-Rundung

Mittelpunktswerte werden auf die nächste gerade Zahl gerundet. Beispielsweise runden sowohl 3,75 als auch 3,85 auf 3,8 und sowohl -3,75 als auch -3,85 auf -3,8. Diese Form der Rundung wird durch das MidpointRounding.ToEven Enumerationselement dargestellt.

Note

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

Das Abrunden von Null ist die bekannteste Form der Rundung, während das Abrunden auf das Nächste sogar der Standard in finanz- und statistischen Vorgängen ist. Es entspricht IEEE Standard 754, Abschnitt 4. Bei Verwendung in mehreren Rundungsvorgängen reduziert das Aufrunden auf das nächste sogar den Rundungsfehler, der durch eine konsistente Rundung von Mittelpunktwerten in einer einzelnen Richtung verursacht wird. In einigen Fällen kann dieser Rundungsfehler erheblich sein.

Im folgenden Beispiel wird die Verzerrung veranschaulicht, die sich aus konsistent rundenden Mittelpunktwerten in einer einzelnen Richtung ergeben kann. Im Beispiel wird das tatsächliche Mittel eines Wertearrays Decimal berechnet und anschließend der Mittelwert berechnet, wenn die Werte im Array mit den beiden Konventionen gerundet werden. In diesem Beispiel sind das wahre Mittel und der Mittelwert, der beim Runden auf das nächste Ergebnis gleich ist. Der Mittelwert, dass sich die Ergebnisse beim Abrunden von Null von 05 (oder 3,6%) vom tatsächlichen Mittel unterscheiden.

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 Runde auf die nächste gerade Konvention. In der folgenden Tabelle sind die Überladungen der Round Methode und die zu verwendende Rundungskonvention aufgeführt.

Overload	Rundungskonvention
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Bestimmt nach `mode` Parameter.
Round(Double, MidpointRounding)	Bestimmt nach `mode` Parameter
Round(Decimal, Int32, MidpointRounding)	Bestimmt nach `mode` Parameter
Round(Double, Int32, MidpointRounding)	Bestimmt nach `mode` Parameter

Rundung und Genauigkeit

Um festzustellen, ob ein Rundungsvorgang einen Mittelpunktswert umfasst, multipliziert die Round Methode den ursprünglichen Wert, der um 10ⁿ gerundet werden soll, wobei n die gewünschte Anzahl von Bruchstellen im Rückgabewert ist, und bestimmt dann, ob der verbleibende Bruchteil des Werts größer oder gleich 0,5 ist. Dies ist eine geringfügige Variation eines Tests auf Gleichheit, und wie im Abschnitt "Tests für 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 ist (aufgrund eines Genauigkeitsverlusts), nicht nach oben gerundet wird.

Das folgende Beispiel veranschaulicht das Problem. Es addiert wiederholt 0,1 bis 11,0 und rundet das Ergebnis auf die nächste ganze Zahl. 11.5 sollte auf 12 gerundet werden, indem eine der Konventionen für die Mittelpunktsrunde (ToEven oder AwayFromZero) verwendet wird. 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 die Genauigkeit verloren hat, und der Wert ist tatsächlich 11,49999999998. Da .499999999999998 kleiner als 0,5 ist, werden die Halbpunktrundenkonventionen nicht wiedergegeben, und der Wert wird abgerundet. Wie das Beispiel zeigt, tritt dieses Problem nicht auf, wenn Sie einer Double Variablen den Konstantenwert 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 rundenden Mittelpunktwerten treten in den folgenden Bedingungen am ehesten auf:

Wenn ein Bruchwert nicht exakt im Binärformat des Gleitkommatyps ausgedrückt werden kann.
Wenn der zu rundende Wert aus einem oder mehreren Gleitkommavorgängen berechnet wird.
Wenn der wert, der gerundet werden soll, ist ein statt ein Single oder Decimal.Double Weitere Informationen finden Sie im nächsten Abschnitt, Rundung und Gleitkommawerte mit einfacher Genauigkeit.

In Fällen, in denen die Genauigkeit bei Rundungsvorgängen problematisch ist, können Sie die folgenden Aktionen ausführen:

Wenn der Rundungsvorgang eine Überladung aufruft, die einen Double Wert rundet, können Sie den Double Wert 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 hat, sind diese Probleme weit weniger häufig.

Definieren Sie einen benutzerdefinierten Rundungsalgorithmus, der einen "fast gleich"-Test durchführt, um zu bestimmen, ob der zu rundende Wert zu einem Mittelpunktswert akzeptiert wird. Im folgenden Beispiel wird eine RoundApproximate Methode definiert, mit der untersucht wird, ob ein Bruchwert ausreichend nahe einem Mittelpunktswert liegt, der der Mittelpunktsrunde unterzogen werden soll. Wie die Ausgabe aus dem Beispiel 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 Double. Es gibt keine Methoden, die Werte des Typs Singlerunden. Wenn Sie einen Single-Wert an eine der Überladungen der Round-Methode übergeben, wird er (in C#) umgewandelt oder (in Visual Basic) in einen Double konvertiert, und die entsprechende Round-Überladung mit einem parameter Double wird aufgerufen. Obwohl dies eine Verbreiterungskonvertierung ist, ist häufig ein Genauigkeitsverlust erforderlich, wie im folgenden Beispiel dargestellt. Wenn ein Single Wert von 16,325 an die Round Methode übergeben und mit der Abrundung 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 ein Double. Da der resultierende Double Wert von 16,325000762939453 kein Mittelpunktswert ist und größer als 16,325 ist, wird er immer aufwärts gerundet.

In vielen Fällen, wie das Beispiel zeigt, kann der Genauigkeitsverlust durch Guss oder Konvertieren des Single Werts in einen Decimalminimiert oder eliminiert werden. Beachten Sie, dass dies eine schmale Konvertierung ist, die Verwendung eines Umwandlungsoperators oder aufrufen einer Konvertierungsmethode erfordert.

Round(Double, Int32, MidpointRounding)

Quelle:: Math.cs

Quelle:: Math.cs

Quelle:: Math.cs

Quelle:: Math.cs

Quelle:: Math.cs

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

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 Gleitkommazahl mit doppelter Genauigkeit, die gerundet werden soll.

digits: Int32

Die Anzahl der Dezimalstellen im Rückgabewert.

mode: MidpointRounding

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

Gibt zurück

Double

Die Zahl mit digits Dezimalstellen, auf die value gerundet wird. Wenn value weniger Dezimalstellen als digitsvorhanden sind, value wird dies unverändert zurückgegeben.

Ausnahmen

ArgumentOutOfRangeException

digits ist kleiner als 0 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 integraler und bruchzahliger Ziffern, die Double vom Typ unterstützt werden, beträgt 15.

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

Von Bedeutung

Beim Runden von Mittelpunktswerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen mit binärer Darstellung und 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 lautet Double.NaN, gibt die Methode zurück Double.NaN. Ist value oder Double.NegativeInfinity, gibt die Methode bzwDouble.NegativeInfinity. die Methode Double.PositiveInfinity zurück.Double.PositiveInfinity

Beispiel

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


// 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 ausführen arithmetischer Vorgänge für Gleitkommawerte ergeben kann, scheint die Round(Double, Int32, MidpointRounding) Methode in einigen Fällen die durch den mode Parameter angegebenen Mittelpunktwerte nicht zu runden. Dies wird im folgenden Beispiel veranschaulicht, wobei 2,135 auf 2,13 statt auf 2,14 gerundet wird. Dies geschieht, da die Methode intern mit 10^Ziffern multipliziert value wird und der Multiplikationsvorgang in diesem Fall unter einem Genauigkeitsverlust leidet.

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

Quelle:: Math.cs

Quelle:: Math.cs

Rundet einen Dezimalwert auf eine angegebene Anzahl von Dezimalstellen mithilfe der angegebenen Rundungskonvention ab.

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 dezimale Zahl, die gerundet werden soll.

decimals: Int32

Die Anzahl der Dezimalstellen im Rückgabewert.

mode: MidpointRounding

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

Gibt zurück

Decimal

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

Ausnahmen

ArgumentOutOfRangeException

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

ArgumentException

mode ist kein gültiger Wert von MidpointRounding.

OverflowException

Das Ergebnis liegt außerhalb des Bereichs eines Decimal.

Hinweise

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

Von Bedeutung

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

Beispiel

Im folgenden Beispiel wird die Verwendung der Methode mit der Round MidpointRounding Enumeration veranschaulicht.

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

Quelle:: Math.cs

Quelle:: Math.cs

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine ganze Zahl mithilfe der angegebenen Rundungskonvention ab.

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 Gleitkommazahl mit doppelter Genauigkeit, die gerundet werden soll.

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 "Mittelpunktswerte" und "Rundungskonventionen ".

Von Bedeutung

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 daraus ergeben kann, dass Dezimalwerte als Gleitkommazahlen oder arithmetische Operationen für Gleitkommawerte ausgeführt werden, scheint die Round(Double, MidpointRounding) Methode in einigen Fällen möglicherweise keine Mittelpunktswerte auf die nächste gerade ganze Zahl zu runden. Im folgenden Beispiel gibt der erste Aufruf der Round(Double) Methode mit dem Wert 11,5 statt 12 11 zurück, da der Gleitkommawert .11 keine endliche binäre Darstellung aufweist.

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

Quelle:: Math.cs

Quelle:: Math.cs

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl von Dezimalstellen ab und rundet die Mittelpunktswerte auf die nächste 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 Gleitkommazahl mit doppelter Genauigkeit, die gerundet werden soll.

digits: Int32

Die Anzahl der Dezimalstellen im Rückgabewert.

Gibt zurück

Double

Die Zahl, die eine value Anzahl von Dezimalstellen enthält, die gleich ist digits.

Ausnahmen

ArgumentOutOfRangeException

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

Hinweise

Der Wert des digits Arguments kann zwischen 0 und 15 liegen. Die maximale Anzahl integraler und bruchzahliger Ziffern, die Double vom Typ unterstützt werden, beträgt 15.

Diese Methode verwendet die standardmäßige Rundungskonvention von MidpointRounding.ToEven. Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter "Mittelpunktswerte" und "Rundungskonventionen ".

Von Bedeutung

Beispiel

Im folgenden Beispiel werden doppelte Werte mit zwei Dezimalstellen auf Doppelstellen gerundet, die eine einzelne Bruchzahl 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

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 ausführen arithmetischer Vorgänge für Gleitkommawerte ergeben kann, scheint die Round(Double, Int32) Methode in einigen Fällen möglicherweise keine Mittelpunktswerte auf den nächsten geraden Wert in der digits Dezimalposition zu runden. Dies wird im folgenden Beispiel veranschaulicht, wobei 2,135 auf 2,13 statt auf 2,14 gerundet wird. Dies geschieht, da die Methode intern mit 10^Ziffern multipliziert value wird und der Multiplikationsvorgang in diesem Fall unter einem Genauigkeitsverlust leidet.

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

Quelle:: Math.cs

Quelle:: Math.cs

Rundet einen Dezimalwert auf eine angegebene Anzahl von Dezimalstellen ab und rundet Mittelpunktswerte auf die nächste gerade Zahl ab.

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 dezimale Zahl, die gerundet werden soll.

decimals: Int32

Die Anzahl der Dezimalstellen im Rückgabewert.

Gibt zurück

Decimal

Die Zahl, die eine d Anzahl von Dezimalstellen enthält, die gleich ist decimals.

Ausnahmen

ArgumentOutOfRangeException

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

OverflowException

Das Ergebnis liegt außerhalb des Bereichs eines Decimal.

Hinweise

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

Von Bedeutung

Beispiel

Im folgenden Beispiel werden Dezimalwerte mit zwei Dezimalstellen auf Werte gerundet, die eine einzelne Bruchzahl aufweisen.

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

Quelle:: Math.cs

Quelle:: Math.cs

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächsten integralen Wert ab und rundet Mittelpunktswerte auf die nächste 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 Gleitkommazahl mit doppelter Genauigkeit, die gerundet werden soll.

Gibt zurück

Double

Die ganze Zahl, die am nächsten ist a. Wenn die Bruchkomponente zwischen a zwei ganzzahligen Zahlen halbwegs ist, von denen eine gerade und die andere ungerade ist, wird die gerade Zahl zurückgegeben. Beachten Sie, dass diese Methode anstelle eines integralen Typs zurückgibt Double .

Hinweise

Von Bedeutung

Wenn der Wert des a Arguments lautet Double.NaN, gibt die Methode zurück Double.NaN. Ist a oder Double.NegativeInfinity, gibt die Methode bzwDouble.NegativeInfinity. die Methode Double.PositiveInfinity zurück.Double.PositiveInfinity

Ab Visual Basic 15,8 ist die Leistung der Konvertierung von Double-to-integer optimiert, wenn Sie den von der Round-Methode zurückgegebenen Wert an eine der integral Konvertierungsfunktionen übergeben, oder wenn der von Round zurückgegebene Double-Wert automatisch in eine ganze Zahl konvertiert wird, wobei Option Strict auf "Aus" festgelegt ist. Mit dieser Optimierung kann Code schneller ausgeführt werden – bis zu doppelt so schnell für Code, der eine große Anzahl von Konvertierungen in ganzzahlige Typen ausführt. Im folgenden Beispiel werden solche optimierten Konvertierungen veranschaulicht:

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 das Runden auf den nächsten ganzzahligen Wert veranschaulicht.

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 daraus ergeben kann, dass Dezimalwerte als Gleitkommazahlen oder arithmetische Operationen für Gleitkommawerte ausgeführt werden, scheint die Round(Double) Methode in einigen Fällen möglicherweise keine Mittelpunktswerte auf die nächste gerade ganze Zahl zu runden. Im folgenden Beispiel gibt der erste Aufruf der Round(Double) Methode mit dem Wert 11,5 statt 12 11 zurück, da der Gleitkommawert .11 keine endliche binäre Darstellung aufweist.

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

Quelle:: Math.cs

Quelle:: Math.cs

Rundet einen Dezimalwert auf den nächstgelegenen integralen Wert und rundet Die Mittelpunktswerte auf die nächste gerade Zahl ab.

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 dezimale Zahl, die gerundet werden soll.

Gibt zurück

Decimal

Die ganze Zahl, die dem Parameter am nächsten ist d . Wenn die Bruchkomponente zwischen d zwei ganzzahligen Zahlen halbwegs liegt, von denen eine gerade und die andere ungerade ist, wird die gerade Zahl zurückgegeben. Beachten Sie, dass diese Methode anstelle eines integralen Typs zurückgibt Decimal .

Ausnahmen

OverflowException

Das Ergebnis liegt außerhalb des Bereichs eines Decimal.

Beispiele

Im folgenden Beispiel wird die Round(Decimal) Methode veranschaulicht. Der Decimal Wert von 4,5 rundet auf 4 und nicht auf 5 ab, 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

Von Bedeutung

Weitere Informationen

Gilt für:

Round(Decimal, MidpointRounding)

Quelle:: Math.cs

Quelle:: Math.cs

Quelle:: Math.cs

Quelle:: Math.cs

Quelle:: Math.cs

Rundet einen Dezimalwert auf eine ganze Zahl mithilfe der angegebenen Rundungskonvention.

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 dezimale Zahl, die gerundet werden soll.

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 eines Decimal.

Hinweise

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter "Mittelpunktswerte" und "Runden"-Konventionen.

Von Bedeutung

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:

Feedback

War diese Seite hilfreich?