Decimal Konstruktory

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Inicjuje nowe wystąpienie klasy Decimal.

Przeciążenia

Decimal(Double)	Inicjuje nowe wystąpienie Decimal wartości określonej liczby zmiennoprzecinkowej o podwójnej precyzji.
Decimal(Int32)	Inicjuje nowe wystąpienie Decimal wartości określonej 32-bitowej liczby całkowitej ze znakiem.
Decimal(Int32[])	Inicjuje nowe wystąpienie Decimal wartości dziesiętnej reprezentowanej w pliku binarnym i zawarte w określonej tablicy.
Decimal(Int64)	Inicjuje nowe wystąpienie Decimal wartości określonej 64-bitowej liczby całkowitej ze znakiem.
Decimal(ReadOnlySpan<Int32>)	Inicjuje nowe wystąpienie Decimal wartości dziesiętnej reprezentowanej w pliku binarnym i zawarte w określonym przedziale.
Decimal(Single)	Inicjuje nowe wystąpienie Decimal wartości określonej liczby zmiennoprzecinkowej o pojedynczej precyzji.
Decimal(UInt32)	Inicjuje nowe wystąpienie Decimal wartości określonej 32-bitowej liczby całkowitej bez znaku.
Decimal(UInt64)	Inicjuje nowe wystąpienie Decimal wartości określonej 64-bitowej liczby całkowitej bez znaku.
Decimal(Int32, Int32, Int32, Boolean, Byte)	Inicjuje nowe wystąpienie parametrów Decimal określających składniki wystąpienia.

Decimal(Double)

Źródło:

Decimal.cs

Inicjuje nowe wystąpienie Decimal wartości określonej liczby zmiennoprzecinkowej o podwójnej precyzji.

C#

public Decimal (double value);

Parametry

value

Double

Wartość, która ma być reprezentowana Decimaljako .

Wyjątki

OverflowException

value parametr jest większy niż Decimal.MaxValue lub mniejszy niż Decimal.MinValue.

-lub-

value to NaN, PositiveInfinitylub NegativeInfinity.

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z wartością Double .

C#

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

Uwagi

Ten konstruktor zaokrągla value do 15 cyfr znaczących przy użyciu zaokrąglania do najbliższej. Odbywa się to nawet wtedy, gdy liczba ma więcej niż 15 cyfr, a mniej znaczących cyfr to zero.

Decimal(Int32)

Źródło:

Decimal.cs

Inicjuje nowe wystąpienie Decimal wartości określonej 32-bitowej liczby całkowitej ze znakiem.

C#

public Decimal (int value);

Parametry

value

Int32

Wartość, która ma być reprezentowana Decimaljako .

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z wartością Int32 .

C#

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

Decimal(Int32[])

Źródło:

Decimal.cs

Inicjuje nowe wystąpienie Decimal wartości dziesiętnej reprezentowanej w pliku binarnym i zawarte w określonej tablicy.

C#

public Decimal (int[] bits);

Parametry

bits

Int32[]

Tablica 32-bitowych liczb całkowitych ze znakiem zawierająca reprezentację wartości dziesiętnej.

Wyjątki

ArgumentNullException

bits to null.

ArgumentException

Długość nie bits wynosi 4.

-lub-

Reprezentacja wartości dziesiętnej w pliku bits jest nieprawidłowa.

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z tablicą czterech Int32 wartości.

C#

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

Uwagi

Reprezentacja Decimal binarna liczby składa się z znaku 1-bitowego, liczby całkowitej 96-bitowej oraz współczynnika skalowania używanego do dzielenia liczby całkowitej i określania, jaka część jest ułamkiem dziesiętnym. Współczynnik skalowania jest niejawnie liczbą 10 podniesioną do wykładnika z zakresu od 0 do 28.

bits to czteroelementowa tablica z 32-bitowymi liczbami całkowitymi ze znakiem.

bits [0], bits [1] i bits [2] zawierają małe, środkowe i wysokie 32 bity liczby całkowitej 96-bitowej.

bits [3] zawiera współczynnik skali i znak i składa się z następujących części:

Bity od 0 do 15, dolne słowo, są nieużywane i muszą być zerowe.

Bity od 16 do 23 muszą zawierać wykładnik z zakresu od 0 do 28, co wskazuje moc 10, aby podzielić liczbę całkowitą.

Bity od 24 do 30 są nieużywane i muszą mieć wartość zero.

Bit 31 zawiera znak; 0 oznacza dodatnie, a 1 oznacza ujemne.

