Compartilhar via

Estrutura System.Decimal

Este artigo fornece comentários complementares à documentação de referência para esta API.

O tipo de valor Decimal representa números decimais que variam de 79.228.162.514.264.337.593.543.950.335 positivos até -79.228.162.514.264.337.593.543.950.335. O valor padrão de um 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, minimiza os erros devido ao arredondamento. Por exemplo, o código a seguir produz um resultado de 0,99999999999999999999999999999999999999 em vez 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)

Quando o resultado da divisão e multiplicação é passado para o Round método, o resultado não sofre perda de precisão, como mostra o 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 em que cada dígito no valor varia de 0 a 9 e um fator de dimensionamento que indica a posição de um ponto decimal flutuante que separa as partes integrais e fracionárias do valor numérico.

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

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

Considerações de conversão

Esse tipo fornece métodos que convertem valores de Decimal para SByte, Int16, Int32, Int64, Byte, UInt16, UInt32 e UInt64. As conversões desses tipos integrais para Decimal são conversões de ampliação que nunca perdem informações nem geram exceções.

As conversões de Decimal para qualquer um dos tipos integrais são conversões restritivas, arredondando o valor de Decimal para o valor inteiro mais próximo, em direção a zero. Alguns idiomas, como C#, também dão 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 exceção OverflowException será gerada.

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

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

Executar operações em valores decimal

O Decimal tipo dá suporte a 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 método CompareTo ou o método Equals.

Você também pode chamar os membros da Math 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
  • Last updated on