# Decimal.GetBits Method

.NET Framework 1.1

Converts the value of a specified instance of Decimal to its equivalent binary representation.

```[Visual Basic]
Public Shared Function GetBits( _
ByVal d As Decimal _
) As Integer()
[C#]
public static int[] GetBits(
decimal d
);
[C++]
public: static int GetBits(
Decimal d
)  __gc[];
[JScript]
public static function GetBits(
d : Decimal
) : int[];```

d
A Decimal value.

#### Return Value

A 32-bit signed integer array with four elements that contain the binary representation of d.

#### Remarks

The binary representation of a Decimal number consists of a 1-bit sign, a 96-bit integer number, and a scaling factor used to divide the integer number and specify what portion of it is a decimal fraction. The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28.

The return value is a four-element long array of 32-bit signed integers.

The first, second, and third elements of the returned array contain the low, middle, and high 32 bits of the 96-bit integer number.

The fourth element of the returned array contains the scale factor and sign. It consists of the following parts:

Bits 0 to 15, the lower word, are unused and must be zero.

Bits 16 to 23 must contain an exponent between 0 and 28, that indicates the power of 10 to divide the integer number.

Bits 24 to 30 are unused and must be zero.

Bit 31 contains the sign; 0 meaning positive, and 1 meaning negative.

Note that the bit representation differentiates between negative and positive zero. These values are treated as being equal in all operations.

#### Example

