Decimal Oluşturucular

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

yeni bir örneğini Decimalbaşlatır.

Aşırı Yüklemeler

Decimal(Double)	Belirtilen çift duyarlıklı kayan nokta sayısının değerine yeni bir örneğini Decimal başlatır.
Decimal(Int32)	Belirtilen 32 bit imzalı tamsayının değerine yeni bir örneğini Decimal başlatır.
Decimal(Int32[])	yeni bir örneğini Decimal ikili olarak temsil edilen ve belirtilen bir dizide bulunan ondalık değere başlatır.
Decimal(Int64)	Belirtilen 64 bit imzalı tamsayının değerine yeni bir örneği Decimal başlatır.
Decimal(ReadOnlySpan<Int32>)	yeni bir örneğini Decimal ikili olarak temsil edilen ve belirtilen yayılma alanında yer alan ondalık bir değere başlatır.
Decimal(Single)	Belirtilen tek duyarlıklı kayan nokta sayısının değerine yeni bir örneği Decimal başlatır.
Decimal(UInt32)	Belirtilen 32 bit işaretsiz tamsayının değerine yeni bir örneği Decimal başlatır.
Decimal(UInt64)	Belirtilen 64 bit işaretsiz tamsayının değerine yeni bir örneği Decimal başlatır.
Decimal(Int32, Int32, Int32, Boolean, Byte)	Örneğin bileşenlerini belirten parametrelerden yeni bir örneğini Decimal başlatır.

Decimal(Double)

Kaynak:

Decimal.cs

Belirtilen çift duyarlıklı kayan nokta sayısının değerine yeni bir örneğini Decimal başlatır.

C#

public Decimal (double value);

Parametreler

value

Double

olarak Decimaltemsil etmek için değer.

Özel durumlar

OverflowException

value Decimal.MaxValue değerinden büyük veya Decimal.MinValue değerinden küçüktür.

-veya-

value, PositiveInfinityveya NegativeInfinityşeklindedirNaN.

Örnekler

Aşağıdaki kod örneği, bir Decimal yapıyı bir Double değerle başlatan oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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

Açıklamalar

Bu oluşturucu, en yakına yuvarlama value kullanarak 15 anlamlı basamağı yuvarlar. Bu işlem, sayıda 15'ten fazla basamak olsa ve daha az anlamlı basamak sıfır olsa bile gerçekleştirilir.

Decimal(Int32)

Kaynak:

Decimal.cs

Belirtilen 32 bit imzalı tamsayının değerine yeni bir örneğini Decimal başlatır.

C#

public Decimal (int value);

Parametreler

value

Int32

olarak Decimaltemsil etmek için değer.

Örnekler

Aşağıdaki kod örneği, bir Decimal yapıyı bir Int32 değerle başlatan oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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[])

Kaynak:

Decimal.cs

yeni bir örneğini Decimal ikili olarak temsil edilen ve belirtilen bir dizide bulunan ondalık değere başlatır.

C#

public Decimal (int[] bits);

Parametreler

bits

Int32[]

Ondalık değerin gösterimini içeren 32 bit imzalı tamsayı dizisi.

Özel durumlar

ArgumentNullException

bits, null değeridir.

ArgumentException

uzunluğu bits 4 değildir.

-veya-

içindeki bits ondalık değerin gösterimi geçerli değil.

Örnekler

Aşağıdaki kod örneği, bir yapıyı dört Int32 değerden oluşan bir Decimal diziyle başlatan oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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

Açıklamalar

Bir Decimal sayının ikili gösterimi 1 bit işaretinden, 96 bitlik bir tamsayıdan ve tamsayı sayısını bölmek ve hangi bölümünün ondalık kesir olduğunu belirtmek için kullanılan ölçeklendirme faktöründen oluşur. Ölçeklendirme faktörü örtük olarak 10 sayısıdır ve 0 ile 28 arasında bir üs oluşturur.

bits 32 bit imzalı tamsayılardan oluşan dört öğeli uzun bir dizidir.

bits [0], bits [1], ve bits [2] 96 bit tamsayı sayısının düşük, orta ve yüksek 32 bitini içerir.

bits [3] ölçek faktörünü ve işaretini içerir ve aşağıdaki bölümlerden oluşur:

Küçük sözcük olan 0 ile 15 arasında bitler kullanılmaz ve sıfır olmalıdır.

16 ile 23 arasındaki bitler, tamsayıyı bölmek için 10'un gücünü gösteren 0 ile 28 arasında bir üs içermelidir.

24 ile 30 arasında bitler kullanılmaz ve sıfır olmalıdır.

Bit 31 işareti içerir; 0 pozitif, 1 negatif anlamına gelir.

