# Decimal 构造函数

## 重载

 Decimal(Double) 将 Decimal 的新实例初始化为指定的双精度浮点数的值。Initializes a new instance of Decimal to the value of the specified double-precision floating-point number. Decimal(Int32) 将 Decimal 的新实例初始化为指定的 32 位有符号整数的值。Initializes a new instance of Decimal to the value of the specified 32-bit signed integer. Decimal(Int32[]) 将 Decimal 的新实例初始化为以二进制表示的、包含在指定数组中的十进制值。Initializes a new instance of Decimal to a decimal value represented in binary and contained in a specified array. Decimal(Int64) 将 Decimal 的新实例初始化为指定的 64 位有符号整数的值。Initializes a new instance of Decimal to the value of the specified 64-bit signed integer. Decimal(Single) 将 Decimal 的新实例初始化为指定的单精度浮点数的值。Initializes a new instance of Decimal to the value of the specified single-precision floating-point number. Decimal(UInt32) 将 Decimal 的新实例初始化为指定的 32 位无符号整数的值。Initializes a new instance of Decimal to the value of the specified 32-bit unsigned integer. Decimal(UInt64) 将 Decimal 的新实例初始化为指定的 64 位无符号整数的值。Initializes a new instance of Decimal to the value of the specified 64-bit unsigned integer. Decimal(Int32, Int32, Int32, Boolean, Byte) 用指定实例构成部分的参数来初始化 Decimal 的新实例。Initializes a new instance of Decimal from parameters specifying the instance's constituent parts.

## Decimal(Double)

Decimal 的新实例初始化为指定的双精度浮点数的值。Initializes a new instance of Decimal to the value of the specified double-precision floating-point number.

``````public:
Decimal(double value);``````
``public Decimal (double value);``
``new decimal : double -> decimal``
``Public Sub New (value As Double)``

value
Double

#### 异常

`value` 大于 MaxValue 或小于 MinValue`value` is greater than MaxValue or less than MinValue.

-或--or- `value`NaNPositiveInfinityNegativeInfinity`value` is NaN, PositiveInfinity, or NegativeInfinity.

### 示例

``````// Example of the Decimal( double ) constructor.
using namespace System;

// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}

// Create a Decimal object and display its value.
void CreateDecimal( double value, String^ valToStr )
{

// Format and display the constructor.
Console::Write( "{0,-34}", String::Format( "Decimal( {0} )", valToStr ) );
try
{

// Construct the Decimal value.
Decimal decimalNum = Decimal(value);

// Display the value if it was created successfully.
Console::WriteLine( "{0,31}", decimalNum );
}
catch ( Exception^ ex )
{

// Display the exception type if an exception was thrown.
Console::WriteLine( "{0,31}", GetExceptionType( ex ) );
}

}

int main()
{
Console::WriteLine( "This example of the Decimal( double ) "
"constructor \ngenerates the following output.\n" );
Console::WriteLine( "{0,-34}{1,31}", "Constructor", "Value or Exception" );
Console::WriteLine( "{0,-34}{1,31}", "-----------", "------------------" );

// Construct Decimal objects from double values.
CreateDecimal( 1.23456789E+5, "1.23456789E+5" );
CreateDecimal( 1.234567890123E+15, "1.234567890123E+15" );
CreateDecimal( 1.2345678901234567E+25, "1.2345678901234567E+25" );
CreateDecimal( 1.2345678901234567E+35, "1.2345678901234567E+35" );
CreateDecimal( 1.23456789E-5, "1.23456789E-5" );
CreateDecimal( 1.234567890123E-15, "1.234567890123E-15" );
CreateDecimal( 1.2345678901234567E-25, "1.2345678901234567E-25" );
CreateDecimal( 1.2345678901234567E-35, "1.2345678901234567E-35" );
CreateDecimal( 1.0 / 7.0, "1.0 / 7.0" );
}

/*
This example of the Decimal( double ) constructor
generates the following output.

Constructor                                    Value or Exception
-----------                                    ------------------
Decimal( 1.23456789E+5 )                               123456.789
Decimal( 1.234567890123E+15 )                    1234567890123000
Decimal( 1.2345678901234567E+25 )      12345678901234600000000000
Decimal( 1.2345678901234567E+35 )               OverflowException
Decimal( 1.23456789E-5 )                          0.0000123456789
Decimal( 1.234567890123E-15 )       0.000000000000001234567890123
Decimal( 1.2345678901234567E-25 )  0.0000000000000000000000001235
Decimal( 1.2345678901234567E-35 )                               0
Decimal( 1.0 / 7.0 )                            0.142857142857143
*/
``````
``````// Example of the decimal( double ) constructor.
using System;

class DecimalCtorDoDemo
{
// 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( double value, string valToStr )
{
// Format and display the constructor.
Console.Write( "{0,-34}",
String.Format( "decimal( {0} )", valToStr ) );

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

// Display the value if it was created successfully.
Console.WriteLine( "{0,31}", decimalNum );
}
catch( Exception ex )
{
// Display the exception type if an exception was thrown.
Console.WriteLine( "{0,31}", GetExceptionType( ex ) );
}
}

public static void Main( )
{
Console.WriteLine( "This example of the decimal( double ) " +
"constructor \ngenerates the following output.\n" );
Console.WriteLine( "{0,-34}{1,31}", "Constructor",
"Value or Exception" );
Console.WriteLine( "{0,-34}{1,31}", "-----------",
"------------------" );

// Construct decimal objects from double values.
CreateDecimal( 1.23456789E+5, "1.23456789E+5" );
CreateDecimal( 1.234567890123E+15, "1.234567890123E+15" );
CreateDecimal( 1.2345678901234567E+25,
"1.2345678901234567E+25" );
CreateDecimal( 1.2345678901234567E+35,
"1.2345678901234567E+35" );
CreateDecimal( 1.23456789E-5, "1.23456789E-5" );
CreateDecimal( 1.234567890123E-15, "1.234567890123E-15" );
CreateDecimal( 1.2345678901234567E-25,
"1.2345678901234567E-25" );
CreateDecimal( 1.2345678901234567E-35,
"1.2345678901234567E-35" );
CreateDecimal( 1.0 / 7.0, "1.0 / 7.0" );
}
}

/*
This example of the decimal( double ) constructor
generates the following output.

Constructor                                    Value or Exception
-----------                                    ------------------
decimal( 1.23456789E+5 )                               123456.789
decimal( 1.234567890123E+15 )                    1234567890123000
decimal( 1.2345678901234567E+25 )      12345678901234600000000000
decimal( 1.2345678901234567E+35 )               OverflowException
decimal( 1.23456789E-5 )                          0.0000123456789
decimal( 1.234567890123E-15 )       0.000000000000001234567890123
decimal( 1.2345678901234567E-25 )  0.0000000000000000000000001235
decimal( 1.2345678901234567E-35 )                               0
decimal( 1.0 / 7.0 )                            0.142857142857143
*/
``````
``````' Example of the Decimal( Double ) constructor.
Module DecimalCtorDoDemo

' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( 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( value As Double, valToStr As String )

' Format and display the constructor.
Console.Write( "{0,-34}", _
String.Format( "Decimal( {0} )", valToStr ) )

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

' Display the value if it was created successfully.
Console.WriteLine( "{0,31}", decimalNum )

