# DecimalDecimalDecimalDecimal Struct

## Definición

Representa un número decimal de punto flotante.Represents a decimal floating-point number.

``public value class Decimal : IComparable, IComparable<System::Decimal>, IConvertible, IEquatable<System::Decimal>, IFormattable, System::Runtime::Serialization::IDeserializationCallback``
``````[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Decimal : IComparable, IComparable<decimal>, IConvertible, IEquatable<decimal>, IFormattable, System.Runtime.Serialization.IDeserializationCallback``````
``````type decimal = struct
interface IFormattable
interface IConvertible
interface IDeserializationCallback``````
``````Public Structure Decimal
Implements IComparable, IComparable(Of Decimal), IConvertible, IDeserializationCallback, IEquatable(Of Decimal), IFormattable``````
Herencia
DecimalDecimalDecimalDecimal
Atributos
Implementaciones

## Ejemplos

En el siguiente ejemplo de código se muestra el uso de Decimal.The following code example demonstrates the use of Decimal.

``````   /// <summary>
/// Keeping my fortune in Decimals to avoid the round-off errors.
/// </summary>
public ref class PiggyBank
{
protected:
Decimal MyFortune;

public:
{
MyFortune = System::Decimal::Add( MyFortune, Decimal(.01) );
}

System::Decimal Capacity()
{
return MyFortune.MaxValue;
}

Decimal Dollars()
{
return Decimal::Floor( MyFortune );
}

Decimal Cents()
{
return Decimal::Subtract( MyFortune, Decimal::Floor( MyFortune ) );
}

virtual System::String^ ToString() override
{
return MyFortune.ToString("C")+" in piggy bank";
}
};
}
``````
``````/// <summary>
/// Keeping my fortune in Decimals to avoid the round-off errors.
/// </summary>
class PiggyBank {
protected decimal MyFortune;

}

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.
Class PiggyBank
Protected MyFortune As Decimal

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

## Comentarios

El Decimal tipo de valor representa los números decimales comprendidos entre el 79,228,162,514,264,337,593,543,950,335 positivo y el 79,228,162,514,264,337,593,543,950,335 negativo.The Decimal value type represents decimal numbers ranging from positive 79,228,162,514,264,337,593,543,950,335 to negative 79,228,162,514,264,337,593,543,950,335. El valor predeterminado de `Decimal` es 0.The default value of a `Decimal` is 0. El Decimal tipo de valor es adecuado para los cálculos financieros que requieren un gran número de dígitos integrales y fraccionarios significativos y sin errores de redondeo.The Decimal value type is appropriate for financial calculations that require large numbers of significant integral and fractional digits and no round-off errors. El Decimal tipo no elimina la necesidad de redondeo.The Decimal type does not eliminate the need for rounding. En su lugar, minimiza los errores debido al redondeo.Rather, it minimizes errors due to rounding. Por ejemplo, el código siguiente genera un resultado de 0.9999999999999999999999999999 en lugar de 1.For example, the following code produces a result of 0.9999999999999999999999999999 instead of 1.

``````using namespace System;

