System.Decimális szerkezet

Megjegyzés:

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

Az Decimal értéktípus a pozitív 79 228 162 514 264 337 593 543 950 335 és a negatív 79 228 162 514 264 337 593 543 950 335 közötti tizedesjegyeket jelöli. Az alapértelmezett érték Decimal 0. Az Decimal értéktípus olyan pénzügyi számításokhoz megfelelő, amelyek nagy számú jelentős integrál- és törtjegyet igényelnek, és nincsenek kerekítési hibák. A Decimal típus nem szünteti meg a kerekítés szükségességét. Ehelyett a kerekítés miatti hibákat minimalizálja. A következő kód például 1 helyett 0,99999999999999999999999999999999999 eredményt ad.

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)

Amikor az osztás és a szorzás eredménye átkerül a Round metódusnak, az eredmény nem szenved pontosságvesztést, ahogy az alábbi kód is mutatja.

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

A decimális szám egy lebegőpontos érték, amely egy előjelből, egy numerikus értékből áll, amelyben az érték minden számjegye 0 és 9 között mozog, és egy skálázási tényező, amely egy lebegő tizedespont pozícióját jelzi, amely elválasztja a numerikus érték szerves és tört részeit.

Egy érték bináris ábrázolása Decimal 128 bites, amely egy 96 bites egész számból és egy 32 bites jelölőkészletből áll, amelyek olyan dolgokat jelölnek, mint például az előjel és a skálázási tényező, amely meghatározza, hogy melyik része tizedes tört. Ezért a Decimal érték bináris ábrázolása a ((-296 to 296) / 10(0–28)) alakban van, ahol -(296-1) egyenlő MinValue, és 296-1 egyenlő MaxValue. Az értékek bináris ábrázolásáról Decimal és egy példáról további információt a Decimal(Int32[]) konstruktor és a GetBits metódus tartalmaz.

A skálázási tényező a Decimal szám végén lévő nullákat is megőrzi. A záró nullák nem befolyásolják az aritmetikai vagy összehasonlító műveletek számértékét Decimal . A metódus azonban felfedheti a ToString záró nullákat, ha megfelelő formátumsztringet alkalmaz.

Konverziós szempontok

Ez a típus olyan metódusokat biztosít, amelyek átalakítják a Decimal értékeket SByte, Int16, Int32, Int64, Byte, UInt16, UInt32 és UInt64 értékekké. Az ezekből az integráltípusokból Decimal történő konverziók szélesítő konverziók, amelyek soha nem veszítenek információt és nem dobálnak kivételeket.

A(z) Decimal típusú adat bármelyik egész típusú adattá történő konvertálása szűkítő típuskonverzió, amely a Decimal értéket a nullához közelebbi egész számra kerekíti. Egyes nyelvek, például a C#, szintén támogatják az értékek Decimal értékekké Char történő alakítását. Ha ezeknek a konverzióknak az eredménye a céltípusban nem jeleníthető meg, akkor OverflowException kivételt ad.

A Decimal típus olyan metódusokat is tartalmaz, amelyek Decimal értékeket Single és Double értékekre és értékekből alakítanak át. A DecimalSingle vagy Double való konvertálások olyan szűkítő konverziók, amelyek pontosságvesztéssel járhatnak, de a konvertált érték nagyságára vonatkozó információkat nem veszítik el. Az átalakítás nem okoz kivételt.

Átalakítások Single vagy Double -ból/-ből Decimal -re/-ra kivétel kivételt OverflowException eredményeznek, ha az átalakítás eredménye nem ábrázolható Decimal formájában.

Műveletek végrehajtása decimális értékeken

A Decimal típus támogatja a standard matematikai műveleteket, például az összeadást, kivonást, osztást, szorzást és a nemary negációt. A(z) Decimal metódus meghívásával közvetlenül is dolgozhat egy GetBits érték bináris ábrázolásával.

Két Decimal érték összehasonlításához használhatja a standard numerikus összehasonlító operátorokat, vagy meghívhatja a metódustCompareTo.Equals

Az osztály tagjait Math is meghívhatja numerikus műveletek széles skálájának végrehajtásához, beleértve egy szám abszolút értékének lekérését, két Decimal érték maximális vagy minimális értékének meghatározását, egy szám jelének lekérését és egy szám kerekítését.

Példák

Az alábbi példakód bemutatja a használatát 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
  • Last updated on