Decimal.GetBits(Decimal) Método
Definição
Importante
Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.
Converte o valor de uma instância especificada de Decimal para a sua representação binária equivalente.
public:
static cli::array <int> ^ GetBits(System::Decimal d);public static int[] GetBits(decimal d);static member GetBits : decimal -> int[]Public Shared Function GetBits (d As Decimal) As Integer()Parâmetros
- d
- Decimal
O valor a converter.
Devoluções
Um array inteiro assinado de 32 bits com quatro elementos que contêm a representação binária de d.
Exemplos
O exemplo seguinte utiliza o GetBits método para converter vários Decimal valores para as suas representações binárias equivalentes. Depois, apresenta os valores decimais e o valor hexadecimal dos elementos do array devolvidos pelo GetBits método.
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
open System
// Define an list of Decimal values.
let values =
[ 1M; 100000000000000M; 10000000000000000000000000000M
100000000000000.00000000000000M; 1.0000000000000000000000000000M
123456789M; 0.123456789M; 0.000000000123456789M
0.000000000000000000123456789M; 4294967295M
18446744073709551615M; Decimal.MaxValue
Decimal.MinValue; -7.9228162514264337593543950335M ]
printfn $"""{"Argument",31} {"Bits[3]",10:X8}{"Bits[2]",10:X8}{"Bits[1]",10:X8}{"Bits[0]",10:X8}"""
printfn $"""{"--------",31} {"-------",10:X8}{"-------",10:X8}{"-------",10:X8}{"-------",10:X8}"""
// Iterate each element and display its binary representation
for value in values do
let bits = Decimal.GetBits value
printfn $"{value,31} {bits[3],10:X8}{bits[2],10:X8}{bits[1],10:X8}{bits[0],10:X8}"
// 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
Module Example
Public Sub Main()
' Define an array of decimal values.
Dim values() As Decimal = { 1d, 100000000000000d,
10000000000000000000000000000d,
100000000000000.00000000000000d,
1.0000000000000000000000000000d,
123456789d, 0.123456789d,
0.000000000123456789d,
0.000000000000000000123456789d,
4294967295d,
18446744073709551615d,
Decimal.MaxValue, Decimal.MinValue,
-7.9228162514264337593543950335d }
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
For Each value In values
Dim bits() As Integer = 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))
Next
End Sub
End Module
' 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
O exemplo seguinte utiliza o GetBits método para recuperar as partes componentes de um array. Depois, utiliza este array na chamada ao Decimal(Int32, Int32, Int32, Boolean, Byte) construtor para instanciar um novo Decimal valor.
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
open System
let values = [ 1234.96m; -1234.96m ]
for value in values do
let parts = Decimal.GetBits value
let sign = (parts[3] &&& 0x80000000) <> 0
let scale = (parts[3] >>> 16) &&& 0x7F |> byte
let newValue = Decimal(parts[0], parts[1], parts[2], sign, scale)
printfn $"{value} --> {newValue}"
// The example displays the following output:
// 1234.96 --> 1234.96
// -1234.96 --> -1234.96
Module Example
Public Sub Main()
Dim values() As Decimal = { 1234.96d, -1234.96d }
For Each value In values
Dim parts() = Decimal.GetBits(value)
Dim sign As Boolean = (parts(3) And &h80000000) <> 0
Dim scale As Byte = CByte((parts(3) >> 16) And &H7F)
Dim newValue As New Decimal(parts(0), parts(1), parts(2), sign, scale)
Console.WriteLine("{0} --> {1}", value, newValue)
Next
End Sub
End Module
' The example displays the following output:
' 1234.96 --> 1234.96
' -1234.96 --> -1234.96
Observações
A representação binária de um Decimal número consiste num sinal de 1 bit, um número inteiro de 96 bits e um fator de escala usado para dividir o número inteiro e especificar que parte dele é uma fração decimal. O fator de escala é implicitamente o número 10, elevado para um expoente que varia de 0 a 28.
O valor de retorno é um array de quatro elementos de inteiros assinados de 32 bits.
O primeiro, segundo e terceiro elementos do array devolvido contêm os 32 bits baixo, médio e alto do número inteiro de 96 bits.
O quarto elemento do array devolvido contém o fator de escala e o sinal. Consiste nas seguintes partes:
Os bits 0 a 15, a palavra inferior, são não usados e devem ser zero.
Os bits 16 a 23 devem conter um expoente entre 0 e 28, o que indica a potência de 10 para dividir o número inteiro.
Os bits 24 a 30 estão por usar e devem ser zero.
O bit 31 contém o sinal: 0 significa positivo, e 1 significa negativo.
Note que a representação em bits diferencia entre zero negativo e zero positivo. Estes valores são tratados como sendo iguais em todas as operações.