' Display the exception type if an exception was thrown.
Catch ex As Exception
Console.WriteLine( "{0,31}", GetExceptionType( ex ) )
End Try
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the Decimal( Double ) constructor " & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( "{0,-34}{1,31}", "Constructor", _
"Value or Exception" )
Console.WriteLine( "{0,-34}{1,31}", "-----------", _
"------------------" )

' Construct Decimal objects from Double values.
CreateDecimal( 1.23456789E+5, "1.23456789E+5" )
CreateDecimal( 1.234567890123E+15, "1.234567890123E+15" )
CreateDecimal( 1.2345678901234567E+25, _
"1.2345678901234567E+25" )
CreateDecimal( 1.2345678901234567E+35, _
"1.2345678901234567E+35" )
CreateDecimal( 1.23456789E-5, "1.23456789E-5" )
CreateDecimal( 1.234567890123E-15, "1.234567890123E-15" )
CreateDecimal( 1.2345678901234567E-25, _
"1.2345678901234567E-25" )
CreateDecimal( 1.2345678901234567E-35, _
"1.2345678901234567E-35" )
CreateDecimal( 1.0 / 7.0, "1.0 / 7.0" )
End Sub
End Module

' This example of the Decimal( Double ) constructor
' generates the following output.
'
' Constructor                                    Value or Exception
' -----------                                    ------------------
' Decimal( 1.23456789E+5 )                               123456.789
' Decimal( 1.234567890123E+15 )                    1234567890123000
' Decimal( 1.2345678901234567E+25 )      12345678901234600000000000
' Decimal( 1.2345678901234567E+35 )               OverflowException
' Decimal( 1.23456789E-5 )                          0.0000123456789
' Decimal( 1.234567890123E-15 )       0.000000000000001234567890123
' Decimal( 1.2345678901234567E-25 )  0.0000000000000000000000001235
' Decimal( 1.2345678901234567E-35 )                               0
' Decimal( 1.0 / 7.0 )                            0.142857142857143
``````

## Decimal(Int32)

Decimal 的新实例初始化为指定的 32 位有符号整数的值。Initializes a new instance of Decimal to the value of the specified 32-bit signed integer.

``````public:
Decimal(int value);``````
``public Decimal (int value);``
``new decimal : int -> decimal``
``Public Sub New (value As Integer)``

value
Int32

### 示例

``````// Example of the Decimal( int ) constructor.
using namespace System;

// Create a Decimal object and display its value.
void CreateDecimal( int value, String^ valToStr )
{
Decimal decimalNum = Decimal(value);

// Format the constructor for display.
String^ ctor = String::Format( "Decimal( {0} )", valToStr );

// Display the constructor and its value.
Console::WriteLine( "{0,-30}{1,16}", ctor, decimalNum );
}

int main()
{
Console::WriteLine( "This example of the Decimal( int ) "
"constructor \ngenerates the following output.\n" );
Console::WriteLine( "{0,-30}{1,16}", "Constructor", "Value" );
Console::WriteLine( "{0,-30}{1,16}", "-----------", "-----" );

// Construct Decimal objects from int values.
CreateDecimal( Int32::MinValue, "Int32::MinValue" );
CreateDecimal( Int32::MaxValue, "Int32::MaxValue" );
CreateDecimal( 0, "0" );
CreateDecimal( 999999999, "999999999" );
CreateDecimal( 0x40000000, "0x40000000" );
CreateDecimal( (int)0xC0000000, "(int)0xC0000000" );
}

/*
This example of the Decimal( int ) constructor
generates the following output.

Constructor                              Value
-----------                              -----
Decimal( Int32::MinValue )         -2147483648
Decimal( Int32::MaxValue )          2147483647
Decimal( 0 )                                 0
Decimal( 999999999 )                 999999999
Decimal( 0x40000000 )               1073741824
Decimal( (int)0xC0000000 )         -1073741824
*/
``````
``````// Example of the decimal( int ) constructor.
using System;

class DecimalCtorIDemo
{
// Create a decimal object and display its value.
public static void CreateDecimal( int value, string valToStr )
{
decimal decimalNum = new decimal( value );

// Format the constructor for display.
string ctor = String.Format( "decimal( {0} )", valToStr );

// Display the constructor and its value.
Console.WriteLine( "{0,-30}{1,16}", ctor, decimalNum );
}

public static void Main( )
{
Console.WriteLine( "This example of the decimal( int ) " +
"constructor \ngenerates the following output.\n" );
Console.WriteLine( "{0,-30}{1,16}", "Constructor", "Value" );
Console.WriteLine( "{0,-30}{1,16}", "-----------", "-----" );

// Construct decimal objects from int values.
CreateDecimal( int.MinValue, "int.MinValue" );
CreateDecimal( int.MaxValue, "int.MaxValue" );
CreateDecimal( 0, "0" );
CreateDecimal( 999999999, "999999999" );
CreateDecimal( 0x40000000, "0x40000000" );
CreateDecimal( unchecked( (int)0xC0000000 ),
"(int)0xC0000000" );
}
}

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

Constructor                              Value
-----------                              -----
decimal( int.MinValue )            -2147483648
decimal( int.MaxValue )             2147483647
decimal( 0 )                                 0
decimal( 999999999 )                 999999999
decimal( 0x40000000 )               1073741824
decimal( (int)0xC0000000 )         -1073741824
*/
``````
``````' Example of the Decimal( Integer ) constructor.
Module DecimalCtorIDemo

' Create a Decimal object and display its value.
Sub CreateDecimal( value As Integer, valToStr As String )

Dim decimalNum As New Decimal( value )

' Format the constructor for display.
Dim ctor As String = _
String.Format( "Decimal( {0} )", valToStr )

' Display the constructor and its value.
Console.WriteLine( "{0,-33}{1,16}", ctor, decimalNum )
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the Decimal( Integer ) constructor " & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( "{0,-33}{1,16}", "Constructor", "Value" )
Console.WriteLine( "{0,-33}{1,16}", "-----------", "-----" )

' Construct Decimal objects from Integer values.
CreateDecimal( Integer.MinValue, "Integer.MinValue" )
CreateDecimal( Integer.MaxValue, "Integer.MaxValue" )
CreateDecimal( 0, "0" )
CreateDecimal( 999999999, "999999999" )
CreateDecimal( &H40000000, "&H40000000" )
CreateDecimal( &HC0000000, "&HC0000000" )
End Sub
End Module

' This example of the Decimal( Integer ) constructor
' generates the following output.
'
' Constructor                                 Value
' -----------                                 -----
' Decimal( Integer.MinValue )           -2147483648
' Decimal( Integer.MaxValue )            2147483647
' Decimal( 0 )                                    0
' Decimal( 999999999 )                    999999999
' Decimal( &H40000000 )                  1073741824
' Decimal( &HC0000000 )                 -1073741824
``````

## Decimal(Int32[])

Decimal 的新实例初始化为以二进制表示的、包含在指定数组中的十进制值。Initializes a new instance of Decimal to a decimal value represented in binary and contained in a specified array.

``````public:
Decimal(cli::array <int> ^ bits);``````
``public Decimal (int[] bits);``
``new decimal : int[] -> decimal``
``Public Sub New (bits As Integer())``

bits
Int32[]

#### 异常

`bits``null``bits` is `null`.