Wartość liczbowa może mieć kilka możliwych reprezentacji binarnych; wszystkie są równie prawidłowe i numerycznie równoważne. Należy pamiętać, że reprezentacja bitów rozróżnia ujemne i dodatnie zero. Te wartości są traktowane jako równe we wszystkich operacjach.

Zobacz też

• GetBits(Decimal)

Decimal(Int64)

Źródło:

Decimal.cs

Inicjuje nowe wystąpienie Decimal wartości określonej 64-bitowej liczby całkowitej ze znakiem.

C#

public Decimal (long value);

Parametry

value

Int64

Wartość, która ma być reprezentowana Decimaljako .

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z wartością Int64 .

C#

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

Decimal(ReadOnlySpan<Int32>)

Źródło:

Decimal.cs

Inicjuje nowe wystąpienie Decimal wartości dziesiętnej reprezentowanej w pliku binarnym i zawarte w określonym przedziale.

C#

public Decimal (ReadOnlySpan<int> bits);

Parametry

bits

ReadOnlySpan<Int32>

Zakres czterech Int32 wartości, który zawiera binarną reprezentację wartości dziesiętnej.

Wyjątki

ArgumentException

Długość wartości bits nie wynosi 4 lub reprezentacja wartości dziesiętnej w bits obiekcie jest nieprawidłowa.

Decimal(Single)

Źródło:

Decimal.cs

Inicjuje nowe wystąpienie Decimal wartości określonej liczby zmiennoprzecinkowej o pojedynczej precyzji.

C#

public Decimal (float value);

Parametry

value

Single

Wartość, która ma być reprezentowana Decimaljako .

Wyjątki

OverflowException

value parametr jest większy niż Decimal.MaxValue lub mniejszy niż Decimal.MinValue.

-lub-

value to NaN, PositiveInfinitylub NegativeInfinity.

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z wartością Single .

C#

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

Uwagi

Ten konstruktor zaokrągla value do 7 cyfr znaczących przy użyciu zaokrąglania do najbliższego. Odbywa się to nawet wtedy, gdy liczba ma więcej niż 7 cyfr, a mniej znaczące cyfry to zero.

Decimal(UInt32)

Źródło:

Decimal.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Inicjuje nowe wystąpienie Decimal wartości określonej 32-bitowej liczby całkowitej bez znaku.

C#

[System.CLSCompliant(false)]
public Decimal (uint value);

Parametry

value

UInt32

Wartość, która ma być reprezentowana Decimaljako .

Atrybuty

CLSCompliantAttribute

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z wartością UInt32 .

C#

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

Decimal(UInt64)

Źródło:

Decimal.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Inicjuje nowe wystąpienie Decimal wartości określonej 64-bitowej liczby całkowitej bez znaku.

C#

[System.CLSCompliant(false)]
public Decimal (ulong value);

Parametry

value

UInt64

Wartość, która ma być reprezentowana Decimaljako .

Atrybuty

CLSCompliantAttribute

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z wartością UInt64 .

C#

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

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

Źródło:

Decimal.cs

Inicjuje nowe wystąpienie parametrów Decimal określających składniki wystąpienia.

C#

public Decimal (int lo, int mid, int hi, bool isNegative, byte scale);

Parametry

lo

Int32

Niskie 32 bity 96-bitowej liczby całkowitej.

mid

Int32

Środkowe 32 bity 96-bitowej liczby całkowitej.

hi

Int32

Wysokie 32 bity 96-bitowej liczby całkowitej.

isNegative

Boolean

true wskazać liczbę ujemną; false aby wskazać liczbę dodatnią.

scale

Byte

Moc 10 od 0 do 28.

Wyjątki

ArgumentOutOfRangeException

scale wartość jest większa niż 28.

Przykłady

Poniższy przykład kodu tworzy kilka Decimal liczb przy użyciu przeciążenia konstruktora, które inicjuje Decimal strukturę z trzema Int32 wyrazami wartości, znakiem Boolean i współczynnikiem skalowania Byte .

C#

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

W poniższym przykładzie użyto GetBits metody , aby pobrać części składowe tablicy. Następnie używa tej tablicy w wywołaniu do konstruktora Decimal(Int32, Int32, Int32, Boolean, Byte) , aby utworzyć wystąpienie nowej Decimal wartości.

C#

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

Uwagi

Reprezentacja Decimal binarna liczby składa się z znaku 1-bitowego, liczby całkowitej 96-bitowej oraz współczynnika skalowania używanego do dzielenia liczby całkowitej i określania, jaka część jest ułamkiem dziesiętnym. Współczynnik skalowania jest niejawnie liczbą 10 podniesioną do wykładnika z zakresu od 0 do 28.