Partager via

Struct System.Decimal

  • Article

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

Le Decimal type valeur représente des nombres décimaux allant de 79 228 162 514 264 337 593 543 950 950 000 335 à 79 228 162 514 264 337 593 543 950 335. La valeur par défaut d’un Decimal est 0. Le Decimal type de valeur est approprié pour les calculs financiers qui nécessitent un grand nombre de chiffres intégraux et fractionnaires significatifs et sans erreur d’arrondi. Le Decimal type n’élimine pas le besoin d’arrondi. Au lieu de cela, il réduit les erreurs dues à l’arrondi. Par exemple, le code suivant produit un résultat de 0,99999999999999999999999999999999999999 à la place de 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)

Lorsque le résultat de la division et de la multiplication est passé à la Round méthode, le résultat ne subit aucune perte de précision, comme le montre le code suivant.

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

Un nombre décimal est une valeur à virgule flottante qui se compose d’un signe, d’une valeur numérique où chaque chiffre de la valeur est compris entre 0 et 9 et un facteur d’échelle qui indique la position d’un virgule décimale flottante qui sépare les parties intégrales et fractionnaires de la valeur numérique.

La représentation binaire d’une Decimal valeur est de 128 bits composée d’un nombre entier 96 bits et d’un jeu d’indicateurs 32 bits représentant des éléments tels que le signe et le facteur de mise à l’échelle utilisé pour spécifier la partie de celle-ci est une fraction décimale. Par conséquent, la représentation binaire d’une Decimal valeur de la forme ((-2 96 à 296) / 10(0 à 28)), où -(296-1) est égal à MinValue, et 296-1 est égal à MaxValue. Pour plus d’informations sur la représentation binaire des Decimal valeurs et un exemple, consultez le Decimal(Int32[]) constructeur et la GetBits méthode.

Le facteur de mise à l’échelle conserve également les zéros de fin dans un Decimal nombre. Les zéros de fin n’affectent pas la valeur d’un nombre dans les Decimal opérations arithmétiques ou de comparaison. Toutefois, les zéros de fin peuvent être révélés par la ToString méthode si une chaîne de format appropriée est appliquée.

Considérations relatives à la conversion

Ce type fournit des méthodes qui convertissent Decimal des valeurs vers et depuis SByte, , Int64Int32Int16, Byte, , UInt16et UInt32UInt64 des valeurs. Les conversions de ces types intégraux pour Decimal élargir les conversions qui ne perdent jamais d’informations ou lèvent des exceptions.

Les conversions de Decimal l’un des types intégraux réduisent les conversions qui arrondit la Decimal valeur à la valeur entière la plus proche vers zéro. Certains langages, tels que C#, prennent également en charge la conversion de valeurs en DecimalChar valeurs. Si le résultat de ces conversions ne peut pas être représenté dans le type de destination, une OverflowException exception est levée.

Le Decimal type fournit également des méthodes qui convertissent Decimal des valeurs vers et depuis et Double depuisSingle. Les conversions depuis Decimal ou DoubleSingle sont des conversions restrictives qui peuvent perdre de la précision, mais pas des informations sur l’ampleur de la valeur convertie. La conversion ne lève pas d’exception.

Conversions depuis Single ou Double pour Decimal lever une OverflowException exception si le résultat de la conversion ne peut pas être représenté en tant que Decimal.

Effectuer des opérations sur les valeurs décimales

Le Decimal type prend en charge les opérations mathématiques standard telles que l’addition, la soustraction, la division, la multiplication et la négation unaire. Vous pouvez également travailler directement avec la représentation binaire d’une Decimal valeur en appelant la GetBits méthode.

Pour comparer deux Decimal valeurs, vous pouvez utiliser les opérateurs de comparaison numériques standard, ou vous pouvez appeler la ou Equals la CompareTo méthode.

Vous pouvez également appeler les membres de la Math classe pour effectuer un large éventail d’opérations numériques, notamment obtenir la valeur absolue d’un nombre, déterminer la valeur maximale ou minimale de deux Decimal valeurs, obtenir le signe d’un nombre et arrondir un nombre.

Exemples

L'exemple de code suivant montre l'utilisation de 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