`bits` 的长度不为 4。The length of the `bits` is not 4.

-或--or- `bits` 中的十进制值的表示形式无效。The representation of the decimal value in `bits` is not valid.

### 示例

``````// Example of the Decimal( int __gc [ ] ) constructor.
using namespace System;

// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}

// Create a Decimal object and display its value.
void CreateDecimal( array<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::Concat( ctor, String::Format( ", 0x{0:X}", bits[ index ] ) );
ctor = String::Concat( ctor, " } )" );
try
{

// Construct the Decimal value.
Decimal decimalNum = 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 )
Console::WriteLine( "{0}{1}", ctor->PadRight( ctorLen ), valOrExc );
// Otherwise, display the data on two lines.
else
{
Console::WriteLine( "{0}", ctor );
Console::WriteLine( "{0,76}", valOrExc );
}
}

int main()
{
Console::WriteLine( "This example of the Decimal( int __gc [ ] ) "
"constructor \ngenerates the following output.\n" );
Console::WriteLine( "{0,-38}{1,38}", "Constructor", "Value or Exception" );
Console::WriteLine( "{0,-38}{1,38}", "-----------", "------------------" );

// Construct Decimal objects from integer arrays.
array<Int32>^zero = {0,0,0,0};
CreateDecimal( zero );
array<Int32>^arrayShort = {0,0,0};
CreateDecimal( arrayShort );
array<Int32>^arrayLong = {0,0,0,0,0};
CreateDecimal( arrayLong );
array<Int32>^word0Data = {1000000000,0,0,0};
CreateDecimal( word0Data );
array<Int32>^word1Data = {0,1000000000,0,0};
CreateDecimal( word1Data );
array<Int32>^word2Data = {0,0,1000000000,0};
CreateDecimal( word2Data );
array<Int32>^word3Data = {0,0,0,1000000000};
CreateDecimal( word3Data );
array<Int32>^decMax = { -1,-1,-1,0};
CreateDecimal( decMax );
array<Int32>^decMin = { -1,-1,-1,0x80000000};
CreateDecimal( decMin );
array<Int32>^fracDig16 = { -1,0,0,0x100000};
CreateDecimal( fracDig16 );
array<Int32>^fracDig28 = { -1,0,0,0x1C0000};
CreateDecimal( fracDig28 );
array<Int32>^fracDig29 = { -1,0,0,0x1D0000};
CreateDecimal( fracDig29 );
array<Int32>^reserved = { -1,0,0,0x1C0001};
CreateDecimal( reserved );
array<Int32>^Same4Words = {0xF0000,0xF0000,0xF0000,0xF0000};
CreateDecimal( Same4Words );
}

/*
This example of the Decimal( int __gc [ ] ) 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
*/
``````
``````// Example of the decimal( int[ ] ) constructor.
using System;

class DecimalCtorIArrDemo
{
// 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( 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 );

// Otherwise, display the data on two lines.
else
{
Console.WriteLine( "{0}", ctor );
Console.WriteLine( "{0,76}", valOrExc );
}
}

