Decimal.GetBits Yöntem

Başvuru

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Aşırı Yüklemeler

GetBits(Decimal)	Belirtilen Decimal örneğinin değerini eşdeğer ikili gösterimine dönüştürür.
GetBits(Decimal, Span<Int32>)	Belirtilen Decimal örneğinin değerini eşdeğer ikili gösterimine dönüştürür.

GetBits(Decimal)

Kaynak:: Decimal.cs

Kaynak:: Decimal.cs

Kaynak:: Decimal.cs

Belirtilen Decimal örneğinin değerini eşdeğer ikili gösterimine dönüştürür.

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

Parametreler

d: Decimal

Dönüştürülecek değer.

Döndürülenler

Int32[]

öğesinin ikili gösterimini diçeren dört öğeye sahip 32 bit imzalı tamsayı dizisi.

Örnekler

Aşağıdaki örnek, GetBits çeşitli Decimal değerleri eşdeğer ikili gösterimlerine dönüştürmek için yöntemini kullanır. Ardından, yöntemi tarafından GetBits döndürülen dizideki öğelerin ondalık değerlerini ve onaltılık değerini görüntüler.

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

Aşağıdaki örnek, bir dizinin bileşen parçalarını almak için yöntemini kullanır GetBits . Daha sonra yeni Decimal bir değer örneği oluşturmak için oluşturucu çağrısında Decimal(Int32, Int32, Int32, Boolean, Byte) bu diziyi kullanır.

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

Açıklamalar

Bir Decimal sayının ikili gösterimi 1 bit işaretinden, 96 bitlik bir tamsayı sayısından ve tamsayıyı bölmek ve hangi bölümünün ondalık kesir olduğunu belirtmek için kullanılan ölçeklendirme faktöründen oluşur. Ölçeklendirme faktörü örtük olarak 10 sayısıdır ve 0 ile 28 arasında bir üs oluşturur.

Dönüş değeri, 32 bit işaretli tamsayılardan oluşan dört öğeli bir dizidir.

Döndürülen dizinin birinci, ikinci ve üçüncü öğeleri, 96 bit tamsayı sayısının düşük, orta ve yüksek 32 bitlerini içerir.

Döndürülen dizinin dördüncü öğesi ölçek faktörünü ve işaretini içerir. Aşağıdaki bölümlerden oluşur:

Küçük sözcük olan 0 ile 15 arasında bitler kullanılmaz ve sıfır olmalıdır.

16 ile 23 arasındaki bitler, tamsayıyı bölmek için 10'un gücünü gösteren 0 ile 28 arasında bir üs içermelidir.

24 - 30 bitleri kullanılmaz ve sıfır olmalıdır.

Bit 31 işareti içerir: 0 ortalama pozitif ve 1 negatif anlamına gelir.

Bit gösteriminin negatif ve pozitif sıfır arasında ayrım yaptığı unutmayın. Bu değerler tüm işlemlerde eşit olarak değerlendirilir.

Ayrıca bkz.

Decimal

Şunlara uygulanır

GetBits(Decimal, Span<Int32>)

Kaynak:: Decimal.cs

Kaynak:: Decimal.cs

Kaynak:: Decimal.cs

Belirtilen Decimal örneğinin değerini eşdeğer ikili gösterimine dönüştürür.

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

Parametreler

d: Decimal

Dönüştürülecek değer.

destination: Span<Int32>

Dört tamsayı ikili gösteriminin depolandığı yayılma alanı.

Döndürülenler

Int32

4, ikili gösterimdeki tamsayıların sayısıdır.

Özel durumlar

ArgumentException

Hedef yayılma alanı, ikili gösterimi depolamak için yeterince uzun değildi.

Şunlara uygulanır

Decimal.GetBits Yöntem

Tanım

Aşırı Yüklemeler

GetBits(Decimal)

Parametreler

Döndürülenler

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

GetBits(Decimal, Span<Int32>)

Parametreler

Döndürülenler

Özel durumlar

Şunlara uygulanır

Geri Bildirim

Ek kaynaklar