void main()
{
Decimal dividend = Decimal::One;
Decimal divisor = 3;
// The following displays 0.9999999999999999999999999999 to the console
Console::WriteLine(dividend/divisor * divisor);
}
``````
``````decimal dividend = Decimal.One;
decimal divisor = 3;
// The following displays 0.9999999999999999999999999999 to the console
Console.WriteLine(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 la multiplicación se pasan al Round método, el resultado no sufre ninguna pérdida de precisión, como muestra el código siguiente.When the result of the division and multiplication is passed to the Round method, the result suffers no loss of precision, as the following code shows.

``````using namespace System;

void main()
{
Decimal dividend = Decimal::One;
Decimal divisor = 3;
// The following displays 1.00 to the console
Console::WriteLine(Math::Round(dividend/divisor * divisor, 2));
}
``````
``````decimal dividend = Decimal.One;
decimal divisor = 3;
// The following displays 1.00 to the console
Console.WriteLine(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 va de 0 a 9, y un factor de escala que indica la posición de un punto decimal flotante que separa las partes enteras y fraccionarias del valor numérico.A decimal number is a floating-point value that consists of a sign, a numeric value where each digit in the value ranges from 0 to 9, and a scaling factor that indicates the position of a floating decimal point that separates the integral and fractional parts of the numeric value.

La representación binaria de Decimal un valor consta de un signo de 1 bit, un número entero de 96 bits y un factor de escala que se usa para dividir el entero de 96 bits y especificar qué parte es una fracción decimal.The binary representation of a Decimal value consists of a 1-bit sign, a 96-bit integer number, and a scaling factor used to divide the 96-bit integer and specify what portion of it is a decimal fraction. El factor de escala es implícitamente el número 10, que se eleva a un exponente que va de 0 a 28.The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28. Por Decimal lo tanto, la representación binaria de un valor del formulario ((-296 a 296)/10(0 a 28)), donde-(296-1) es MinValueigual a y 296-1 es igual MaxValuea.Therefore, the binary representation of a Decimal value the form, ((-296 to 296) / 10(0 to 28)), where -(296-1) is equal to MinValue, and 296-1 is equal to MaxValue. Para obtener más información sobre la representación binaria de Decimal valores y un ejemplo, vea el Decimal(Int32[]) constructor GetBits y el método.For more information about the binary representation of Decimal values and an example, see the Decimal(Int32[]) constructor and the GetBits method.

El factor de escala también conserva los ceros finales de un Decimal número.The scaling factor also preserves any trailing zeros in a Decimal number. Los ceros finales no afectan al valor de un Decimal número en operaciones aritméticas o de comparación.Trailing zeros do not affect the value of a Decimal number in arithmetic or comparison operations. Sin embargo, el ToString método podría revelar ceros finales si se aplica una cadena de formato adecuada.However, trailing zeros might be revealed by the ToString method if an appropriate format string is applied.

### Consideraciones sobre la conversiónConversion Considerations

Este tipo proporciona Decimal métodos que convierten valores en valores de Int16 Int64 SByte Int32 Byte ,UInt32,,,,, y UInt64. UInt16This type provides methods that convert Decimal values to and from SByte, Int16, Int32, Int64, Byte, UInt16, UInt32, and UInt64 values. Las conversiones de estos tipos enteros a Decimal son conversiones de ampliación que nunca pierden información o producen excepciones.Conversions from these integral types to Decimal are widening conversions that never lose information or throw exceptions.

Las conversiones de Decimal a cualquiera de los tipos enteros son conversiones de restricción que redondean Decimal el valor al valor entero más cercano hacia cero.Conversions from Decimal to any of the integral types are narrowing conversions that round the Decimal value to the nearest integer value toward zero. Algunos lenguajes, como C#, también admiten la conversión Decimal de valores Char en valores.Some languages, such as C#, also support the conversion of Decimal values to Char values. Si el resultado de estas conversiones no se puede representar en el tipo de destino, OverflowException se produce una excepción.If the result of these conversions cannot be represented in the destination type, an OverflowException exception is thrown.

El Decimal tipo también proporciona métodos que convierten Decimal valores en y Single desde Double los valores y.The Decimal type also provides methods that convert Decimal values to and from Single and Double values. Las conversiones de Decimal a Single o Double son conversiones de restricción que pueden perder precisión pero no información sobre la magnitud del valor convertido.Conversions from Decimal to Single or Double are narrowing conversions that might lose precision but not information about the magnitude of the converted value. La conversión no produce una excepción.The conversion does not throw an exception.

Las conversiones de Single o Double para Decimal producen una OverflowException excepción Decimalsi el resultado de la conversión no se puede representar como.Conversions from Single or Double to Decimal throw an OverflowException exception if the result of the conversion cannot be represented as a Decimal.

### Realizar operaciones en valores decimalesPerforming Operations on Decimal Values

El Decimal tipo admite operaciones matemáticas estándar como la suma, la resta, la división, la multiplicación y la negación unaria.The Decimal type supports standard mathematical operations such as addition, subtraction, division, multiplication, and unary negation. También puede trabajar directamente con la representación binaria de un Decimal valor llamando al GetBits método.You can also work directly with the binary representation of a Decimal value by calling the GetBits method.

Para comparar dos Decimal valores, puede usar los operadores de comparación numérica estándar, o puede llamar al CompareTo método o Equals .To compare two Decimal values, you can use the standard numeric comparison operators, or you can call the CompareTo or Equals method.

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, la determinación del valor máximo o Decimal mínimo de dos valores, la obtención del signo de un número y el redondeo. un número.You can also call the members of the Math class to perform a wide range of numeric operations, including getting the absolute value of a number, determining the maximum or minimum value of two Decimal values, getting the sign of a number, and rounding a number.

## Constructores

 Decimal(Double) Decimal(Double) Decimal(Double) Decimal(Double) Inicializa una nueva instancia de Decimal en el valor del número de punto flotante de precisión doble especificado.Initializes a new instance of Decimal to the value of the specified double-precision floating-point number. Decimal(Int32) Decimal(Int32) Decimal(Int32) Decimal(Int32) Inicializa una nueva instancia de Decimal en el valor del entero de 32 bits con signo especificado.Initializes a new instance of Decimal to the value of the specified 32-bit signed integer. Decimal(Int32[]) Decimal(Int32[]) Decimal(Int32[]) Decimal(Int32[]) Inicializa una nueva instancia de Decimal en un valor decimal representado en binario e incluido en una matriz especificada.Initializes a new instance of Decimal to a decimal value represented in binary and contained in a specified array. Decimal(Int64) Decimal(Int64) Decimal(Int64) Decimal(Int64) Inicializa una nueva instancia de Decimal en el valor del entero de 64 bits con signo especificado.Initializes a new instance of Decimal to the value of the specified 64-bit signed integer. Decimal(Single) Decimal(Single) Decimal(Single) Decimal(Single) Inicializa una nueva instancia de Decimal en el valor del número de punto flotante de precisión sencilla especificado.Initializes a new instance of Decimal to the value of the specified single-precision floating-point number. Decimal(UInt32) Decimal(UInt32) Decimal(UInt32) Decimal(UInt32) Inicializa una nueva instancia de Decimal en el valor del entero de 32 bits sin signo especificado.Initializes a new instance of Decimal to the value of the specified 32-bit unsigned integer. Decimal(UInt64) Decimal(UInt64) Decimal(UInt64) Decimal(UInt64) Inicializa una nueva instancia de Decimal en el valor del entero de 64 bits sin signo especificado.Initializes a new instance of Decimal to the value of the specified 64-bit unsigned integer. Decimal(Int32, Int32, Int32, Boolean, Byte) Decimal(Int32, Int32, Int32, Boolean, Byte) Decimal(Int32, Int32, Int32, Boolean, Byte) Decimal(Int32, Int32, Int32, Boolean, Byte) Inicializa una nueva instancia de Decimal a partir de los parámetros que especifican las partes constituyentes de la instancia.Initializes a new instance of Decimal from parameters specifying the instance's constituent parts.

## Campos

 MaxValue MaxValue MaxValue MaxValue Representa el mayor valor posible de Decimal.Represents the largest possible value of Decimal. Este campo es constante y de solo lectura.This field is constant and read-only. MinusOne MinusOne MinusOne MinusOne Representa el número menos uno (-1).Represents the number negative one (-1). MinValue MinValue MinValue MinValue Representa el menor valor posible de Decimal.Represents the smallest possible value of Decimal. Este campo es constante y de solo lectura.This field is constant and read-only. One One One One Representa el número uno (1).Represents the number one (1). Zero Zero Zero Zero Representa el número cero (0).Represents the number zero (0).