public static void Main( )
{
Console.WriteLine(
"This example of the decimal( int[ ] ) constructor " +
"\ngenerates the following output.\n" );
Console.WriteLine( "{0,-38}{1,38}", "Constructor",
"Value or Exception" );
Console.WriteLine( "{0,-38}{1,38}", "-----------",
"------------------" );

// Construct decimal objects from integer arrays.
CreateDecimal( new int[ ] { 0, 0, 0, 0 } );
CreateDecimal( new int[ ] { 0, 0, 0 } );
CreateDecimal( new int[ ] { 0, 0, 0, 0, 0 } );
CreateDecimal( new int[ ] { 1000000000, 0, 0, 0 } );
CreateDecimal( new int[ ] { 0, 1000000000, 0, 0 } );
CreateDecimal( new int[ ] { 0, 0, 1000000000, 0 } );
CreateDecimal( new int[ ] { 0, 0, 0, 1000000000 } );
CreateDecimal( new int[ ] { -1, -1, -1, 0 } );
CreateDecimal( new int[ ]
{ -1, -1, -1, unchecked( (int)0x80000000 ) } );
CreateDecimal( new int[ ] { -1, 0, 0, 0x100000 } );
CreateDecimal( new int[ ] { -1, 0, 0, 0x1C0000 } );
CreateDecimal( new int[ ] { -1, 0, 0, 0x1D0000 } );
CreateDecimal( new int[ ] { -1, 0, 0, 0x1C0001 } );
CreateDecimal( 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
*/
``````
``````' Example of the Decimal( Integer( ) ) constructor.
Module DecimalCtorIArrDemo

' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( 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 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.
Console.WriteLine( "{0}{1}", ctor.PadRight( ctorLen ), _
valOrExc )

' Otherwise, display the data on two lines.
Else
Console.WriteLine( "{0}", ctor )
Console.WriteLine( "{0,76}", valOrExc )
End If
End Sub

Sub Main( )

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

' Construct Decimal objects from Integer arrays.
CreateDecimal( New Integer( ) { 0, 0, 0, 0 } )
CreateDecimal( New Integer( ) { 0, 0, 0 } )
CreateDecimal( New Integer( ) { 0, 0, 0, 0, 0 } )
CreateDecimal( New Integer( ) { 1000000000, 0, 0, 0 } )
CreateDecimal( New Integer( ) { 0, 1000000000, 0, 0 } )
CreateDecimal( New Integer( ) { 0, 0, 1000000000, 0 } )
CreateDecimal( New Integer( ) { 0, 0, 0, 1000000000 } )
CreateDecimal( New Integer( ) { -1, -1, -1, 0 } )
CreateDecimal( New Integer( ) { -1, -1, -1, &H80000000 } )
CreateDecimal( New Integer( ) { -1, 0, 0, &H100000 } )
CreateDecimal( New Integer( ) { -1, 0, 0, &H1C0000 } )
CreateDecimal( New Integer( ) { -1, 0, 0, &H1D0000 } )
CreateDecimal( New Integer( ) { -1, 0, 0, &H1C0001 } )
CreateDecimal( 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
``````

### 注解

Decimal 数字的二进制表示形式由1位符号、96位整数和比例因子组成，用于划分整数号，并指定它的哪一部分是小数部分。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. 缩放系数隐式为数字10，指数范围为0到28。The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28.

`bits` 是由四个元素组成的长度为32位的有符号整数的数组。`bits` is a four-element long array of 32-bit signed integers.

`bits` [0]、`bits` [1] 和 `bits` [2] 包含96位整数的低、中和高32位。`bits` [0], `bits` [1], and `bits` [2] contain the low, middle, and high 32 bits of the 96-bit integer number.

`bits` [3] 包含缩放系数和符号，由以下部分组成：`bits` [3] contains the scale factor and sign, and consists of following parts:

## Decimal(Int64)

Decimal 的新实例初始化为指定的 64 位有符号整数的值。Initializes a new instance of Decimal to the value of the specified 64-bit signed integer.

``````public:
Decimal(long value);``````
``public Decimal (long value);``
``new decimal : int64 -> decimal``
``Public Sub New (value As Long)``

value
Int64

### 示例

``````// Example of the Decimal( __int64 ) constructor.
using namespace System;

// Create a Decimal object and display its value.
void CreateDecimal( __int64 value, String^ valToStr )
{
Decimal decimalNum = Decimal(value);

// Format the constructor for display.
String^ ctor = String::Format( "Decimal( {0} )", valToStr );

// Display the constructor and its value.
Console::WriteLine( "{0,-35}{1,22}", ctor, decimalNum );
}

int main()
{
Console::WriteLine( "This example of the Decimal( __int64 ) "
"constructor \ngenerates the following output.\n" );
Console::WriteLine( "{0,-35}{1,22}", "Constructor", "Value" );
Console::WriteLine( "{0,-35}{1,22}", "-----------", "-----" );

// Construct Decimal objects from __int64 values.
CreateDecimal( Int64::MinValue, "Int64::MinValue" );
CreateDecimal( Int64::MaxValue, "Int64::MaxValue" );
CreateDecimal( 0, "0" );
CreateDecimal( 999999999999999999, "999999999999999999" );
CreateDecimal( 0x2000000000000000, "0x2000000000000000" );
CreateDecimal( 0xE000000000000000, "0xE000000000000000" );
}

/*
This example of the Decimal( __int64 ) constructor
generates the following output.

Constructor                                         Value
-----------                                         -----
Decimal( Int64::MinValue )           -9223372036854775808
Decimal( Int64::MaxValue )            9223372036854775807
Decimal( 0 )                                            0
Decimal( 999999999999999999 )          999999999999999999
Decimal( 0x2000000000000000 )         2305843009213693952
Decimal( 0xE000000000000000 )        -2305843009213693952
*/
``````
``````// Example of the decimal( long ) constructor.
using System;

class DecimalCtorLDemo
{
// Create a decimal object and display its value.
public static void CreateDecimal( long value, string valToStr )
{
decimal decimalNum = new decimal( value );

// Format the constructor for display.
string ctor = String.Format( "decimal( {0} )", valToStr );

// Display the constructor and its value.
Console.WriteLine( "{0,-35}{1,22}", ctor, decimalNum );
}

public static void Main( )
{
Console.WriteLine( "This example of the decimal( long ) " +
"constructor \ngenerates the following output.\n" );
Console.WriteLine( "{0,-35}{1,22}", "Constructor", "Value" );
Console.WriteLine( "{0,-35}{1,22}", "-----------", "-----" );

// Construct decimal objects from long values.
CreateDecimal( long.MinValue, "long.MinValue" );
CreateDecimal( long.MaxValue, "long.MaxValue" );
CreateDecimal( 0L, "0L" );
CreateDecimal( 999999999999999999, "999999999999999999" );
CreateDecimal( 0x2000000000000000, "0x2000000000000000" );
CreateDecimal( unchecked( (long)0xE000000000000000 ),
"(long)0xE000000000000000" );
}
}

/*
This example of the decimal( long ) constructor
generates the following output.

Constructor                                         Value
-----------                                         -----
decimal( long.MinValue )             -9223372036854775808
decimal( long.MaxValue )              9223372036854775807
decimal( 0 )                                            0
decimal( 999999999999999999 )          999999999999999999
decimal( 0x2000000000000000 )         2305843009213693952
decimal( (long)0xE000000000000000 )  -2305843009213693952
*/
``````
``````' Example of the Decimal( Long ) constructor.
Module DecimalCtorLDemo

' Create a Decimal object and display its value.
Sub CreateDecimal( value As Long, valToStr As String )

Dim decimalNum As New Decimal( value )

' Format the constructor for display.
Dim ctor As String = _
String.Format( "Decimal( {0} )", valToStr )

' Display the constructor and its value.
Console.WriteLine( "{0,-30}{1,22}", ctor, decimalNum )
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the Decimal( Long ) constructor " & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( "{0,-30}{1,22}", "Constructor", "Value" )
Console.WriteLine( "{0,-30}{1,22}", "-----------", "-----" )

' Construct Decimal objects from Long values.
CreateDecimal( Long.MinValue, "Long.MinValue" )
CreateDecimal( Long.MaxValue, "Long.MaxValue" )
CreateDecimal( 0L, "0" )
CreateDecimal( 999999999999999999, "999999999999999999" )
CreateDecimal( &H2000000000000000, "&H2000000000000000" )
CreateDecimal( &HE000000000000000, "&HE000000000000000" )
End Sub
End Module

' This example of the Decimal( Long ) constructor
' generates the following output.
'
' Constructor                                    Value
' -----------                                    -----
' Decimal( Long.MinValue )        -9223372036854775808
' Decimal( Long.MaxValue )         9223372036854775807
' Decimal( 0 )                                       0
' Decimal( 999999999999999999 )     999999999999999999
' Decimal( &H2000000000000000 )    2305843009213693952
' Decimal( &HE000000000000000 )   -2305843009213693952
``````

## Decimal(Single)

Decimal 的新实例初始化为指定的单精度浮点数的值。Initializes a new instance of Decimal to the value of the specified single-precision floating-point number.

``````public:
Decimal(float value);``````
``public Decimal (float value);``
``new decimal : single -> decimal``
``Public Sub New (value As Single)``

value
Single

#### 异常

`value` 大于 MaxValue 或小于 MinValue`value` is greater than MaxValue or less than MinValue.

-或--or- `value`NaNPositiveInfinityNegativeInfinity`value` is NaN, PositiveInfinity, or NegativeInfinity.

### 示例

``````// Example of the Decimal( float ) constructor.
using namespace System;

// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}

// Create a Decimal object and display its value.
void CreateDecimal( float value, String^ valToStr )
{

// Format and display the constructor.
Console::Write( "{0,-27}", String::Format( "Decimal( {0} )", valToStr ) );
try
{

// Construct the Decimal value.
Decimal decimalNum = Decimal(value);

// Display the value if it was created successfully.
Console::WriteLine( "{0,31}", decimalNum );
}
catch ( Exception^ ex )
{

// Display the exception type if an exception was thrown.
Console::WriteLine( "{0,31}", GetExceptionType( ex ) );
}

}

int main()
{
Console::WriteLine( "This example of the Decimal( float ) "
"constructor \ngenerates the following output.\n" );
Console::WriteLine( "{0,-27}{1,31}", "Constructor", "Value or Exception" );
Console::WriteLine( "{0,-27}{1,31}", "-----------", "------------------" );

// Construct Decimal objects from float values.
CreateDecimal( 1.2345E+5, "1.2345E+5" );
CreateDecimal( 1.234567E+15, "1.234567E+15" );
CreateDecimal( 1.23456789E+25, "1.23456789E+25" );
CreateDecimal( 1.23456789E+35, "1.23456789E+35" );
CreateDecimal( 1.2345E-5, "1.2345E-5" );
CreateDecimal( 1.234567E-15, "1.234567E-15" );
CreateDecimal( 1.23456789E-25, "1.23456789E-25" );
CreateDecimal( 1.23456789E-35, "1.23456789E-35" );
CreateDecimal( 1.0 / 7.0, "1.0 / 7.0" );
}

/*
This example of the Decimal( float ) constructor
generates the following output.

Constructor                             Value or Exception
-----------                             ------------------
Decimal( 1.2345E+5 )                                123450
Decimal( 1.234567E+15 )                   1234567000000000
Decimal( 1.23456789E+25 )       12345680000000000000000000
Decimal( 1.23456789E+35 )                OverflowException
Decimal( 1.2345E-5 )                           0.000012345
Decimal( 1.234567E-15 )            0.000000000000001234567
Decimal( 1.23456789E-25 )   0.0000000000000000000000001235
Decimal( 1.23456789E-35 )                                0
Decimal( 1.0 / 7.0 )                             0.1428571
*/
``````
``````// Example of the decimal( float ) constructor.
using System;

class DecimalCtorSDemo
{
// 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( float value, string valToStr )
{
// Format and display the constructor.
Console.Write( "{0,-27}",
String.Format( "decimal( {0} )", valToStr ) );

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

// Display the value if it was created successfully.
Console.WriteLine( "{0,31}", decimalNum );
}
catch( Exception ex )
{
// Display the exception type if an exception was thrown.
Console.WriteLine( "{0,31}", GetExceptionType( ex ) );
}
}

public static void Main( )
{

Console.WriteLine( "This example of the decimal( float ) " +
"constructor \ngenerates the following output.\n" );
Console.WriteLine( "{0,-27}{1,31}", "Constructor",
"Value or Exception" );
Console.WriteLine( "{0,-27}{1,31}", "-----------",
"------------------" );

// Construct decimal objects from float values.
CreateDecimal( 1.2345E+5F, "1.2345E+5F" );
CreateDecimal( 1.234567E+15F, "1.234567E+15F" );
CreateDecimal( 1.23456789E+25F, "1.23456789E+25F" );
CreateDecimal( 1.23456789E+35F, "1.23456789E+35F" );
CreateDecimal( 1.2345E-5F, "1.2345E-5F" );
CreateDecimal( 1.234567E-15F, "1.234567E-15F" );
CreateDecimal( 1.23456789E-25F, "1.23456789E-25F" );
CreateDecimal( 1.23456789E-35F, "1.23456789E-35F" );
CreateDecimal( 1.0F / 7.0F, "1.0F / 7.0F" );
}
}

/*
This example of the decimal( float ) constructor
generates the following output.

Constructor                             Value or Exception
-----------                             ------------------
decimal( 1.2345E+5F )                               123450
decimal( 1.234567E+15F )                  1234567000000000
decimal( 1.23456789E+25F )      12345680000000000000000000
decimal( 1.23456789E+35F )               OverflowException
decimal( 1.2345E-5F )                          0.000012345
decimal( 1.234567E-15F )           0.000000000000001234567
decimal( 1.23456789E-25F )  0.0000000000000000000000001235
decimal( 1.23456789E-35F )                               0
decimal( 1.0F / 7.0F )                           0.1428571
*/
``````
``````' Example of the Decimal( Single ) constructor.
Module DecimalCtorSDemo

' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( 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( value As Single, valToStr As String )

' Format and display the constructor.
Console.Write( "{0,-27}", _
String.Format( "Decimal( {0} )", valToStr ) )

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

' Display the value if it was created successfully.
Console.WriteLine( "{0,31}", decimalNum )

' Display the exception type if an exception was thrown.
Catch ex As Exception
Console.WriteLine( "{0,31}", GetExceptionType( ex ) )
End Try
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the Decimal( Single ) constructor " & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( "{0,-27}{1,31}", "Constructor", "Value or Exception" )
Console.WriteLine( "{0,-27}{1,31}", "-----------", "------------------" )

' Construct Decimal objects from Single values.
CreateDecimal( 1.2345E+5, "1.2345E+5" )
CreateDecimal( 1.234567E+15, "1.234567E+15" )
CreateDecimal( 1.23456789E+25, "1.23456789E+25" )
CreateDecimal( 1.23456789E+35, "1.23456789E+35" )
CreateDecimal( 1.2345E-5, "1.2345E-5" )
CreateDecimal( 1.234567E-15, "1.234567E-15" )
CreateDecimal( 1.23456789E-25, "1.23456789E-25" )
CreateDecimal( 1.23456789E-35, "1.23456789E-35" )
CreateDecimal( 1.0 / 7.0, "1.0 / 7.0" )
End Sub
End Module

' This example of the Decimal( Single ) constructor
' generates the following output.
'
' Constructor                             Value or Exception
' -----------                             ------------------
' Decimal( 1.2345E+5 )                                123450
' Decimal( 1.234567E+15 )                   1234567000000000
' Decimal( 1.23456789E+25 )       12345680000000000000000000
' Decimal( 1.23456789E+35 )                OverflowException
' Decimal( 1.2345E-5 )                           0.000012345
' Decimal( 1.234567E-15 )            0.000000000000001234567
' Decimal( 1.23456789E-25 )   0.0000000000000000000000001235
' Decimal( 1.23456789E-35 )                                0
' Decimal( 1.0 / 7.0 )                             0.1428571
``````

## Decimal(UInt32)

Decimal 的新实例初始化为指定的 32 位无符号整数的值。Initializes a new instance of Decimal to the value of the specified 32-bit unsigned integer.

``````public:
Decimal(System::UInt32 value);``````
``````[System.CLSCompliant(false)]
public Decimal (uint value);``````
``new decimal : uint32 -> decimal``
``Public Sub New (value As UInteger)``

value
UInt32

### 示例

``````// Example of the Decimal( unsigned int ) constructor.
using namespace System;

// Create a Decimal object and display its value.
void CreateDecimal( unsigned int value, String^ valToStr )
{
Decimal decimalNum = Decimal(value);

// Format the constructor for display.
String^ ctor = String::Format( "Decimal( {0} )", valToStr );

// Display the constructor and its value.
Console::WriteLine( "{0,-30}{1,16}", ctor, decimalNum );
}

int main()
{
Console::WriteLine( "This example of the Decimal( unsigned "
"int ) constructor \ngenerates the following output.\n" );
Console::WriteLine( "{0,-30}{1,16}", "Constructor", "Value" );
Console::WriteLine( "{0,-30}{1,16}", "-----------", "-----" );

// Construct Decimal objects from unsigned int values.
CreateDecimal( UInt32::MinValue, "UInt32::MinValue" );
CreateDecimal( UInt32::MaxValue, "UInt32::MaxValue" );
CreateDecimal( Int32::MaxValue, "Int32::MaxValue" );
CreateDecimal( 999999999, "999999999" );
CreateDecimal( 0x40000000, "0x40000000" );
CreateDecimal( 0xC0000000, "0xC0000000" );
}

/*
This example of the Decimal( unsigned int ) constructor
generates the following output.

Constructor                              Value
-----------                              -----
Decimal( UInt32::MinValue )                  0
Decimal( UInt32::MaxValue )         4294967295
Decimal( Int32::MaxValue )          2147483647
Decimal( 999999999 )                 999999999
Decimal( 0x40000000 )               1073741824
Decimal( 0xC0000000 )               3221225472
*/
``````
``````// Example of the decimal( uint ) constructor.
using System;

class DecimalCtorUIDemo
{
// Create a decimal object and display its value.
public static void CreateDecimal( uint value, string valToStr )
{
decimal decimalNum = new decimal( value );

// Format the constructor for display.
string ctor = String.Format( "decimal( {0} )", valToStr );

// Display the constructor and its value.
Console.WriteLine( "{0,-33}{1,16}", ctor, decimalNum );
}

public static void Main( )
{
Console.WriteLine( "This example of the decimal( uint ) " +
"constructor \ngenerates the following output.\n" );
Console.WriteLine( "{0,-33}{1,16}", "Constructor", "Value" );
Console.WriteLine( "{0,-33}{1,16}", "-----------", "-----" );

// Construct decimal objects from uint values.
CreateDecimal( uint.MinValue, "uint.MinValue" );
CreateDecimal( uint.MaxValue, "uint.MaxValue" );
CreateDecimal( (uint)int.MaxValue, "(uint)int.MaxValue" );
CreateDecimal( 999999999U, "999999999U" );
CreateDecimal( 0x40000000U, "0x40000000U" );
CreateDecimal( 0xC0000000, "0xC0000000" );
}
}

/*
This example of the decimal( uint ) constructor
generates the following output.

Constructor                                 Value
-----------                                 -----
decimal( uint.MinValue )                        0
decimal( uint.MaxValue )               4294967295
decimal( (uint)int.MaxValue )          2147483647
decimal( 999999999U )                   999999999
decimal( 0x40000000U )                 1073741824
decimal( 0xC0000000 )                  3221225472
*/
``````
``````' Example of the Decimal( UInt32 ) constructor.
Module DecimalCtorUIDemo

' Create a Decimal object and display its value.
Sub CreateDecimal( value As UInt32, valToStr As String )

Dim decimalNum As New Decimal( value )

' Format the constructor for display.
Dim ctor As String = _
String.Format( "Decimal( {0} )", valToStr )

' Display the constructor and its value.
Console.WriteLine( "{0,-33}{1,16}", ctor, decimalNum )
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the Decimal( UInt32 ) constructor " & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( "{0,-33}{1,16}", "Constructor", "Value" )
Console.WriteLine( "{0,-33}{1,16}", "-----------", "-----" )

' Construct Decimal objects from UInt32 values.
' UInt32.MinValue and UInt32.MaxValue are not defined in VB.
CreateDecimal( Convert.ToUInt32( 0 ), """UInt32.MinValue""" )
CreateDecimal( Convert.ToUInt32( 4294967295 ), _
"""UInt32.MaxValue""" )
CreateDecimal( Convert.ToUInt32( Integer.MaxValue ), _
"Integer.MaxValue" )
CreateDecimal( Convert.ToUInt32( 999999999 ), "999999999" )
CreateDecimal( Convert.ToUInt32( &H40000000 ), "&H40000000" )
CreateDecimal( Convert.ToUInt32( &HC0000000L ), "&HC0000000" )
End Sub
End Module

' This example of the Decimal( UInt32 ) constructor
' generates the following output.
'
' Constructor                                 Value
' -----------                                 -----
' Decimal( "UInt32.MinValue" )                    0
' Decimal( "UInt32.MaxValue" )           4294967295
' Decimal( Integer.MaxValue )            2147483647
' Decimal( 999999999 )                    999999999
' Decimal( &H40000000 )                  1073741824
' Decimal( &HC0000000 )                  3221225472
``````

## Decimal(UInt64)

Decimal 的新实例初始化为指定的 64 位无符号整数的值。Initializes a new instance of Decimal to the value of the specified 64-bit unsigned integer.

``````public:
Decimal(System::UInt64 value);``````
``````[System.CLSCompliant(false)]
public Decimal (ulong value);``````
``new decimal : uint64 -> decimal``
``Public Sub New (value As ULong)``

value
UInt64

### 示例

``````// Example of the Decimal( unsigned __int64 ) constructor.
using namespace System;

// Create a Decimal object and display its value.
void CreateDecimal( unsigned __int64 value, String^ valToStr )
{
Decimal decimalNum = Decimal(value);

// Format the constructor for display.
String^ ctor = String::Format( "Decimal( {0} )", valToStr );

// Display the constructor and its value.
Console::WriteLine( "{0,-33}{1,22}", ctor, decimalNum );
}

int main()
{
Console::WriteLine( "This example of the Decimal( unsigned "
"__int64 ) constructor \ngenerates the following output.\n" );
Console::WriteLine( "{0,-33}{1,22}", "Constructor", "Value" );
Console::WriteLine( "{0,-33}{1,22}", "-----------", "-----" );

// Construct Decimal objects from unsigned __int64 values.
CreateDecimal( UInt64::MinValue, "UInt64::MinValue" );
CreateDecimal( UInt64::MaxValue, "UInt64::MaxValue" );
CreateDecimal( Int64::MaxValue, "Int64::MaxValue" );
CreateDecimal( 999999999999999999, "999999999999999999" );
CreateDecimal( 0x2000000000000000, "0x2000000000000000" );
CreateDecimal( 0xE000000000000000, "0xE000000000000000" );
}

/*
This example of the Decimal( unsigned __int64 ) constructor
generates the following output.

Constructor                                       Value
-----------                                       -----
Decimal( UInt64::MinValue )                           0
Decimal( UInt64::MaxValue )        18446744073709551615
Decimal( Int64::MaxValue )          9223372036854775807
Decimal( 999999999999999999 )        999999999999999999
Decimal( 0x2000000000000000 )       2305843009213693952
Decimal( 0xE000000000000000 )      16140901064495857664
*/
``````
``````// Example of the decimal( ulong ) constructor.
using System;

class DecimalCtorLDemo
{
// Create a decimal object and display its value.
public static void CreateDecimal( ulong value, string valToStr )
{
decimal decimalNum = new decimal( value );

// Format the constructor for display.
string ctor = String.Format( "decimal( {0} )", valToStr );

// Display the constructor and its value.
Console.WriteLine( "{0,-35}{1,22}", ctor, decimalNum );
}

public static void Main( )
{
Console.WriteLine( "This example of the decimal( ulong ) " +
"constructor \ngenerates the following output.\n" );
Console.WriteLine( "{0,-35}{1,22}", "Constructor", "Value" );
Console.WriteLine( "{0,-35}{1,22}", "-----------", "-----" );

// Construct decimal objects from ulong values.
CreateDecimal( ulong.MinValue, "ulong.MinValue" );
CreateDecimal( ulong.MaxValue, "ulong.MaxValue" );
CreateDecimal( long.MaxValue, "long.MaxValue" );
CreateDecimal( 999999999999999999, "999999999999999999" );
CreateDecimal( 0x2000000000000000, "0x2000000000000000" );
CreateDecimal( 0xE000000000000000, "0xE000000000000000" );
}
}

/*
This example of the decimal( ulong ) constructor
generates the following output.

Constructor                                         Value
-----------                                         -----
decimal( ulong.MinValue )                               0
decimal( ulong.MaxValue )            18446744073709551615
decimal( long.MaxValue )              9223372036854775807
decimal( 999999999999999999 )          999999999999999999
decimal( 0x2000000000000000 )         2305843009213693952
decimal( 0xE000000000000000 )        16140901064495857664
*/
``````
``````' Example of the Decimal( UInt64 ) constructor.
Module DecimalCtorULDemo

' Create a Decimal object and display its value.
Sub CreateDecimal( value As UInt64, valToStr As String )

Dim decimalNum As New Decimal( value )

' Format the constructor for display.
Dim ctor As String = _
String.Format( "Decimal( {0} )", valToStr )

' Display the constructor and its value.
Console.WriteLine( "{0,-33}{1,22}", ctor, decimalNum )
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the Decimal( UInt64 ) constructor " & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( "{0,-33}{1,22}", "Constructor", "Value" )
Console.WriteLine( "{0,-33}{1,22}", "-----------", "-----" )

' Construct Decimal objects from UInt64 values.
' UInt64.MinValue and UInt64.MaxValue are not defined in VB.
CreateDecimal( Convert.ToUInt64( 0 ), """UInt64.MinValue""" )
CreateDecimal( Convert.ToUInt64( 18446744073709551615D ), _
"""UInt64.MaxValue""" )
CreateDecimal( Convert.ToUInt64( Long.MaxValue ), _
"Long.MaxValue" )
CreateDecimal( Convert.ToUInt64( 999999999999999999 ), _
"999999999999999999" )
CreateDecimal( Convert.ToUInt64( &H2000000000000000 ), _
"&H2000000000000000" )
CreateDecimal( Convert.ToUInt64( 16140901064495857664.0 ), _
"16140901064495857664.0" )
End Sub
End Module

' This example of the Decimal( UInt64 ) constructor
' generates the following output.
'
' Constructor                                       Value
' -----------                                       -----
' Decimal( "UInt64.MinValue" )                          0
' Decimal( "UInt64.MaxValue" )       18446744073709551615
' Decimal( Long.MaxValue )            9223372036854775807
' Decimal( 999999999999999999 )        999999999999999999
' Decimal( &H2000000000000000 )       2305843009213693952
' Decimal( 16140901064495857664.0 )  16140901064495857664
``````

## Decimal(Int32, Int32, Int32, Boolean, Byte)

``````public:
Decimal(int lo, int mid, int hi, bool isNegative, System::Byte scale);``````
``public Decimal (int lo, int mid, int hi, bool isNegative, byte scale);``
``new decimal : int * int * int * bool * byte -> decimal``
``Public Sub New (lo As Integer, mid As Integer, hi As Integer, isNegative As Boolean, scale As Byte)``

#### 参数

lo
Int32

96 位整数的低 32 位。The low 32 bits of a 96-bit integer.

mid
Int32

96 位整数的中间 32 位。The middle 32 bits of a 96-bit integer.

hi
Int32

96 位整数的高 32 位。The high 32 bits of a 96-bit integer.

isNegative
Boolean

scale
Byte

10 的指数（0 到 28 之间）。A power of 10 ranging from 0 to 28.

#### 异常

`scale` 大于 28。`scale` is greater than 28.

### 示例

``````// Example of the Decimal( int, int, int, bool, unsigned char )
// constructor.
using namespace System;

// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}

// Create a Decimal object and display its value.
void CreateDecimal( int low, int mid, int high, bool isNeg, unsigned char scale )
{

// Format the constructor for display.
array<Object^>^boxedParams = gcnew array<Object^>(5);
boxedParams[ 0 ] = low;
boxedParams[ 1 ] = mid;
boxedParams[ 2 ] = high;
boxedParams[ 3 ] = isNeg;
boxedParams[ 4 ] = scale;
String^ ctor = String::Format( "Decimal( {0}, {1}, {2}, {3}, {4} )", boxedParams );
String^ valOrExc;
try
{

// Construct the Decimal value.
Decimal decimalNum = Decimal(low,mid,high,isNeg,scale);

// Format and save the Decimal value.
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 )
Console::WriteLine( "{0}{1}", ctor->PadRight( ctorLen ), valOrExc );
// Otherwise, display the data on two lines.
else
{
Console::WriteLine( "{0}", ctor );
Console::WriteLine( "{0,76}", valOrExc );
}
}

int main()
{
Console::WriteLine( "This example of the Decimal( int, int, "
"int, bool, unsigned char ) \nconstructor "
"generates the following output.\n" );
Console::WriteLine( "{0,-38}{1,38}", "Constructor", "Value or Exception" );
Console::WriteLine( "{0,-38}{1,38}", "-----------", "------------------" );

// Construct Decimal objects from double values.
CreateDecimal( 0, 0, 0, false, 0 );
CreateDecimal( 0, 0, 0, false, 27 );
CreateDecimal( 0, 0, 0, true, 0 );
CreateDecimal( 1000000000, 0, 0, false, 0 );
CreateDecimal( 0, 1000000000, 0, false, 0 );
CreateDecimal( 0, 0, 1000000000, false, 0 );
CreateDecimal( 1000000000, 1000000000, 1000000000, false, 0 );
CreateDecimal(  -1, -1, -1, false, 0 );
CreateDecimal(  -1, -1, -1, true, 0 );
CreateDecimal(  -1, -1, -1, false, 15 );
CreateDecimal(  -1, -1, -1, false, 28 );
CreateDecimal(  -1, -1, -1, false, 29 );
CreateDecimal( Int32::MaxValue, 0, 0, false, 18 );
CreateDecimal( Int32::MaxValue, 0, 0, false, 28 );
CreateDecimal( Int32::MaxValue, 0, 0, true, 28 );
}

/*
This example of the Decimal( int, int, int, bool, unsigned char )
constructor generates the following output.

Constructor                                               Value or Exception
-----------                                               ------------------
Decimal( 0, 0, 0, False, 0 )                                               0
Decimal( 0, 0, 0, False, 27 )                                              0
Decimal( 0, 0, 0, True, 0 )                                                0
Decimal( 1000000000, 0, 0, False, 0 )                             1000000000
Decimal( 0, 1000000000, 0, False, 0 )                    4294967296000000000
Decimal( 0, 0, 1000000000, False, 0 )          18446744073709551616000000000
Decimal( 1000000000, 1000000000, 1000000000, False, 0 )
18446744078004518913000000000
Decimal( -1, -1, -1, False, 0 )                79228162514264337593543950335
Decimal( -1, -1, -1, True, 0 )                -79228162514264337593543950335
Decimal( -1, -1, -1, False, 15 )              79228162514264.337593543950335
Decimal( -1, -1, -1, False, 28 )              7.9228162514264337593543950335
Decimal( -1, -1, -1, False, 29 )                 ArgumentOutOfRangeException
Decimal( 2147483647, 0, 0, False, 18 )                  0.000000002147483647
Decimal( 2147483647, 0, 0, False, 28 )        0.0000000000000000002147483647
Decimal( 2147483647, 0, 0, True, 28 )        -0.0000000000000000002147483647
*/
``````
``````// Example of the decimal( int, int, int, bool, byte ) constructor.
using System;

class DecimalCtorIIIBByDemo
{
// 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( int low, int mid, int high,
bool isNeg, byte scale )
{
// Format the constructor for display.
string ctor = String.Format(
"decimal( {0}, {1}, {2}, {3}, {4} )",
low, mid, high, isNeg, scale );
string valOrExc;

try
{
// Construct the decimal value.
decimal decimalNum = new decimal(
low, mid, high, isNeg, scale );

// Format and save the decimal value.
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 );

// Otherwise, display the data on two lines.
else
{
Console.WriteLine( "{0}", ctor );
Console.WriteLine( "{0,76}", valOrExc );
}
}

public static void Main( )
{

Console.WriteLine( "This example of the decimal( int, int, " +
"int, bool, byte ) \nconstructor " +
"generates the following output.\n" );
Console.WriteLine( "{0,-38}{1,38}", "Constructor",
"Value or Exception" );
Console.WriteLine( "{0,-38}{1,38}", "-----------",
"------------------" );

// Construct decimal objects from the component fields.
CreateDecimal( 0, 0, 0, false, 0 );
CreateDecimal( 0, 0, 0, false, 27 );
CreateDecimal( 0, 0, 0, true, 0 );
CreateDecimal( 1000000000, 0, 0, false, 0 );
CreateDecimal( 0, 1000000000, 0, false, 0 );
CreateDecimal( 0, 0, 1000000000, false, 0 );
CreateDecimal( 1000000000, 1000000000, 1000000000, false, 0 );
CreateDecimal( -1, -1, -1, false, 0 );
CreateDecimal( -1, -1, -1, true, 0 );
CreateDecimal( -1, -1, -1, false, 15 );
CreateDecimal( -1, -1, -1, false, 28 );
CreateDecimal( -1, -1, -1, false, 29 );
CreateDecimal( int.MaxValue, 0, 0, false, 18 );
CreateDecimal( int.MaxValue, 0, 0, false, 28 );
CreateDecimal( int.MaxValue, 0, 0, true, 28 );
}
}

/*
This example of the decimal( int, int, int, bool, byte )
constructor generates the following output.

Constructor                                               Value or Exception
-----------                                               ------------------
decimal( 0, 0, 0, False, 0 )                                               0
decimal( 0, 0, 0, False, 27 )                                              0
decimal( 0, 0, 0, True, 0 )                                                0
decimal( 1000000000, 0, 0, False, 0 )                             1000000000
decimal( 0, 1000000000, 0, False, 0 )                    4294967296000000000
decimal( 0, 0, 1000000000, False, 0 )          18446744073709551616000000000
decimal( 1000000000, 1000000000, 1000000000, False, 0 )
18446744078004518913000000000
decimal( -1, -1, -1, False, 0 )                79228162514264337593543950335
decimal( -1, -1, -1, True, 0 )                -79228162514264337593543950335
decimal( -1, -1, -1, False, 15 )              79228162514264.337593543950335
decimal( -1, -1, -1, False, 28 )              7.9228162514264337593543950335
decimal( -1, -1, -1, False, 29 )                 ArgumentOutOfRangeException
decimal( 2147483647, 0, 0, False, 18 )                  0.000000002147483647
decimal( 2147483647, 0, 0, False, 28 )        0.0000000000000000002147483647
decimal( 2147483647, 0, 0, True, 28 )        -0.0000000000000000002147483647
*/
``````
``````' Example of the Decimal( Integer, Integer, Integer, Boolean, Byte )
' constructor.
Module DecimalCtorIIIBByDemo

' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( 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( low As Integer, mid As Integer, _
high As Integer, isNeg As Boolean, scale as Byte )

