Compartilhar via

System.Decimal struct

  • Artigo

Este artigo fornece observações complementares à documentação de referência para essa API.

O Decimal tipo de valor representa números decimais que variam de positivo 79.228.162.514.264.337.593.543.950.335 a negativo 79.228.162.514.264.337.593.543.950.335. O valor padrão de a Decimal é 0. O Decimal tipo de valor é apropriado para cálculos financeiros que exigem um grande número de dígitos integrais e fracionários significativos e nenhum erro de arredondamento. O Decimal tipo não elimina a necessidade de arredondamento. Em vez disso, ele minimiza erros devido a arredondamento. Por exemplo, o código a seguir produz um resultado de 0,9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999

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)

Quando o resultado da divisão e multiplicação é passado para o método, o resultado não sofre perda de precisão, como mostra o Round código a seguir.

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

Um número decimal é um valor de ponto flutuante que consiste em um sinal, um valor numérico onde cada dígito no valor varia de 0 a 9 e um fator de escala que indica a posição de um ponto decimal flutuante que separa as partes integral e fracionária do valor numérico.

A representação binária de um valor é de 128 bits que consiste em um número inteiro de 96 bits e um Decimal conjunto de sinalizadores de 32 bits que representam coisas como o sinal e o fator de escala usados para especificar qual parte dele é uma fração decimal. Portanto, a representação binária de um Decimal valor a forma, ((-2 96 a 2 96) / 10(0 a 28)), onde -(2 96-1) é igual a , e 296-1 é igual a .MinValueMaxValue Para obter mais informações sobre a representação binária de Decimal valores e um exemplo, consulte o construtor e o Decimal(Int32[])GetBits método.

O fator de dimensionamento também preserva quaisquer zeros à direita em um Decimal número. Os zeros à direita não afetam o valor de um Decimal número em operações aritméticas ou de comparação. No entanto, zeros à direita podem ser revelados ToString pelo método se uma cadeia de caracteres de formato apropriado for aplicada.

Considerações de conversão

Esse tipo fornece métodos que convertem Decimal valores de e para SByte, , , , , UInt32ByteUInt16, Int64Int16Int32e UInt64 valores. As conversões desses tipos integrais para Decimal estão ampliando as conversões que nunca perdem informações ou lançam exceções.

As conversões de para qualquer um dos tipos integrais são conversões de Decimal estreitamento que arredondam o valor para o Decimal valor inteiro mais próximo em direção a zero. Algumas linguagens, como C#, também oferecem suporte à conversão de Decimal valores em Char valores. Se o resultado dessas conversões não puder ser representado no tipo de destino, uma OverflowException exceção será lançada.

O Decimal tipo também fornece métodos que convertem Decimal valores de e para e Double valoresSingle. Conversões de Decimal ou SingleDouble estão restringindo conversões que podem perder precisão, mas não informações sobre a magnitude do valor convertido. A conversão não lança uma exceção.

Conversões de Single ou Double para Decimal lançar uma OverflowException exceção se o resultado da conversão não puder ser representado como um Decimalarquivo .

Executar operações em valores decimais

O Decimal tipo suporta operações matemáticas padrão, como adição, subtração, divisão, multiplicação e negação unária. Você também pode trabalhar diretamente com a representação binária de um Decimal valor chamando o GetBits método.

Para comparar dois Decimal valores, você pode usar os operadores de comparação numérica padrão ou pode chamar o CompareTo método ou Equals .

Você também pode chamar os Math membros da classe para executar uma ampla gama de operações numéricas, incluindo obter o valor absoluto de um número, determinar o valor máximo ou mínimo de dois Decimal valores, obter o sinal de um número e arredondar um número.

Exemplos

O exemplo de código a seguir demonstra o uso 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