This topic has not yet been rated - Rate this topic

# Decimal Constructor (Int32[])

Silverlight

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)
```public Decimal(
int[] bits
)
```

#### Parameters

bits
Type: System.Int32[]
An array of 32-bit signed integers containing a representation of a decimal value.
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.

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.

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

```

#### Silverlight

Supported in: 5, 4, 3

#### Silverlight for Windows Phone

Supported in: Windows Phone OS 7.1, Windows Phone OS 7.0

#### XNA Framework

Supported in: Xbox 360, Windows Phone OS 7.0

For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.