Estructura System.Decimal

En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.

El Decimal tipo de valor representa números decimales que van desde 79,228,162,514,264,337,593,543,950,950,335 a negativo 79,228,162,514,264,337,593,543,950,335. El valor predeterminado de es Decimal 0. El Decimal tipo de valor es adecuado para los cálculos financieros que requieren un gran número de dígitos enteros y fraccionarios significativos y sin errores de redondeo. El Decimal tipo no elimina la necesidad de redondear. En su lugar, minimiza los errores debido al redondeo. Por ejemplo, el código siguiente genera un resultado de 0,9999999999999999999999999999999999999 en lugar 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)

Cuando el resultado de la división y multiplicación se pasa al Round método , el resultado no sufre ninguna pérdida de precisión, como se muestra en el código siguiente.

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 número decimal es un valor de punto flotante que consta de un signo, un valor numérico donde cada dígito del valor oscila entre 0 y 9 y un factor de escala que indica la posición de un separador decimal flotante que separa las partes integrales y fraccionarios del valor numérico.

La representación binaria de un Decimal valor es de 128 bits que consta de un número entero de 96 bits y un conjunto de 32 bits de marcas que representan elementos como el signo y el factor de escala que se usa para especificar qué parte de es una fracción decimal. Por lo tanto, la representación binaria de un Decimal valor con el formato (-2^{de 96} a 2⁹⁶) / 10^{(0 a 28)}), donde -(2^96-1) es igual a MinValuey 2^96-1 es igual a MaxValue. Para obtener más información sobre la representación binaria de Decimal valores y un ejemplo, vea el Decimal(Int32[]) constructor y el GetBits método .

El factor de escalado también conserva los ceros finales de un Decimal número. Los ceros finales no afectan al valor de un Decimal número en operaciones aritméticas o de comparación. Sin embargo, el ToString método podría revelar ceros finales si se aplica una cadena de formato adecuada.

Consideraciones sobre la conversión

Este tipo proporciona métodos que convierten Decimal valores en y desde SBytelos valores , Int16, ByteInt64UInt16Int32, , UInt32y .UInt64 Las conversiones de estos tipos enteros a Decimal son conversiones de ampliación que nunca pierden información ni inician excepciones.

Las conversiones de Decimal a cualquiera de los tipos enteros son conversiones de restricción que redondean el Decimal valor al valor entero más cercano hacia cero. Algunos lenguajes, como C#, también admiten la conversión de Decimal valores a Char valores. Si el resultado de estas conversiones no se puede representar en el tipo de destino, se produce una OverflowException excepción.

El Decimal tipo también proporciona métodos que convierten Decimal valores en valores y desde Single y Double . Las conversiones de Decimal a o SingleDouble son conversiones de restricción que podrían perder precisión, pero no información sobre la magnitud del valor convertido. La conversión no produce una excepción.

Conversiones de Single o Double para Decimal producir una OverflowException excepción si el resultado de la conversión no se puede representar como .Decimal

Realización de operaciones en valores decimales

El Decimal tipo admite operaciones matemáticas estándar, como suma, resta, división, multiplicación y negación unaria. También puede trabajar directamente con la representación binaria de un Decimal valor llamando al GetBits método .

Para comparar dos Decimal valores, puede usar los operadores de comparación numéricos estándar o puede llamar al CompareTo método o Equals .

También puede llamar a los miembros de la Math clase para realizar una amplia gama de operaciones numéricas, incluida la obtención del valor absoluto de un número, determinar el valor máximo o mínimo de dos Decimal valores, obtener el signo de un número y redondear un número.

Ejemplos

En el siguiente ejemplo de código se muestra el 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