Decimal Constructor (array<Int32[])

Microsoft Silverlight will reach end of support after October 2021. Learn more.

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

``````'Declaration
Public Sub New ( _
bits As Integer() _
)
``````
``````public Decimal(
int[] bits
)
``````

Parameters

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

Exceptions

Exception Condition
ArgumentNullException

bits is nulla null reference (Nothing in Visual Basic).

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( Integer( ) ) constructor.

Module Example

' Get the exception type name; remove the namespace prefix.
Function GetExceptionType(ByVal ex As Exception) As String

Dim exceptionType As String = ex.GetType().ToString()
Return exceptionType.Substring( _
exceptionType.LastIndexOf("."c) + 1)
End Function

' Create a Decimal object and display its value.
Sub CreateDecimal(ByVal outputBlock As System.Windows.Controls.TextBlock, ByVal bits() As Integer)

' Format and save the constructor.
Dim ctor As String = String.Format("Decimal( {{ &H{0:X}", bits(0))
Dim valOrExc As String
Dim index As Integer
For index = 1 To bits.Length - 1
ctor &= String.Format(", &H{0:X}", bits(index))
Next index
ctor &= " } )"

' Construct the Decimal value.
Try
Dim decimalNum As New Decimal(bits)

' Format the Decimal value for display.
valOrExc = decimalNum.ToString()

' Save the exception type if an exception was thrown.
Catch ex As Exception
valOrExc = GetExceptionType(ex)
End Try

' Display the constructor and Decimal value or exception.
Dim ctorLen As Integer = 76 - valOrExc.Length
If ctorLen > ctor.Length Then

' Display the data on one line if it will fit.
outputBlock.Text &= String.Format("{0}{1}", ctor.PadRight(ctorLen) & vbCrLf, _
valOrExc)

' Otherwise, display the data on two lines.
Else
outputBlock.Text &= String.Format("{0}", ctor) & vbCrLf
outputBlock.Text &= String.Format("{0,76}", valOrExc) & vbCrLf
End If
End Sub

Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

outputBlock.Text &= "This example of the " & _
"Decimal( Integer( ) ) constructor " & _
vbCrLf & "generates the following output." & vbCrLf & vbCrLf
outputBlock.Text &= String.Format("{0,-38}{1,38}", "Constructor", _
"Value or Exception") & vbCrLf
outputBlock.Text &= String.Format("{0,-38}{1,38}", "-----------", _
"------------------") & vbCrLf

' Construct Decimal objects from Integer arrays.
CreateDecimal(outputBlock, New Integer() {0, 0, 0, 0})
CreateDecimal(outputBlock, New Integer() {0, 0, 0})
CreateDecimal(outputBlock, New Integer() {0, 0, 0, 0, 0})
CreateDecimal(outputBlock, New Integer() {1000000000, 0, 0, 0})
CreateDecimal(outputBlock, New Integer() {0, 1000000000, 0, 0})
CreateDecimal(outputBlock, New Integer() {0, 0, 1000000000, 0})
CreateDecimal(outputBlock, New Integer() {0, 0, 0, 1000000000})
CreateDecimal(outputBlock, New Integer() {-1, -1, -1, 0})
CreateDecimal(outputBlock, New Integer() {-1, -1, -1, &H80000000})
CreateDecimal(outputBlock, New Integer() {-1, 0, 0, &H100000})
CreateDecimal(outputBlock, New Integer() {-1, 0, 0, &H1C0000})
CreateDecimal(outputBlock, New Integer() {-1, 0, 0, &H1D0000})
CreateDecimal(outputBlock, New Integer() {-1, 0, 0, &H1C0001})
CreateDecimal(outputBlock, New Integer() _
{&HF0000, &HF0000, &HF0000, &HF0000})
End Sub
End Module

' This example of the Decimal( Integer( ) ) constructor
' generates the following output.
'
' Constructor                                               Value or Exception
' -----------                                               ------------------
' Decimal( { &H0, &H0, &H0, &H0 } )                                          0
' Decimal( { &H0, &H0, &H0 } )                               ArgumentException
' Decimal( { &H0, &H0, &H0, &H0, &H0 } )                     ArgumentException
' Decimal( { &H3B9ACA00, &H0, &H0, &H0 } )                          1000000000
' Decimal( { &H0, &H3B9ACA00, &H0, &H0 } )                 4294967296000000000
' Decimal( { &H0, &H0, &H3B9ACA00, &H0 } )       18446744073709551616000000000
' Decimal( { &H0, &H0, &H0, &H3B9ACA00 } )                   ArgumentException
' Decimal( { &HFFFFFFFF, &HFFFFFFFF, &HFFFFFFFF, &H0 } )
'                                                79228162514264337593543950335
' Decimal( { &HFFFFFFFF, &HFFFFFFFF, &HFFFFFFFF, &H80000000 } )
'                                               -79228162514264337593543950335
' Decimal( { &HFFFFFFFF, &H0, &H0, &H100000 } )             0.0000004294967295
' Decimal( { &HFFFFFFFF, &H0, &H0, &H1C0000 } ) 0.0000000000000000004294967295
' Decimal( { &HFFFFFFFF, &H0, &H0, &H1D0000 } )              ArgumentException
' Decimal( { &HFFFFFFFF, &H0, &H0, &H1C0001 } )              ArgumentException
' Decimal( { &HF0000, &HF0000, &HF0000, &HF0000 } )
'                                                  18133887298.441562272235520
``````
``````// 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
*/
``````

Version Information

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

Platforms

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