Decimal Costruttori
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Inizializza una nuova istanza di Decimal.
Overload
Decimal(Double) |
Inizializza una nuova istanza di Decimal sul valore del numero a virgola mobile a precisione doppia specificato. |
Decimal(Int32) |
Inizializza una nuova istanza di Decimal sul valore dell'intero con segno a 32 bit specificato. |
Decimal(Int32[]) |
Inizializza una nuova istanza di Decimal su un valore decimale rappresentato in formato binario e contenuto nella matrice specificata. |
Decimal(Int64) |
Inizializza una nuova istanza di Decimal sul valore dell'intero con segno a 64 bit specificato. |
Decimal(ReadOnlySpan<Int32>) |
Inizializza una nuova istanza di Decimal in un valore decimale rappresentato in binario e contenuto nell'intervallo specificato. |
Decimal(Single) |
Inizializza una nuova istanza di Decimal sul valore del numero a virgola mobile a precisione singola specificato. |
Decimal(UInt32) |
Inizializza una nuova istanza di Decimal sul valore dell'intero senza segno a 32 bit specificato. |
Decimal(UInt64) |
Inizializza una nuova istanza di Decimal sul valore dell'intero senza segno a 64 bit specificato. |
Decimal(Int32, Int32, Int32, Boolean, Byte) |
Inizializza una nuova istanza di Decimal dai parametri che specificano le parti costitutive dell'istanza. |
Decimal(Double)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Inizializza una nuova istanza di Decimal sul valore del numero a virgola mobile a precisione doppia specificato.
public:
Decimal(double value);
public Decimal (double value);
new decimal : double -> decimal
Public Sub New (value As Double)
Parametri
Eccezioni
value
è maggiore di Decimal.MaxValue o minore di Decimal.MinValue.
-oppure-
value
è NaN, PositiveInfinity o NegativeInfinity.
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una Decimal
struttura con un Double valore.
// 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
Commenti
Questo costruttore si arrotonda value
a 15 cifre significative usando l'arrotondamento più vicino. Questa operazione viene eseguita anche se il numero ha più di 15 cifre e le cifre meno significative sono zero.
Si applica a
Decimal(Int32)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Inizializza una nuova istanza di Decimal sul valore dell'intero con segno a 32 bit specificato.
public:
Decimal(int value);
public Decimal (int value);
new decimal : int -> decimal
Public Sub New (value As Integer)
Parametri
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una Decimal
struttura con un Int32 valore.
// 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
Si applica a
Decimal(Int32[])
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Inizializza una nuova istanza di Decimal su un valore decimale rappresentato in formato binario e contenuto nella matrice specificata.
public:
Decimal(cli::array <int> ^ bits);
public Decimal (int[] bits);
new decimal : int[] -> decimal
Public Sub New (bits As Integer())
Parametri
- bits
- Int32[]
Matrice di interi con segno a 32 bit che contiene una rappresentazione di un valore decimale.
Eccezioni
bits
è null
.
La lunghezza di bits
non è 4.
-oppure-
La rappresentazione del valore decimale in bits
non è valida.
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una struttura con una Decimal
matrice di quattro Int32 valori.
// 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
Commenti
La rappresentazione binaria di un Decimal numero è costituita da un segno a 1 bit, un numero intero a 96 bit e un fattore di ridimensionamento utilizzato per dividere il numero intero e specificare la parte di cui è una frazione decimale. Il fattore di ridimensionamento è implicitamente il numero 10, generato a un esponente compreso tra 0 e 28.
bits
è una matrice lunga a quattro elementi di interi con segno a 32 bit.
bits
[0], [1], e bits
[2] contengono i bit bassi, bits
intermedi e alti 32 bit del numero intero a 96 bit.
bits
[3] contiene il fattore di scala e il segno e sono costituiti dalle parti seguenti:
I bit da 0 a 15, la parola inferiore, sono inutilizzati e devono essere zero.
I bit da 16 a 23 devono contenere un esponente compreso tra 0 e 28, che indica la potenza di 10 per dividere il numero intero.
I bit da 24 a 30 sono inutilizzati e devono essere zero.
Bit 31 contiene il segno; 0 significa positivo e 1 significato negativo.
Un valore numerico potrebbe avere diverse possibili rappresentazioni binarie; tutti sono ugualmente validi e numericamente equivalenti. Si noti che la rappresentazione bit distingue tra zero negativo e positivo. Questi valori vengono considerati uguali in tutte le operazioni.
Vedi anche
Si applica a
Decimal(Int64)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Inizializza una nuova istanza di Decimal sul valore dell'intero con segno a 64 bit specificato.
public:
Decimal(long value);
public Decimal (long value);
new decimal : int64 -> decimal
Public Sub New (value As Long)
Parametri
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una Decimal
struttura con un Int64 valore.
// 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
Si applica a
Decimal(ReadOnlySpan<Int32>)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Inizializza una nuova istanza di Decimal in un valore decimale rappresentato in binario e contenuto nell'intervallo specificato.
public:
Decimal(ReadOnlySpan<int> bits);
public Decimal (ReadOnlySpan<int> bits);
new decimal : ReadOnlySpan<int> -> decimal
Public Sub New (bits As ReadOnlySpan(Of Integer))
Parametri
- bits
- ReadOnlySpan<Int32>
Intervallo di quattro valori Int32 che contiene una rappresentazione binaria di un valore decimale.
Eccezioni
La lunghezza di bits
non è 4 oppure la rappresentazione del valore decimale in bits
non è valida.
Si applica a
Decimal(Single)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Inizializza una nuova istanza di Decimal sul valore del numero a virgola mobile a precisione singola specificato.
public:
Decimal(float value);
public Decimal (float value);
new decimal : single -> decimal
Public Sub New (value As Single)
Parametri
Eccezioni
value
è maggiore di Decimal.MaxValue o minore di Decimal.MinValue.
-oppure-
value
è NaN, PositiveInfinity o NegativeInfinity.
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una Decimal
struttura con un Single valore.
// 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
Commenti
Questo costruttore si arrotonda value
a 7 cifre significative usando l'arrotondamento al più vicino. Questa operazione viene eseguita anche se il numero ha più di 7 cifre e le cifre meno significative sono zero.
Si applica a
Decimal(UInt32)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Importante
Questa API non è conforme a CLS.
Inizializza una nuova istanza di Decimal sul valore dell'intero senza segno a 32 bit specificato.
public:
Decimal(System::UInt32 value);
[System.CLSCompliant(false)]
public Decimal (uint value);
[<System.CLSCompliant(false)>]
new decimal : uint32 -> decimal
Public Sub New (value As UInteger)
Parametri
- Attributi
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una Decimal
struttura con un UInt32 valore.
// 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
Si applica a
Decimal(UInt64)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Importante
Questa API non è conforme a CLS.
Inizializza una nuova istanza di Decimal sul valore dell'intero senza segno a 64 bit specificato.
public:
Decimal(System::UInt64 value);
[System.CLSCompliant(false)]
public Decimal (ulong value);
[<System.CLSCompliant(false)>]
new decimal : uint64 -> decimal
Public Sub New (value As ULong)
Parametri
- Attributi
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una Decimal
struttura con un UInt64 valore.
// 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
Si applica a
Decimal(Int32, Int32, Int32, Boolean, Byte)
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
- Origine:
- Decimal.cs
Inizializza una nuova istanza di Decimal dai parametri che specificano le parti costitutive dell'istanza.
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)
Parametri
- lo
- Int32
32 bit bassi di un intero a 96 bit.
- mid
- Int32
32 bit medi di un intero a 96 bit.
- hi
- Int32
32 bit bassi di un intero a 96 bit.
- isNegative
- Boolean
true
per indicare un numero negativo; false
per indicare un numero positivo.
- scale
- Byte
Potenza di 10 compresa tra 0 e 28.
Eccezioni
scale
è maggiore di 28.
Esempio
Nell'esempio di codice seguente vengono creati diversi Decimal
numeri usando l'overload del costruttore che inizializza una Decimal
struttura con tre Int32 parole di valore, un Boolean segno e un Byte fattore di scala.
// 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
Nell'esempio seguente viene usato il GetBits metodo per recuperare le parti componente di una matrice. Usa quindi questa matrice nella chiamata al Decimal(Int32, Int32, Int32, Boolean, Byte) costruttore per creare un'istanza di un nuovo Decimal valore.
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
Commenti
La rappresentazione binaria di un Decimal numero è costituita da un segno a 1 bit, un numero intero a 96 bit e un fattore di ridimensionamento utilizzato per dividere il numero intero e specificare la parte di cui è una frazione decimale. Il fattore di ridimensionamento è implicitamente il numero 10 generato a un esponente compreso tra 0 e 28.