# 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 números decimales comprendidos 79,228,162,514,264,337,593,543,950,335 positivo negativo 79,228,162,514,264,337,593,543,950,335.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 un `Decimal` es 0.The default value of a `Decimal` is 0. El Decimal el tipo de valor es adecuado para cálculos financieros que requieren gran cantidad de dígitos enteros y fraccionarios significativos y no hay 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 se pasa el resultado de la división y multiplicación a la Round método, el resultado se ve afectada ninguna pérdida de precisión, como se muestra en 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 inicio de sesión, un valor numérico, donde cada dígito en el valor comprendido entre 0 y 9 y un factor de escala que indica la posición de un separador decimal flotante que separa las partes enteras y fraccionarias de los 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 un Decimal valor consta de un signo de 1 bit, un número entero de 96 bits y un factor de escala utilizado para dividir el entero de 96 bits y especificar qué parte de ella 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 elevado a un exponente comprendido entre 0 y 28.The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28. Por lo tanto, la representación binaria de un Decimal el formulario, valor ((-296 a 296) / 10(de 0 a 28)), donde-(296-1) es igual a MinValuey 296es igual a -1 MaxValue.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 acerca de la representación binaria de Decimal valores y un ejemplo, vea el Decimal(Int32[]) constructor y el GetBits 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 escalado factor también conserva cualquier finales ceros en un Decimal número.The scaling factor also preserves any trailing zeros in a Decimal number. Los ceros finales no afecta al valor de un Decimal 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, los ceros finales podrían revelarse por la ToString método si se aplica a una cadena de formato adecuado.However, trailing zeros might be revealed by the ToString method if an appropriate format string is applied.

### Consideraciones de conversiónConversion Considerations

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

Conversiones de Decimal a cualquiera de los tipos enteros son las conversiones de restricción que redondean el Decimal valor hacia cero al valor entero más cercano.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 de Decimal valores Char valores.Some languages, such as C#, also support the conversion of Decimal values to Char values. Si no se puede representar el resultado de estas conversiones en el tipo de destino, un OverflowException es 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 a y desde Single y Double valores.The Decimal type also provides methods that convert Decimal values to and from Single and Double values. Conversiones de Decimal a Single o Double son conversiones de restricción que podrían perder precisión, pero no la información acerca de 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.

Conversiones de Single o Double a Decimal producir una OverflowException excepción si el resultado de la conversión no se puede representar como un Decimal.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 los valores decimalesPerforming Operations on Decimal Values

El Decimal tipo admite operaciones matemáticas estándares como la adición, resta, multiplicación, división y unario de negación.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 mediante una llamada a la 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 bien puede llamar el CompareTo o Equals método.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, cómo obtener el valor absoluto de un número, para determinar el valor máximo o mínimo de dos Decimal valores, obteniendo el 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).