Decimal コンストラクター
定義
重要
一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。
Decimal の新しいインスタンスを初期化します。
オーバーロード
| Decimal(Double) |
Decimal の新しいインスタンスを初期化し、その値を、指定した倍精度浮動小数点数に設定します。 |
| Decimal(Int32) |
Decimal の新しいインスタンスを初期化し、その値を、指定した 32 ビット符号付き整数に設定します。 |
| Decimal(Int32[]) |
Decimal の新しいインスタンスの値を、指定した配列に格納されている、バイナリ形式の 10 進値に初期化します。 |
| Decimal(Int64) |
Decimal の新しいインスタンスを初期化し、その値を、指定した 64 ビット符号付き整数に設定します。 |
| Decimal(ReadOnlySpan<Int32>) |
Decimal の新しいインスタンスを、指定したスパンに格納されている、バイナリ形式の 10 進値に初期化します。 |
| Decimal(Single) |
Decimal の新しいインスタンスを初期化し、その値を、指定した単精度浮動小数点数に設定します。 |
| Decimal(UInt32) |
Decimal の新しいインスタンスを初期化し、その値を、指定した 32 ビット符号なし整数に設定します。 |
| Decimal(UInt64) |
Decimal の新しいインスタンスを初期化し、その値を、指定した 64 ビット符号なし整数に設定します。 |
| Decimal(Int32, Int32, Int32, Boolean, Byte) |
Decimal の新しいインスタンスの値を、そのインスタンスの構成部分を指定するパラメーターに従って初期化します。 |
Decimal(Double)
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
Decimal の新しいインスタンスを初期化し、その値を、指定した倍精度浮動小数点数に設定します。
public:
Decimal(double value);public Decimal (double value);new decimal : double -> decimalPublic Sub New (value As Double)パラメーター
例外
value が Decimal.MaxValue より大きいか、 Decimal.MinValue より小さい。
または
value が NaN、PositiveInfinity、または NegativeInfinity です。
例
次のコード例では、値を使用して構造体を初期化するコンストラクター オーバーロードをDecimal使用して、いくつかのDecimal数値をDouble作成します。
// 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.
open System
// Get the exception type name; remove the namespace prefix.
let getExceptionType (ex: exn) =
let exceptionType = ex.GetType() |> string
exceptionType.Substring(exceptionType.LastIndexOf '.' + 1)
// Create a decimal object and display its value.
let createDecimal (value: double) valToStr =
// Format and display the constructor.
printf "%-34s" $"decimal( {valToStr} )"
try
// Construct the decimal value.
let decimalNum = Decimal value
// Display the value if it was created successfully.
printfn $"{decimalNum,31}"
with ex ->
// Display the exception type if an exception was thrown.
printfn $"{getExceptionType ex,31}"
printfn $"This example of the decimal( double ) constructor \ngenerates the following output.\n"
printfn "%-34s%31s" "Constructor" "Value or Exception"
printfn "%-34s%31s" "-----------" "------------------"
// 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. / 7.) "1. / 7."
// 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
' 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
注釈
このコンストラクターは、 value 丸めを使用して有効桁数を 15 桁に丸めます。 これは、数値が 15 桁を超え、有効桁数の小さい数字が 0 の場合でも実行されます。
適用対象
Decimal(Int32)
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
Decimal の新しいインスタンスを初期化し、その値を、指定した 32 ビット符号付き整数に設定します。
public:
Decimal(int value);public Decimal (int value);new decimal : int -> decimalPublic Sub New (value As Integer)パラメーター
例
次のコード例では、値を使用して構造体を初期化するコンストラクター オーバーロードをDecimal使用して、いくつかのDecimal数値を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(int) constructor.
open System
// Create a decimal object and display its value.
let createDecimal (value: int) valToStr =
let decimalNum = new decimal(value)
// Format the constructor for display.
let ctor = $"decimal( {valToStr} )"
// Display the constructor and its value.
printfn $"{ctor,-30}{decimalNum,16}"
printfn "This example of the decimal(int) constructor\ngenerates the following output.\n"
printfn "%-30s%16s" "Constructor" "Value"
printfn "%-30s%16s" "-----------" "-----"
// Construct decimal objects from int values.
createDecimal Int32.MinValue "Int32.MinValue"
createDecimal Int32.MaxValue "int.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( 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.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
Decimal の新しいインスタンスの値を、指定した配列に格納されている、バイナリ形式の 10 進値に初期化します。
public:
Decimal(cli::array <int> ^ bits);public Decimal (int[] bits);new decimal : int[] -> decimalPublic Sub New (bits As Integer())パラメーター
- bits
- Int32[]
10 進値形式を格納している 32 ビット符号付き整数の配列。
例外
bits が nullです。
例
次のコード例では、4 つのInt32値の配列で構造体をDecimal初期化するコンストラクター オーバーロードを使用して、いくつかのDecimal数値を作成します。
// 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 )
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 );
}
}
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(int[]) constructor.
open System
// Get the exception type name; remove the namespace prefix.
let getExceptionType (ex: exn) =
let exceptionType = ex.GetType() |> string
exceptionType.Substring(exceptionType.LastIndexOf '.' + 1)
// Create a decimal object and display its value.
let createDecimal (bits: int[]) =
// Format the constructor for display.
let mutable ctor = String.Format("decimal( {{ 0x{0:X}", bits[0])
for i = 1 to bits.Length - 1 do
ctor <- $"{ctor}, 0x{bits[i]:X}"
ctor <- ctor + " } )"
let valOrExc =
try
// Construct the decimal value.
let decimalNum = new decimal(bits)
// Format the decimal value for display.
string decimalNum
with ex ->
// Save the exception type if an exception was thrown.
getExceptionType ex
// Display the constructor and decimal value or exception.
let ctorLen = 76 - valOrExc.Length;
// Display the data on one line if it will fit.
if ctorLen > ctor.Length then
printfn $"{ctor.PadRight ctorLen}{valOrExc}"
// Otherwise, display the data on two lines.
else
printfn $"{ctor}"
printfn $"{valOrExc,76}"
printfn
"""This example of the decimal(int[]) constructor
generates the following output.
"""
printfn "%-38s%38s" "Constructor" "Value or Exception"
printfn "%-38s%38s" "-----------" "------------------"
// Construct decimal objects from integer arrays.
createDecimal [| 0; 0; 0; 0 |]
createDecimal [| 0; 0; 0 |]
createDecimal [| 0; 0; 0; 0; 0 |]
createDecimal [| 1000000000; 0; 0; 0 |]
createDecimal [| 0; 1000000000; 0; 0 |]
createDecimal [| 0; 0; 1000000000; 0 |]
createDecimal [| 0; 0; 0; 1000000000 |]
createDecimal [| -1; -1; -1; 0 |]
createDecimal [| -1; -1; -1; 0x80000000 |]
createDecimal [| -1; 0; 0; 0x100000 |]
createDecimal [| -1; 0; 0; 0x1C0000 |]
createDecimal [| -1; 0; 0; 0x1D0000 |]
createDecimal [| -1; 0; 0; 0x1C0001 |]
createDecimal [| 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 ビット整数、および整数を除算し、その部分を小数部として指定するために使用されるスケーリング係数で構成されます。 スケーリング係数は暗黙的に数値 10 で、0 から 28 までの指数に引き上げられます。
bits は、32 ビット符号付き整数の 4 要素長配列です。
bits [0]、 bits [1]、および bits [2] には、96 ビット整数値の下位、中間、および高の 32 ビットが含まれます。
bits [3] スケール ファクターと符号が含まれており、次の部分で構成されます。
下位ワードであるビット 0 から 15 は使用されず、ゼロである必要があります。
ビット 16 から 23 には、整数を除算する 10 のべき乗を示す 0 ~ 28 の指数が含まれている必要があります。
ビット 24 から 30 は未使用であり、ゼロである必要があります。
ビット 31 には記号が含まれています。0 は正の意味、1 は負の意味です。
数値には、複数のバイナリ表現が含まれる場合があります。すべて等しく有効であり、数値的に同等です。 ビット表現では、負と正の 0 が区別されることに注意してください。 これらの値は、すべての操作で等しいと見なされます。
こちらもご覧ください
適用対象
Decimal(Int64)
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
Decimal の新しいインスタンスを初期化し、その値を、指定した 64 ビット符号付き整数に設定します。
public:
Decimal(long value);public Decimal (long value);new decimal : int64 -> decimalPublic Sub New (value As Long)パラメーター
例
次のコード例では、値を使用して構造体を初期化するコンストラクター オーバーロードをDecimal使用して、いくつかのDecimal数値を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( int64 ) constructor.
open System
// Create a decimal object and display its value.
let createDecimal (value: int64) valToStr =
let decimalNum = Decimal value
// Format the constructor for display.
let ctor = $"decimal( {valToStr} )"
// Display the constructor and its value.
printfn $"{ctor,-35}{decimalNum,22}"
printfn "This example of the decimal( int64 ) constructor\ngenerates the following output.\n"
printfn "%-35s%22s" "Constructor" "Value"
printfn "%-35s%22s" "-----------" "-----"
// Construct decimal objects from long values.
createDecimal Int64.MinValue "Int64.MinValue"
createDecimal Int64.MaxValue "Int64.MaxValue"
createDecimal 0L "0L"
createDecimal 999999999999999999L "999999999999999999L"
createDecimal 0x2000000000000000L "0x2000000000000000L"
createDecimal (int64 0xE000000000000000L) "int64 0xE000000000000000L"
// This example of the decimal( int64 ) constructor
// generates the following output.
//
// Constructor Value
// ----------- -----
// decimal( Int64.MinValue ) -9223372036854775808
// decimal( Int64.MaxValue ) 9223372036854775807
// decimal( 0L ) 0
// decimal( 999999999999999999L ) 999999999999999999
// decimal( 0x2000000000000000L ) 2305843009213693952
// decimal( int64 0xE000000000000000L ) -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(ReadOnlySpan<Int32>)
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
Decimal の新しいインスタンスを、指定したスパンに格納されている、バイナリ形式の 10 進値に初期化します。
public:
Decimal(ReadOnlySpan<int> bits);public Decimal (ReadOnlySpan<int> bits);new decimal : ReadOnlySpan<int> -> decimalPublic Sub New (bits As ReadOnlySpan(Of Integer))パラメーター
- bits
- ReadOnlySpan<Int32>
10 進値のバイナリ表現を含む 4 つのInt32 値のスパン。
例外
bits の長さが 4 ではないか、bits の 10 進値の表現が有効ではありません。
適用対象
Decimal(Single)
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
Decimal の新しいインスタンスを初期化し、その値を、指定した単精度浮動小数点数に設定します。
public:
Decimal(float value);public Decimal (float value);new decimal : single -> decimalPublic Sub New (value As Single)パラメーター
例外
value が Decimal.MaxValue より大きいか、 Decimal.MinValue より小さい。
または
value が NaN、PositiveInfinity、または NegativeInfinity です。
例
次のコード例では、値を使用して構造体を初期化するコンストラクター オーバーロードをDecimal使用して、いくつかのDecimal数値をSingle作成します。
// 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( float ) constructor.
open System
// Get the exception type name; remove the namespace prefix.
let getExceptionType (ex: exn) =
let exceptionType = ex.GetType() |> string
exceptionType.Substring(exceptionType.LastIndexOf '.' + 1)
// Create a decimal object and display its value.
let createDecimal (value: float32) valToStr =
// Format and display the constructor.
printf "%-27s" $"decimal( {valToStr} )"
try
// Construct the decimal value.
let decimalNum = Decimal value
// Display the value if it was created successfully.
printfn $"{decimalNum,31}"
with ex ->
// Display the exception type if an exception was thrown.
printfn $"{getExceptionType ex,31}"
printfn "This example of the decimal( float ) constructor \ngenerates the following output.\n"
printfn $"""{"Constructor",-27}{"Value or Exception",31}"""
printfn $"""{"-----------",-27}{"------------------",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 (1f / 7f) "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
注釈
このコンストラクターは、 value 四捨五入を使用して 7 桁の有効桁数に丸めます。 これは、数値が 7 桁を超え、有効桁数の小さい数字が 0 の場合でも行われます。
適用対象
Decimal(UInt32)
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
重要
この API は CLS 準拠ではありません。
Decimal の新しいインスタンスを初期化し、その値を、指定した 32 ビット符号なし整数に設定します。
public:
Decimal(System::UInt32 value);[System.CLSCompliant(false)]
public Decimal (uint value);[<System.CLSCompliant(false)>]
new decimal : uint32 -> decimalPublic Sub New (value As UInteger)パラメーター
- 属性
例
次のコード例では、値を使用して構造体を初期化するコンストラクター オーバーロードをDecimal使用して、いくつかのDecimal数値を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( uint ) constructor.
open System
// Create a decimal object and display its value.
let createDecimal (value: uint) valToStr =
let decimalNum = Decimal value
// Format the constructor for display.
let ctor = $"decimal( {valToStr} )"
// Display the constructor and its value.
printfn $"{ctor,-33}{decimalNum,16}"
printfn "This example of the decimal( uint ) constructor \ngenerates the following output.\n"
printfn "%-33s%16s" "Constructor" "Value"
printfn "%-33s%16s" "-----------" "-----"
// Construct decimal objects from uint values.
createDecimal UInt32.MinValue "UInt32.MinValue"
createDecimal UInt32.MaxValue "UInt32.MaxValue"
createDecimal (uint Int32.MaxValue) "uint Int32.MaxValue"
createDecimal 999999999u "999999999u"
createDecimal 0x40000000u "0x40000000u"
createDecimal 0xC0000000u "0xC0000000u"
// This example of the decimal( uint ) constructor
// generates the following output.
//
// Constructor Value
// ----------- -----
// decimal( UInt32.MinValue ) 0
// decimal( UInt32.MaxValue ) 4294967295
// decimal( uint Int32.MaxValue ) 2147483647
// decimal( 999999999u ) 999999999
// decimal( 0x40000000u ) 1073741824
// decimal( 0xC0000000u ) 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.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
重要
この API は CLS 準拠ではありません。
Decimal の新しいインスタンスを初期化し、その値を、指定した 64 ビット符号なし整数に設定します。
public:
Decimal(System::UInt64 value);[System.CLSCompliant(false)]
public Decimal (ulong value);[<System.CLSCompliant(false)>]
new decimal : uint64 -> decimalPublic Sub New (value As ULong)パラメーター
- 属性
例
次のコード例では、値を使用して構造体を初期化するコンストラクター オーバーロードをDecimal使用して、いくつかのDecimal数値を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.
open System
// Create a decimal object and display its value.
let createDecimal (value: uint64) valToStr =
let decimalNum = Decimal value
// Format the constructor for display.
let ctor = $"decimal( {valToStr} )"
// Display the constructor and its value.
printfn $"{ctor,-35}{decimalNum,22}"
printfn "This example of the decimal( uint64 ) constructor \ngenerates the following output.\n"
printfn "%-35s%22s" "Constructor" "Value"
printfn "%-35s%22s" "-----------" "-----"
// Construct decimal objects from ulong values.
createDecimal UInt64.MinValue "UInt64.MinValue"
createDecimal UInt64.MaxValue "UInt64.MaxValue"
createDecimal (uint64 Int64.MaxValue) "int64 Int64.MaxValue"
createDecimal 999999999999999999uL "999999999999999999uL"
createDecimal 0x2000000000000000uL "0x2000000000000000uL"
createDecimal 0xE000000000000000uL "0xE000000000000000uL"
// This example of the decimal( uint64 ) constructor
// generates the following output.
//
// Constructor Value
// ----------- -----
// decimal( UInt64.MinValue ) 0
// decimal( UInt64.MaxValue ) 18446744073709551615
// decimal( int64 Int64.MaxValue ) 9223372036854775807
// decimal( 999999999999999999uL ) 999999999999999999
// decimal( 0x2000000000000000uL ) 2305843009213693952
// decimal( 0xE000000000000000uL ) 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)
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
- ソース:
- Decimal.cs
Decimal の新しいインスタンスの値を、そのインスタンスの構成部分を指定するパラメーターに従って初期化します。
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 -> decimalPublic Sub New (lo As Integer, mid As Integer, hi As Integer, isNegative As Boolean, scale As Byte)パラメーター
- lo
- Int32
96 ビット整数の下位 32 ビット。
- mid
- Int32
96 ビット整数の中位 32 ビット。
- hi
- Int32
96 ビット整数の上位 32 ビット。
- isNegative
- Boolean
負の数を示す場合は true。正の数を示す場合は false。
- scale
- Byte
0 から 28 までの 10 のべき乗。
例外
scale が 28 を超えています。
例
次のコード例では、3 つのInt32値の単語、符号、およびスケール ファクターを使用して構造体をDecimal初期化するコンストラクター オーバーロードをBoolean使用して、いくつかのDecimal数値をByte作成します。
// 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 )
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 );
}
}
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( int, int, int, bool, byte ) constructor.
open System
// Get the exception type name; remove the namespace prefix.
let getExceptionType (ex: exn) =
let exceptionType = ex.GetType() |> string
exceptionType.Substring(exceptionType.LastIndexOf '.' + 1)
// Create a decimal object and display its value.
let createDecimal low mid high (isNeg: bool) (scale: byte) =
// Format the constructor for display.
let ctor =
$"decimal( %i{low}, %i{mid}, %i{high}, {isNeg}, {scale} )"
let valOrExc =
try
// Construct the decimal value.
let decimalNum = new decimal(low, mid, high, isNeg, scale)
// Format and save the decimal value.
decimalNum |> string
with ex ->
// Save the exception type if an exception was thrown.
getExceptionType ex
// Display the constructor and decimal value or exception.
let ctorLen = 76 - valOrExc.Length
// Display the data on one line if it will fit.
if ctorLen > ctor.Length then
printfn $"{ctor.PadRight ctorLen}{valOrExc}"
// Otherwise, display the data on two lines.
else
printfn $"{ctor}"
printfn $"{valOrExc,76}"
printfn
"""This example of the decimal(int, int, int, bool, byte)
constructor generates the following output.
"""
printfn "%-38s%38s" "Constructor" "Value or Exception"
printfn "%-38s%38s" "-----------" "------------------"
// Construct decimal objects from the component fields.
createDecimal 0 0 0 false 0uy
createDecimal 0 0 0 false 27uy
createDecimal 0 0 0 true 0uy
createDecimal 1000000000 0 0 false 0uy
createDecimal 0 1000000000 0 false 0uy
createDecimal 0 0 1000000000 false 0uy
createDecimal 1000000000 1000000000 1000000000 false 0uy
createDecimal -1 -1 -1 false 0uy
createDecimal -1 -1 -1 true 0uy
createDecimal -1 -1 -1 false 15uy
createDecimal -1 -1 -1 false 28uy
createDecimal -1 -1 -1 false 29uy
createDecimal Int32.MaxValue 0 0 false 18uy
createDecimal Int32.MaxValue 0 0 false 28uy
createDecimal Int32.MaxValue 0 0 true 28uy
// 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
次の例では、 メソッドを GetBits 使用して配列のコンポーネント部分を取得します。 次に、コンストラクターの呼び出しでこの配列を Decimal(Int32, Int32, Int32, Boolean, Byte) 使用して、新 Decimal しい値をインスタンス化します。
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
open System
let values = [ 1234.96m; -1234.96m ]
for value in values do
let parts = Decimal.GetBits value
let sign = (parts[3] &&& 0x80000000) <> 0
let scale = (parts[3] >>> 16) &&& 0x7F |> byte
let newValue = Decimal(parts[0], parts[1], parts[2], sign, scale)
printfn $"{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 ビット整数、および整数を除算し、その部分を小数部として指定するために使用されるスケーリング係数で構成されます。 スケーリング係数は、暗黙的に 0 から 28 までの指数に引き上げられた数値 10 です。
適用対象
GitHub で Microsoft と共同作業する
このコンテンツのソースは GitHub にあります。そこで、issue や pull request を作成および確認することもできます。 詳細については、共同作成者ガイドを参照してください。
.NET