Sayısal bir değerin birkaç olası ikili gösterimi olabilir; tümü eşit oranda geçerli ve sayısal olarak eşdeğerdir. Bit gösteriminin negatif ve pozitif sıfır arasında ayrım olduğunu unutmayın. Bu değerler tüm işlemlerde eşit olarak kabul edilir.

Ayrıca bkz.

• GetBits(Decimal)

Decimal(Int64)

Kaynak:

Decimal.cs

Belirtilen 64 bit imzalı tamsayının değerine yeni bir örneği Decimal başlatır.

C#

public Decimal (long value);

Parametreler

value

Int64

olarak Decimaltemsil etmek için değer.

Örnekler

Aşağıdaki kod örneği, bir Decimal yapıyı bir Int64 değerle başlatan oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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>)

Kaynak:

Decimal.cs

yeni bir örneğini Decimal ikili olarak temsil edilen ve belirtilen yayılma alanında yer alan ondalık bir değere başlatır.

C#

public Decimal (ReadOnlySpan<int> bits);

Parametreler

bits

ReadOnlySpan<Int32>

Ondalık değerin ikili gösterimini içeren dört Int32 değerden oluşan bir yayılma alanı.

Özel durumlar

ArgumentException

uzunluğu bits 4 değil veya içindeki bits ondalık değerin gösterimi geçerli değil.

Decimal(Single)

Kaynak:

Decimal.cs

Belirtilen tek duyarlıklı kayan nokta sayısının değerine yeni bir örneği Decimal başlatır.

C#

public Decimal (float value);

Parametreler

value

Single

olarak Decimaltemsil etmek için değer.

Özel durumlar

OverflowException

value Decimal.MaxValue değerinden büyük veya Decimal.MinValue değerinden küçüktür.

-veya-

value, PositiveInfinityveya NegativeInfinityşeklindedirNaN.

Örnekler

Aşağıdaki kod örneği, bir Decimal yapıyı bir Single değerle başlatan oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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

Açıklamalar

Bu oluşturucu, en yakına yuvarlama kullanarak 7 anlamlı basamağı yuvarlar value . Bu işlem, sayıda 7'den fazla basamak olsa ve daha az anlamlı basamak sıfır olsa bile gerçekleştirilir.

Decimal(UInt32)

Kaynak:

Decimal.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 32 bit işaretsiz tamsayının değerine yeni bir örneği Decimal başlatır.

C#

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

Parametreler

value

UInt32

olarak Decimaltemsil etmek için değer.

Öznitelikler

CLSCompliantAttribute

Örnekler

Aşağıdaki kod örneği, bir Decimal yapıyı bir UInt32 değerle başlatan oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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)

Kaynak:

Decimal.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 64 bit işaretsiz tamsayının değerine yeni bir örneği Decimal başlatır.

C#

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

Parametreler

value

UInt64

olarak Decimaltemsil etmek için değer.

Öznitelikler

CLSCompliantAttribute

Örnekler

Aşağıdaki kod örneği, bir Decimal yapıyı bir UInt64 değerle başlatan oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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)

Kaynak:

Decimal.cs

Örneğin bileşenlerini belirten parametrelerden yeni bir örneğini Decimal başlatır.

C#

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

Parametreler

lo

Int32

96 bitlik tamsayının düşük 32 biti.

mid

Int32

96 bitlik tamsayının orta 32 biti.

hi

Int32

96 bitlik tamsayının yüksek 32 biti.

isNegative

Boolean

true negatif bir sayı belirtmek için; false pozitif bir sayı belirtmek için.

scale

Byte

0 ile 28 arasında değişen 10 gücü.

Özel durumlar

ArgumentOutOfRangeException

scale 28'den büyük.

Örnekler

Aşağıdaki kod örneği, bir yapıyı üç Int32 değer sözcüğü, bir Boolean işaret ve Byte ölçek faktörüyle başlatan Decimal oluşturucu aşırı yüklemesini kullanarak birkaç Decimal sayı oluşturur.

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

Aşağıdaki örnek, bir dizinin bileşen bölümlerini almak için yöntemini kullanır GetBits . Daha sonra yeni Decimal bir değer örneği oluşturmak için oluşturucu çağrısında Decimal(Int32, Int32, Int32, Boolean, Byte) bu diziyi kullanır.

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

Açıklamalar

Bir Decimal sayının ikili gösterimi 1 bit işaretinden, 96 bitlik bir tamsayıdan ve tamsayı sayısını bölmek ve hangi bölümünün ondalık kesir olduğunu belirtmek için kullanılan ölçeklendirme faktöründen oluşur. Ölçeklendirme faktörü örtük olarak 10 sayısının 0 ile 28 arasında bir üs olarak yükseltilmesidir.