Decimal.GetBits Método

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Sobrecargas

GetBits(Decimal)	Convierte el valor de una instancia de Decimal especificada en la representación binaria equivalente.
GetBits(Decimal, Span<Int32>)	Convierte el valor de una instancia de Decimal especificada en la representación binaria equivalente.

GetBits(Decimal)

Source:

Decimal.cs

Convierte el valor de una instancia de Decimal especificada en la representación binaria equivalente.

C#

public static int[] GetBits(decimal d);

Parámetros

d

Decimal

Valor que se va a convertir.

Devoluciones

Int32[]

Matriz de enteros de 32 bits con signo con cuatro elementos que contiene la representación binaria de d.

Ejemplos

En el ejemplo siguiente se usa el GetBits método para convertir varios Decimal valores en sus representaciones binarias equivalentes. A continuación, muestra los valores decimales y el valor hexadecimal de los elementos de la matriz devuelta por el GetBits método .

C#

using System;

class Example
{
   public static void Main()
   {
      // Define an array of Decimal values.
      Decimal[] values = { 1M, 100000000000000M, 10000000000000000000000000000M,
                           100000000000000.00000000000000M, 1.0000000000000000000000000000M,
                           123456789M, 0.123456789M, 0.000000000123456789M,
                           0.000000000000000000123456789M, 4294967295M,
                           18446744073709551615M, Decimal.MaxValue,
                           Decimal.MinValue, -7.9228162514264337593543950335M };

      Console.WriteLine("{0,31}  {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
                        "Argument", "Bits[3]", "Bits[2]", "Bits[1]",
                        "Bits[0]" );
      Console.WriteLine( "{0,31}  {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
                         "--------", "-------", "-------", "-------",
                         "-------" );

      // Iterate each element and display its binary representation
      foreach (var value in values) {
        int[] bits = decimal.GetBits(value);
        Console.WriteLine("{0,31}  {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
                          value, bits[3], bits[2], bits[1], bits[0]);
      }
   }
}
// The example displays the following output:
//                           Argument     Bits[3]   Bits[2]   Bits[1]   Bits[0]
//                           --------     -------   -------   -------   -------
//                                  1    00000000  00000000  00000000  00000001
//                    100000000000000    00000000  00000000  00005AF3  107A4000
//      10000000000000000000000000000    00000000  204FCE5E  3E250261  10000000
//     100000000000000.00000000000000    000E0000  204FCE5E  3E250261  10000000
//     1.0000000000000000000000000000    001C0000  204FCE5E  3E250261  10000000
//                          123456789    00000000  00000000  00000000  075BCD15
//                        0.123456789    00090000  00000000  00000000  075BCD15
//               0.000000000123456789    00120000  00000000  00000000  075BCD15
//      0.000000000000000000123456789    001B0000  00000000  00000000  075BCD15
//                         4294967295    00000000  00000000  00000000  FFFFFFFF
//               18446744073709551615    00000000  00000000  FFFFFFFF  FFFFFFFF
//      79228162514264337593543950335    00000000  FFFFFFFF  FFFFFFFF  FFFFFFFF
//     -79228162514264337593543950335    80000000  FFFFFFFF  FFFFFFFF  FFFFFFFF
//    -7.9228162514264337593543950335    801C0000  FFFFFFFF  FFFFFFFF  FFFFFFFF

En el ejemplo siguiente se usa el GetBits método para recuperar las partes de componente de una matriz. A continuación, usa esta matriz en la llamada al Decimal(Int32, Int32, Int32, Boolean, Byte) constructor para crear una instancia de un nuevo Decimal valor.

C#

using System;

public class Example
{
   public static void Main()
   {
      Decimal[] values = { 1234.96m, -1234.96m };
      foreach (var value in values) {
         int[] parts = Decimal.GetBits(value);
         bool sign = (parts[3] & 0x80000000) != 0;

         byte scale = (byte) ((parts[3] >> 16) & 0x7F);
         Decimal newValue = new Decimal(parts[0], parts[1], parts[2], sign, scale);
         Console.WriteLine("{0} --> {1}", value, newValue);
      }
   }
}
// The example displays the following output:
//       1234.96 --> 1234.96
//       -1234.96 --> -1234.96

Comentarios

La representación binaria de un Decimal número consta de un signo de 1 bits, un número entero de 96 bits y un factor de escala utilizado para dividir el número entero y especificar qué parte de él es una fracción decimal. El factor de escalado es implícitamente el número 10, elevado a un exponente comprendido entre 0 y 28.

El valor devuelto es una matriz de cuatro elementos de enteros con signo de 32 bits.

Los elementos primero, segundo y tercero de la matriz devuelta contienen los 32 bits bajos, intermedios y altos del número entero de 96 bits.

El cuarto elemento de la matriz devuelta contiene el factor de escala y el signo. Consta de las siguientes partes:

Los bits de 0 a 15, la palabra inferior, no se usan y deben ser cero.

Los bits de 16 a 23 deben contener un exponente entre 0 y 28, que indica la potencia de 10 para dividir el número entero.

Los bits de 24 a 30 no se usan y deben ser cero.

El bit 31 contiene el signo: 0 positivo medio y 1 significa negativo.

Tenga en cuenta que la representación de bits diferencia entre cero negativo y positivo. Estos valores se tratan como iguales en todas las operaciones.

Consulte también

• Decimal

GetBits(Decimal, Span<Int32>)

Source:

Decimal.cs

Convierte el valor de una instancia de Decimal especificada en la representación binaria equivalente.

C#

public static int GetBits(decimal d, Span<int> destination);

Parámetros

d

Decimal

Valor que se va a convertir.

destination

Span<Int32>

Intervalo en el que se va a almacenar la representación binaria de cuatro enteros.

Devoluciones

Int32

4, que es el número de enteros en la representación binaria.

Excepciones

ArgumentException

El intervalo de destino no era lo suficientemente largo como para almacenar la representación binaria.