[Visual Basic, C#, C++] The following code example uses the GetBits method to convert several Decimal values to their equivalent binary representations.

```[Visual Basic]
' Example of the Decimal.GetBits method.
Imports System
Imports Microsoft.VisualBasic

Module DecimalGetBitsDemo

Const dataFmt As String = _
"{0,31}  {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}"

' Display the Decimal.GetBits argument and the result array.
Sub ShowDecimalGetBits( Argument As Decimal )

Dim Bits As Integer( ) = Decimal.GetBits( Argument )

Console.WriteLine( dataFmt, Argument, _
Bits( 3 ), Bits( 2 ), Bits( 1 ), Bits( 0 ) )
End Sub

Sub Main( )
Console.WriteLine( "This example of the " & _
"Decimal.GetBits( Decimal ) method " & vbCrLf & _
"generates the following output. It displays " & _
"the argument " & vbCrLf & "as a Decimal and the result " & _
"array in hexadecimal." & vbCrLf )
Console.WriteLine( dataFmt, "Argument", "Bits(3)", _
"Bits(2)", "Bits(1)", "Bits(0)" )
Console.WriteLine( dataFmt, "--------", "-------", _
"-------", "-------", "-------" )

' Get internal bits for Decimal objects.
ShowDecimalGetBits( 1D )
ShowDecimalGetBits( 100000000000000D )
ShowDecimalGetBits( 10000000000000000000000000000D )
ShowDecimalGetBits( _
Decimal.Parse( "100000000000000.00000000000000" ) )
ShowDecimalGetBits( _
Decimal.Parse( "1.0000000000000000000000000000" ) )
ShowDecimalGetBits( 123456789D )
ShowDecimalGetBits( 0.123456789D )
ShowDecimalGetBits( 0.000000000123456789D )
ShowDecimalGetBits( 0.000000000000000000123456789D )
ShowDecimalGetBits( 4294967295D )
ShowDecimalGetBits( 18446744073709551615D )
ShowDecimalGetBits( Decimal.MaxValue )
ShowDecimalGetBits( Decimal.MinValue )
ShowDecimalGetBits( -7.9228162514264337593543950335D )
End Sub
End Module

' 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

[C#]
// Example of the decimal.GetBits method.
using System;

class DecimalGetBitsDemo
{
const string dataFmt = "{0,31}  {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}";

// Display the decimal.GetBits argument and the result array.
public static void ShowDecimalGetBits( decimal Argument )
{
int[ ] Bits = decimal.GetBits( Argument );

Console.WriteLine( dataFmt, Argument,
Bits[ 3 ], Bits[ 2 ], Bits[ 1 ], Bits[ 0 ] );
}

public static void Main( )
{
Console.WriteLine( "This example of the " +
"decimal.GetBits( decimal ) method \ngenerates the " +
"following output. It displays the argument \nas a " +
"decimal and the result array in hexadecimal.\n" );
Console.WriteLine( dataFmt, "Argument", "Bits[3]",
"Bits[2]", "Bits[1]", "Bits[0]" );
Console.WriteLine( dataFmt, "--------", "-------",
"-------", "-------", "-------" );

// Get internal bits for decimal objects.
ShowDecimalGetBits( 1M );
ShowDecimalGetBits( 100000000000000M );
ShowDecimalGetBits( 10000000000000000000000000000M );
ShowDecimalGetBits( 100000000000000.00000000000000M );
ShowDecimalGetBits( 1.0000000000000000000000000000M );
ShowDecimalGetBits( 123456789M );
ShowDecimalGetBits( 0.123456789M );
ShowDecimalGetBits( 0.000000000123456789M );
ShowDecimalGetBits( 0.000000000000000000123456789M );
ShowDecimalGetBits( 4294967295M );
ShowDecimalGetBits( 18446744073709551615M );
ShowDecimalGetBits( decimal.MaxValue );
ShowDecimalGetBits( decimal.MinValue );
ShowDecimalGetBits( -7.9228162514264337593543950335M );
}
}

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

[C++]
// Example of the Decimal::GetBits method.
#using <mscorlib.dll>
using namespace System;

const __wchar_t* dataFmt =
L"{0,31}  {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}";

// Display the Decimal::GetBits argument and the result array.
void ShowDecimalGetBits( Decimal Argument )
{
int Bits __gc [ ] = Decimal::GetBits( Argument );

Console::WriteLine( new String( dataFmt ), __box( Argument ),
__box( Bits[ 3 ] ), __box( Bits[ 2 ] ),
__box( Bits[ 1 ] ), __box( Bits[ 0 ] ) );
}

void main( )
{
Console::WriteLine( S"This example of the "
S"Decimal::GetBits( Decimal ) method \ngenerates the "
S"following output. It displays the argument \nas a "
S"Decimal and the result array in hexadecimal.\n" );
Console::WriteLine( new String( dataFmt ), S"Argument",
S"Bits[3]", S"Bits[2]", S"Bits[1]", S"Bits[0]" );
Console::WriteLine( new String( dataFmt ), S"--------",
S"-------", S"-------", S"-------", S"-------" );

// Get internal bits for Decimal objects.
ShowDecimalGetBits( Decimal::Parse( S"1" ) );
ShowDecimalGetBits( Decimal::Parse( S"100000000000000" ) );
ShowDecimalGetBits(
Decimal::Parse( S"10000000000000000000000000000" ) );
ShowDecimalGetBits(
Decimal::Parse( S"100000000000000.00000000000000" ) );
ShowDecimalGetBits(
Decimal::Parse( S"1.0000000000000000000000000000" ) );
ShowDecimalGetBits( Decimal::Parse( S"123456789" ) );
ShowDecimalGetBits( Decimal::Parse( S"0.123456789" ) );
ShowDecimalGetBits( Decimal::Parse( S"0.000000000123456789" ) );
ShowDecimalGetBits(
Decimal::Parse( S"0.000000000000000000123456789" ) );
ShowDecimalGetBits( Decimal::Parse( S"4294967295" ) );
ShowDecimalGetBits( Decimal::Parse( S"18446744073709551615" ) );
ShowDecimalGetBits( Decimal::MaxValue );
ShowDecimalGetBits( Decimal::MinValue );
ShowDecimalGetBits(
Decimal::Parse( S"-7.9228162514264337593543950335" ) );
}

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

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button in the upper-left corner of the page.

#### Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework, Common Language Infrastructure (CLI) Standard