System.Decimal-structuur

Het Decimal waardetype vertegenwoordigt decimale getallen van positief 79.228.162.514.264.337.593.543.950.335 tot negatief 79.228.162.514.264.337.593.543.950.335. De standaardwaarde van een Decimal is 0. Het Decimal waardetype is geschikt voor financiële berekeningen waarvoor grote aantallen significante integraal- en breukcijfers en geen afrondingsfouten zijn vereist. Het Decimal type elimineert niet de noodzaak voor afronding. In plaats daarvan worden fouten door afronding geminimaliseerd. De volgende code produceert bijvoorbeeld een resultaat van 0,999999999999999999999999999999999999999999 in plaats van 1.

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)

Wanneer het resultaat van de verdeling en vermenigvuldiging wordt doorgegeven aan de Round methode, lijdt het resultaat geen verlies van precisie, zoals in de volgende code wordt weergegeven.

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

Een decimaal getal is een drijvende-kommawaarde die bestaat uit een teken, een numerieke waarde waarbij elk cijfer in de waarde varieert van 0 tot 9 en een schaalfactor die de positie aangeeft van een zwevend decimaalteken dat de integrale en breukdelen van de numerieke waarde scheidt.

De binaire weergave van een Decimal waarde is 128 bits die bestaan uit een 96-bits geheel getal en een 32-bits set vlaggen die dingen vertegenwoordigen, zoals het teken en de schaalfactor die wordt gebruikt om op te geven welk gedeelte hiervan een decimale breuk is. Daarom is de binaire weergave van een Decimal waarde in het formulier ((-2⁹⁶ tot 2⁹⁶) / 10^{(0 tot 28)}), waarbij -(2^96-1) gelijk is aan MinValueen 2^96-1 gelijk is aan MaxValue. Zie de Decimal constructor en de Decimal(Int32[]) methode voor meer informatie over de binaire weergave van GetBits waarden en een voorbeeld.

De schaalfactor behoudt ook eventuele volgnullen in een Decimal getal. Volgnullen hebben geen invloed op de waarde van een Decimal getal in rekenkundige of vergelijkingsbewerkingen. Volgnullen kunnen echter worden weergegeven door de ToString methode als er een geschikte notatietekenreeks wordt toegepast.

Overwegingen voor conversie

Dit type biedt methoden waarmee Decimal waarden worden geconverteerd naar en van SByte, Int16, Int32, Int64, Byte, UInt16, UInt32 en UInt64 waarden. Conversies van deze integrale typen naar Decimal zijn uitbreidingsconversies die nooit informatie verliezen of uitzonderingen veroorzaken.

Conversies van Decimal naar een van de integrale typen beperken conversies die de Decimal waarde afronden op het dichtstbijzijnde gehele getal naar nul. Sommige talen, zoals C#, ondersteunen ook de conversie van Decimal waarden naar Char waarden. Als het resultaat van deze conversies niet kan worden weergegeven in het doeltype, wordt er een OverflowException uitzondering gegenereerd.

Het Decimal-type biedt ook methoden om Decimal waarden naar en van Single en Double waarden te converteren. Conversies van Decimal naar Single of Double beperken conversies die mogelijk precisie verliezen, maar geen informatie over de grootte van de geconverteerde waarde. De conversie veroorzaakt geen foutmelding.

Conversies van Single of Double naar Decimal veroorzaken een OverflowException-uitzondering als het resultaat van de conversie niet kan worden weergegeven als een Decimal.

Bewerkingen uitvoeren op decimale waarden

Het Decimal type ondersteunt standaard wiskundige bewerkingen, zoals optellen, aftrekken, delen, vermenigvuldigen en unaire negatie. U kunt ook rechtstreeks met de binaire weergave van een Decimal waarde werken door de methode aan te GetBits roepen.

Als u twee Decimal waarden wilt vergelijken, kunt u de standaardoperators voor numerieke vergelijkingen gebruiken of de CompareTo- of Equals-methode aanroepen.

U kunt ook de leden van de Math klasse aanroepen om een breed scala aan numerieke bewerkingen uit te voeren, waaronder het ophalen van de absolute waarde van een getal, het bepalen van de maximum- of minimumwaarde van twee Decimal waarden, het ophalen van het teken van een getal en het afronden van een getal.

Voorbeelden

In het volgende codevoorbeeld ziet u het gebruik van 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