' Format the constructor for display.
Dim ctor As String = String.Format( _
"Decimal( {0}, {1}, {2}, {3}, {4} )", _
low, mid, high, isNeg, scale )
Dim valOrExc As String

' Construct the Decimal value.
Try
Dim decimalNum As New Decimal( _
low, mid, high, isNeg, scale )

' Format and save the Decimal value.
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 = 76 - valOrExc.Length
If ctorLen > ctor.Length Then

' Display the data on one line if it will fit.
Console.WriteLine( "{0}{1}", ctor.PadRight( ctorLen ), _
valOrExc )

' Otherwise, display the data on two lines.
Else
Console.WriteLine( "{0}", ctor )
Console.WriteLine( "{0,76}", valOrExc )
End If
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the Decimal( Integer, Integer, " & _
"Integer, Boolean, Byte ) " & vbCrLf & "constructor " & _
"generates the following output." & vbCrLf )
Console.WriteLine( "{0,-38}{1,38}", "Constructor", _
"Value or Exception" )
Console.WriteLine( "{0,-38}{1,38}", "-----------", _
"------------------" )

' Construct Decimal objects from the component fields.
CreateDecimal( 0, 0, 0, False, 0 )
CreateDecimal( 0, 0, 0, False, 27 )
CreateDecimal( 0, 0, 0, True, 0 )
CreateDecimal( 1000000000, 0, 0, False, 0 )
CreateDecimal( 0, 1000000000, 0, False, 0 )
CreateDecimal( 0, 0, 1000000000, False, 0 )
CreateDecimal( 1000000000, 1000000000, 1000000000, False, 0 )
CreateDecimal( -1, -1, -1, False, 0 )
CreateDecimal( -1, -1, -1, True, 0 )
CreateDecimal( -1, -1, -1, False, 15 )
CreateDecimal( -1, -1, -1, False, 28 )
CreateDecimal( -1, -1, -1, False, 29 )
CreateDecimal( Integer.MaxValue, 0, 0, False, 18 )
CreateDecimal( Integer.MaxValue, 0, 0, False, 28 )
CreateDecimal( Integer.MaxValue, 0, 0, True, 28 )
End Sub
End Module

