Export (0) Print
Expand All
1 out of 2 rated this helpful - Rate this topic

Decimal.GetBits Method

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

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)
public static int[] GetBits(
	decimal d
)

Parameters

d
Type: System.Decimal

The value to convert.

Return Value

Type: System.Int32[]
A 32-bit signed integer array with four elements that contain the binary representation of d.

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 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, which 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 mean positive, and 1 means negative.

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

The following example uses the GetBits method to convert several Decimal values to their equivalent binary representations. It then displays the decimal values and the hexadecimal value of the elements in the array returned by the GetBits method.

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

The following example uses the GetBits method to retrieve the component parts of an array. It then uses this array in the call to the Decimal(Int32, Int32, Int32, Boolean, Byte) constructor to instantiate a new Decimal value.

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

.NET Framework

Supported in: 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

.NET for Windows Store apps

Supported in: Windows 8

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.