Freigeben über

System.Decimal-Struktur

  • Artikel

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Der Decimal Werttyp stellt dezimale Zahlen dar, die von positiven 79.228.162.514.264.337.593.543.950,950,00335 auf negative 79.228.162.514.264.337.593.543.950.335. Der Standardwert eines Werts Decimal ist 0. Der Decimal Werttyp ist für Finanzberechnungen geeignet, die eine große Anzahl signifikanter Integral- und Bruchziffern und keine Abrundungsfehler erfordern. Der Decimal Typ beseitigt nicht die Notwendigkeit der Rundung. Stattdessen reduziert er Fehler, die beim Runden auftreten. Mit dem folgenden Code wird beispielsweise ein Ergebnis von 0,99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999,9999999999,999999999,9999999,9999

decimal dividend = Decimal.One;
decimal divisor = 3;
// The following displays 0.9999999999999999999999999999 to the console
Console.WriteLine(dividend/divisor * divisor);

let dividend = Decimal.One
let divisor = 3m
// The following displays 0.9999999999999999999999999999 to the console
printfn $"{dividend/divisor * divisor}"

Dim dividend As Decimal = Decimal.One
Dim divisor As Decimal = 3
' The following displays 0.9999999999999999999999999999 to the console
Console.WriteLine(dividend/divisor * divisor)

Wenn das Ergebnis der Division und Multiplikation an die Round Methode übergeben wird, leidet das Ergebnis ohne Genauigkeit, wie der folgende Code zeigt.

decimal dividend = Decimal.One;
decimal divisor = 3;
// The following displays 1.00 to the console
Console.WriteLine(Math.Round(dividend/divisor * divisor, 2));

let dividend = Decimal.One
let divisor = 3m
// The following displays 1.00 to the console
printfn $"{Math.Round(dividend/divisor * divisor, 2)}"

Dim dividend As Decimal = Decimal.One
Dim divisor As Decimal = 3
' The following displays 1.00 to the console
Console.WriteLine(Math.Round(dividend/divisor * divisor, 2))

Eine Dezimalzahl ist ein Gleitkommawert, der aus einem Vorzeichen, einem numerischen Wert besteht, bei dem jede Ziffer im Wert zwischen 0 und 9 liegt, und einen Skalierungsfaktor, der die Position eines gleitenden Dezimalkommas angibt, das die integralen und Bruchteile des numerischen Werts trennt.

Die binäre Darstellung eines Decimal Werts ist 128-Bits, die aus einer 96-Bit-ganzzahligen Zahl bestehen, und einer 32-Bit-Gruppe von Flags, die Elemente wie das Vorzeichen und den Skalierungsfaktor darstellen, der verwendet wird, um anzugeben, welcher Teil davon eine Dezimalbruchzahl ist. Daher ist die binäre Darstellung eines Decimal Werts, der der Form entspricht (-296 bis 296) / 10(0 bis 28)), wobei -(296-1) gleich MinValueist und 296-1 gleich MaxValueist. Weitere Informationen zur binären Darstellung von Decimal Werten und einem Beispiel finden Sie im Decimal(Int32[]) Konstruktor und der GetBits Methode.

Der Skalierungsfaktor behält auch alle nachfolgenden Nullen in einer Decimal Zahl bei. Nachfolgende Nullen wirken sich nicht auf den Wert einer Decimal Zahl in arithmetischen oder Vergleichsvorgängen aus. Nachfolgende Nullen können jedoch durch die ToString Methode angezeigt werden, wenn eine entsprechende Formatzeichenfolge angewendet wird.

Überlegungen zur Konvertierung

Dieser Typ stellt Methoden bereit, mit denen Werte in und aus SByteInt16, , Int64Int32, Byte, UInt16, und UInt64UInt32Werten konvertiert Decimal werden. Konvertierungen von diesen integralen Typen auf Decimal eine Erweiterung von Konvertierungen, die niemals Informationen verlieren oder Ausnahmen auslösen.

