Decimal Constructor (Int32[])

# Decimal Constructor (Int32[])

[ This article is for Windows Phone 8 developers. If you’re developing for Windows 10, see the latest documentation. ]

Initializes a new instance of Decimal to a decimal value represented in binary and contained in a specified array.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

## Syntax

```public Decimal(
int[] bits
)
```

#### Parameters

bits
Type: System.Int32 []
An array of 32-bit signed integers containing a representation of a decimal value.

## Exceptions

ExceptionCondition
ArgumentNullException

bits is null.

ArgumentException

The length of the bits is not 4.

-or-

The representation of the decimal value in bits is not valid.

## 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.

bits is a four-element long array of 32-bit signed integers.

bits [0], bits [1], and bits [2] contain the low, middle, and high 32 bits of the 96-bit integer number.

bits [3] contains the scale factor and sign, and consists of 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 meaning positive, and 1 meaning negative.

A numeric value might have several possible binary representations; all are equally valid and numerically equivalent. Note that the bit representation differentiates between negative and positive zero. These values are treated as being equal in all operations.

## Examples

The following code example creates several Decimal numbers using the constructor overload that initializes a Decimal structure with an array of four Int32 values.

```
// Example of the decimal( int[ ] ) constructor.
using System;

class Example
{
// Get the exception type name; remove the namespace prefix.
public static string GetExceptionType(Exception ex)
{
string exceptionType = ex.GetType().ToString();
return exceptionType.Substring(
exceptionType.LastIndexOf('.') + 1);
}

// Create a decimal object and display its value.
public static void CreateDecimal(System.Windows.Controls.TextBlock outputBlock, int[] bits)
{
// Format the constructor for display.
string ctor = String.Format(
"decimal( {{ 0x{0:X}", bits[0]);
string valOrExc;

for (int index = 1; index < bits.Length; index++)
ctor += String.Format(", 0x{0:X}", bits[index]);
ctor += " } )";

try
{
// Construct the decimal value.
decimal decimalNum = new decimal(bits);

// Format the decimal value for display.
valOrExc = decimalNum.ToString();
}
catch (Exception ex)
{
// Save the exception type if an exception was thrown.
valOrExc = GetExceptionType(ex);
}

// Display the constructor and decimal value or exception.
int ctorLen = 76 - valOrExc.Length;

// Display the data on one line if it will fit.
if (ctorLen > ctor.Length)
outputBlock.Text += String.Format("{0}{1}", ctor.PadRight(ctorLen),
valOrExc) + "\n";

// Otherwise, display the data on two lines.
else
{
outputBlock.Text += String.Format("{0}", ctor) + "\n";
outputBlock.Text += String.Format("{0,76}", valOrExc) + "\n";
}
}

public static void Demo(System.Windows.Controls.TextBlock outputBlock)
{
outputBlock.Text += String.Format(
"This example of the decimal( int[ ] ) constructor " +
"\ngenerates the following output.\n") + "\n";
outputBlock.Text += String.Format("{0,-38}{1,38}", "Constructor",
"Value or Exception") + "\n";
outputBlock.Text += String.Format("{0,-38}{1,38}", "-----------",
"------------------") + "\n";

// Construct decimal objects from integer arrays.
CreateDecimal(outputBlock, new int[] { 0, 0, 0, 0 });
CreateDecimal(outputBlock, new int[] { 0, 0, 0 });
CreateDecimal(outputBlock, new int[] { 0, 0, 0, 0, 0 });
CreateDecimal(outputBlock, new int[] { 1000000000, 0, 0, 0 });
CreateDecimal(outputBlock, new int[] { 0, 1000000000, 0, 0 });
CreateDecimal(outputBlock, new int[] { 0, 0, 1000000000, 0 });
CreateDecimal(outputBlock, new int[] { 0, 0, 0, 1000000000 });
CreateDecimal(outputBlock, new int[] { -1, -1, -1, 0 });
CreateDecimal(outputBlock, new int[] { -1, -1, -1, unchecked((int)0x80000000) });
CreateDecimal(outputBlock, new int[] { -1, 0, 0, 0x100000 });
CreateDecimal(outputBlock, new int[] { -1, 0, 0, 0x1C0000 });
CreateDecimal(outputBlock, new int[] { -1, 0, 0, 0x1D0000 });
CreateDecimal(outputBlock, new int[] { -1, 0, 0, 0x1C0001 });
CreateDecimal(outputBlock, new int[] { 0xF0000, 0xF0000, 0xF0000, 0xF0000 });
}
}

/*
This example of the decimal( int[ ] ) constructor
generates the following output.

Constructor                                               Value or Exception
-----------                                               ------------------
decimal( { 0x0, 0x0, 0x0, 0x0 } )                                          0
decimal( { 0x0, 0x0, 0x0 } )                               ArgumentException
decimal( { 0x0, 0x0, 0x0, 0x0, 0x0 } )                     ArgumentException
decimal( { 0x3B9ACA00, 0x0, 0x0, 0x0 } )                          1000000000
decimal( { 0x0, 0x3B9ACA00, 0x0, 0x0 } )                 4294967296000000000
decimal( { 0x0, 0x0, 0x3B9ACA00, 0x0 } )       18446744073709551616000000000
decimal( { 0x0, 0x0, 0x0, 0x3B9ACA00 } )                   ArgumentException
decimal( { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0 } )
79228162514264337593543950335
decimal( { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x80000000 } )
-79228162514264337593543950335
decimal( { 0xFFFFFFFF, 0x0, 0x0, 0x100000 } )             0.0000004294967295
decimal( { 0xFFFFFFFF, 0x0, 0x0, 0x1C0000 } ) 0.0000000000000000004294967295
decimal( { 0xFFFFFFFF, 0x0, 0x0, 0x1D0000 } )              ArgumentException
decimal( { 0xFFFFFFFF, 0x0, 0x0, 0x1C0001 } )              ArgumentException
decimal( { 0xF0000, 0xF0000, 0xF0000, 0xF0000 } )
18133887298.441562272235520
*/

```

## Version Information

#### Windows Phone OS

Supported in: 8.1, 8.0, 7.1, 7.0

Windows Phone