Decimal.GetBits Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Überlädt

GetBits(Decimal)	Konvertiert den Wert einer angegebenen Instanz von Decimal in die entsprechende binäre Darstellung.
GetBits(Decimal, Span<Int32>)	Konvertiert den Wert einer angegebenen Instanz von Decimal in die entsprechende binäre Darstellung.

GetBits(Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Konvertiert den Wert einer angegebenen Instanz von Decimal in die entsprechende binäre Darstellung.

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

Parameter

d: Decimal

Der zu konvertierende Wert.

Gibt zurück

Int32[]

Ein Array von 32-Bit-Ganzzahlen mit Vorzeichen mit vier Elementen, die die binäre Darstellung von d enthalten.

Beispiele

Im folgenden Beispiel wird die GetBits -Methode verwendet, um mehrere Decimal Werte in die entsprechenden binären Darstellungen zu konvertieren. Anschließend werden die Dezimalwerte und der Hexadezimalwert der Elemente in dem von der GetBits -Methode zurückgegebenen Array angezeigt.

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

Im folgenden Beispiel wird die GetBits -Methode verwendet, um die Komponententeile eines Arrays abzurufen. Anschließend wird dieses Array im Aufruf des Decimal(Int32, Int32, Int32, Boolean, Byte) Konstruktors verwendet, um einen neuen Decimal Wert zu instanziieren.

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

Hinweise

Die binäre Darstellung einer Decimal Zahl besteht aus einem 1-Bit-Zeichen, einer ganzzahligen Zahl von 96 Bit und einem Skalierungsfaktor, der verwendet wird, um die ganzzahlige Zahl zu dividieren und anzugeben, welcher Teil davon ein Dezimalbruch ist. Der Skalierungsfaktor ist implizit die Zahl 10, die auf einen Exponenten von 0 bis 28 erhöht wird.

Der Rückgabewert ist ein Array mit vier Elementen mit 32-Bit-Ganzzahlen mit Vorzeichen.

Das erste, zweite und dritte Element des zurückgegebenen Arrays enthalten die niedrigen, mittleren und hohen 32 Bits der ganzzahligen 96-Bit-Zahl.

Das vierte Element des zurückgegebenen Arrays enthält den Skalierungsfaktor und das Vorzeichen. Es besteht aus den folgenden Teilen:

Die Bits 0 bis 15, das untere Wort, sind nicht verwendet und müssen null sein.

Die Bits 16 bis 23 müssen einen Exponenten zwischen 0 und 28 enthalten, der die Leistung von 10 angibt, um die ganze Zahl zu teilen.

Die Bits 24 bis 30 werden nicht verwendet und müssen 0 sein.

Bit 31 enthält das Zeichen: 0 mittel positiv und 1 bedeutet negativ.

Beachten Sie, dass die Bitdarstellung zwischen negativer und positiver Null unterscheidet. Diese Werte werden in allen Vorgängen als gleich behandelt.

Weitere Informationen

Decimal

Gilt für:

GetBits(Decimal, Span<Int32>)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Konvertiert den Wert einer angegebenen Instanz von Decimal in die entsprechende binäre Darstellung.

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

Parameter

d: Decimal

Der zu konvertierende Wert.

destination: Span<Int32>

Die Spanne, in der die Binärdarstellung mit vier ganzen Zahlen gespeichert werden soll.

Gibt zurück

Int32

4, wobei es sich um die Anzahl von ganzen Zahlen in der Binärdarstellung handelt.

Ausnahmen

ArgumentException

Die Zielspanne war nicht lang genug, um die Binärdarstellung zu speichern.

Gilt für:

Teilen über

Decimal.GetBits Methode

Definition

Überlädt

GetBits(Decimal)

Parameter

Gibt zurück

Beispiele

Hinweise

Weitere Informationen

Gilt für:

GetBits(Decimal, Span<Int32>)

Parameter

Gibt zurück

Ausnahmen

Gilt für:

Zusätzliche Ressourcen