Decimal.GetBits Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Přetížení

GetBits(Decimal)	Převede hodnotu zadané instance Decimal na její ekvivalentní binární reprezentaci.
GetBits(Decimal, Span<Int32>)	Převede hodnotu zadané instance Decimal na její ekvivalentní binární reprezentaci.

GetBits(Decimal)

Zdroj:: Decimal.cs

Zdroj:: Decimal.cs

Zdroj:: Decimal.cs

Převede hodnotu zadané instance Decimal na její ekvivalentní binární reprezentaci.

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()

Parametry

d: Decimal

Hodnota, kterou chcete převést.

Návraty

Int32[]

32bitové celočíselné pole se čtyřmi prvky, které obsahují binární reprezentaci .d

Příklady

Následující příklad používá metodu k převodu GetBits několika Decimal hodnot na jejich ekvivalentní binární reprezentace. Pak zobrazí desetinné hodnoty a šestnáctkovou hodnotu prvků v poli vrácených metodou GetBits .

using namespace System;

int main()
{
   // Define an array of Decimal values.
   array<Decimal>^ values = gcnew array<Decimal>  { Decimal::One, 
                                  Decimal::Parse("100000000000000"), 
                                  Decimal::Parse("10000000000000000000000000000"),
                                  Decimal::Parse("100000000000000.00000000000000"), 
                                  Decimal::Parse("1.0000000000000000000000000000"),
                                  Decimal::Parse("123456789"), 
                                  Decimal::Parse("0.123456789"), 
                                  Decimal::Parse("0.000000000123456789"), 
                                  Decimal::Parse("0.000000000000000000123456789"), 
                                  Decimal::Parse("4294967295.0"), 
                                  Decimal::Parse("18446744073709551615.0"), 
                                  Decimal::MaxValue, Decimal::MinValue, 
                                  Decimal::Parse("-7.9228162514264337593543950335") }; 

   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}", 
                      "--------", "-------", "-------", "-------", "-------" );
   
   for each (Decimal value in values)
   {
      array<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] );
   }
}

/*
This example of the Decimal::GetBits( Decimal ) method
generates the following output. It displays the argument
as a Decimal and the result array in hexadecimal.

                       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
*/

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

Následující příklad používá metodu GetBits k načtení komponent částí pole. Potom použije toto pole ve volání konstruktoru Decimal(Int32, Int32, Int32, Boolean, Byte) k vytvoření instance nové Decimal hodnoty.

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

Poznámky

Binární reprezentace čísla se skládá z 1bitového Decimal znaménka, 96bitového celočíselného čísla a faktoru škálování, který se používá k dělení celočíselného čísla a určení, jaká část je desetinnou desetinnou zlomkem. Faktor škálování je implicitně číslo 10, které je zvýšeno na exponent v rozsahu od 0 do 28.

Návratová hodnota je pole se čtyřmi prvky 32bitových celých signedch.

První, druhý a třetí prvek vráceného pole obsahují nízké, střední a vysoké 32 bitů 96bitového celočíselného čísla.

Čtvrtý prvek vráceného pole obsahuje faktor škálování a znaménko. Skládá se z následujících částí:

Bity 0 až 15 , dolní slovo, se nepoužívají a musí být nulové.

Bity 16 až 23 musí obsahovat exponent mezi 0 a 28, což označuje mocninu 10 pro dělení celého čísla.

Bity 24 až 30 se nepoužívají a musí být nulové.

Bit 31 obsahuje znaménko: 0 střední pozitivní a 1 znamená negativní.

Všimněte si, že bitová reprezentace rozlišuje mezi zápornou a kladnou nulou. Tyto hodnoty jsou ve všech operacích považovány za stejné.

Viz také

Decimal

Platí pro

GetBits(Decimal, Span<Int32>)

Zdroj:: Decimal.cs

Zdroj:: Decimal.cs

Zdroj:: Decimal.cs

Převede hodnotu zadané instance Decimal na její ekvivalentní binární reprezentaci.

public:
 static int GetBits(System::Decimal d, Span<int> destination);

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

static member GetBits : decimal * Span<int> -> int

Public Shared Function GetBits (d As Decimal, destination As Span(Of Integer)) As Integer

Parametry

d: Decimal

Hodnota, kterou chcete převést.

destination: Span<Int32>

Rozsah, do kterého se má uložit binární reprezentace se čtyřmi celými čísly.

Návraty

Int32

4, což je počet celých čísel v binární reprezentaci.

Výjimky

ArgumentException

Cílový rozsah nebyl dostatečně dlouhý na uložení binární reprezentace.

Platí pro

Sdílet prostřednictvím

Decimal.GetBits Metoda

Definice

Přetížení

GetBits(Decimal)

Parametry

Návraty

Příklady

Poznámky

Viz také

Platí pro

GetBits(Decimal, Span<Int32>)

Parametry

Návraty

Výjimky

Platí pro

Další materiály