Konvertierungen von Decimal einem der integralen Typen sind schmale Konvertierungen, die den Decimal Wert auf den nächsten ganzzahligen Wert in Richtung Null runden. Einige Sprachen, z. B. C#, unterstützen auch die Konvertierung von Decimal Werten in Char Werte. Wenn das Ergebnis dieser Konvertierungen nicht im Zieltyp dargestellt werden kann, wird eine OverflowException Ausnahme ausgelöst.

Der Decimal Typ stellt außerdem Methoden bereit, mit denen Werte in und aus Single werten konvertiert Decimal werdenDouble. Konvertierungen von Decimal zu Single oder Double verengen Konvertierungen, die möglicherweise Genauigkeit verlieren, aber keine Informationen über die Größe des konvertierten Werts. Die Konvertierung löst keine Ausnahme aus.

Konvertierungen von Single oder Double auslösen Decimal eine OverflowException Ausnahme, wenn das Ergebnis der Konvertierung nicht als ein Decimaldargestellt werden kann.

Ausführen von Vorgängen für Dezimalwerte

Der Decimal Typ unterstützt mathematische Standardvorgänge wie Addition, Subtraktion, Division, Multiplikation und unäre Negation. Sie können auch direkt mit der binären Darstellung eines Decimal Werts arbeiten, indem Sie die GetBits Methode aufrufen.

Um zwei Decimal Werte zu vergleichen, können Sie die standardmäßigen numerischen Vergleichsoperatoren verwenden oder die CompareTo Methode aufrufen Equals .

Sie können auch die Member der Math Klasse aufrufen, um einen breiten Bereich numerischer Vorgänge auszuführen, einschließlich des Abrufens des Absoluten Werts einer Zahl, bestimmen des Höchst- oder Minimalwerts von zwei Decimal Werten, Abrufen des Vorzeichens einer Zahl und Runden einer Zahl.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung von Decimal.

/// <summary>
/// Keeping my fortune in Decimals to avoid the round-off errors.
/// </summary>
class PiggyBank {
    protected decimal MyFortune;

    public void AddPenny() {
        MyFortune = Decimal.Add(MyFortune, .01m);
    }

    public decimal Capacity {
        get {
            return Decimal.MaxValue;
        }
    }

    public decimal Dollars {
        get {
            return Decimal.Floor(MyFortune);
        }
    }

    public decimal Cents {
        get {
            return Decimal.Subtract(MyFortune, Decimal.Floor(MyFortune));
        }
    }

    public override string ToString() {
        return MyFortune.ToString("C")+" in piggy bank";
    }
}

/// Keeping my fortune in Decimals to avoid the round-off errors.
type PiggyBank() =
    let mutable myFortune = 0m

    member _.AddPenny() =
        myFortune <- Decimal.Add(myFortune, 0.01m)

    member _.Capacity =
        Decimal.MaxValue

    member _.Dollars =
        Decimal.Floor myFortune

    member _.Cents =
        Decimal.Subtract(myFortune, Decimal.Floor myFortune)

    override _.ToString() =
        $"{myFortune:C} in piggy bank"

' Keeping my fortune in Decimals to avoid the round-off errors.
Class PiggyBank
    Protected MyFortune As Decimal

    Public Sub AddPenny()
        MyFortune = [Decimal].Add(MyFortune, 0.01D)
    End Sub

    Public ReadOnly Property Capacity() As Decimal
        Get
            Return [Decimal].MaxValue
        End Get
    End Property

    Public ReadOnly Property Dollars() As Decimal
        Get
            Return [Decimal].Floor(MyFortune)
        End Get
    End Property

    Public ReadOnly Property Cents() As Decimal
        Get
            Return [Decimal].Subtract(MyFortune, [Decimal].Floor(MyFortune))
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return MyFortune.ToString("C") + " in piggy bank"
    End Function
End Class