' This example of the Decimal( Integer, Integer, Integer, Boolean, Byte )
' constructor generates the following output.
'
' Constructor                                               Value or Exception
' -----------                                               ------------------
' Decimal( 0, 0, 0, False, 0 )                                               0
' Decimal( 0, 0, 0, False, 27 )                                              0
' Decimal( 0, 0, 0, True, 0 )                                                0
' Decimal( 1000000000, 0, 0, False, 0 )                             1000000000
' Decimal( 0, 1000000000, 0, False, 0 )                    4294967296000000000
' Decimal( 0, 0, 1000000000, False, 0 )          18446744073709551616000000000
' Decimal( 1000000000, 1000000000, 1000000000, False, 0 )
'                                                18446744078004518913000000000
' Decimal( -1, -1, -1, False, 0 )                79228162514264337593543950335
' Decimal( -1, -1, -1, True, 0 )                -79228162514264337593543950335
' Decimal( -1, -1, -1, False, 15 )              79228162514264.337593543950335
' Decimal( -1, -1, -1, False, 28 )              7.9228162514264337593543950335
' Decimal( -1, -1, -1, False, 29 )                 ArgumentOutOfRangeException
' Decimal( 2147483647, 0, 0, False, 18 )                  0.000000002147483647
' Decimal( 2147483647, 0, 0, False, 28 )        0.0000000000000000002147483647
' Decimal( 2147483647, 0, 0, True, 28 )        -0.0000000000000000002147483647
``````

``````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
``````
``````Module Example
Public Sub Main()
Dim values() As Decimal = { 1234.96d, -1234.96d }
For Each value In values
Dim parts() = Decimal.GetBits(value)
Dim sign As Boolean = (parts(3) And &h80000000) <> 0
Dim scale As Byte = CByte((parts(3) >> 16) And &H7F)

Dim newValue As New Decimal(parts(0), parts(1), parts(2), sign, scale)
Console.WriteLine("{0} --> {1}", value, newValue)
Next
End Sub
End Module
' The example displays the following output:
'    1234.96 --> 1234.96
'    -1234.96 --> -1234.96
``````

### 注解

Decimal 数字的二进制表示形式由1位符号、96位整数和比例因子组成，用于划分整数号，并指定它的哪一部分是小数部分。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. 缩放系数隐式地将数字10的数字从0到28。The scaling factor is implicitly the number 10 raised to an exponent ranging from 0 to 28.