Decimal.Implicit Operator

  • Referensi

Definisi

Ruang nama:
System
Rakitan:
System.Runtime.dll
Rakitan:
mscorlib.dll
Rakitan:
netstandard.dll

Menentukan konversi implisit dari nilai jenis menjadi Decimal nilai.

Overload

Implicit(UInt16 to Decimal)

Menentukan konversi implisit dari bilangan bulat yang tidak ditandatangani 16-bit ke Decimal.

API ini bukan kompatibel CLS.
Implicit(UInt64 to Decimal)

Mendefinisikan konversi implisit dari bilangan bulat yang tidak ditandatangani 64-bit ke Decimal.

API ini bukan kompatibel CLS.
Implicit(UInt32 to Decimal)

Menentukan konversi implisit dari bilangan bulat yang tidak ditandatangani 32-bit ke Decimal.

API ini bukan kompatibel CLS.
Implicit(Int64 to Decimal)

Menentukan konversi implisit dari bilangan bulat bertanda tangan 64-bit ke Decimal.
Implicit(SByte to Decimal)

Menentukan konversi implisit dari bilangan bulat bertanda tangan 8-bit ke Decimal.

API ini bukan kompatibel CLS.
Implicit(Int16 to Decimal)

Menentukan konversi implisit dari bilangan bulat bertanda tangan 16-bit ke Decimal.
Implicit(Char to Decimal)

Mendefinisikan konversi implisit dari karakter Unicode ke Decimal.
Implicit(Byte to Decimal)

Menentukan konversi implisit dari bilangan bulat yang tidak ditandatangani 8-bit ke Decimal.
Implicit(Int32 to Decimal)

Menentukan konversi implisit dari bilangan bulat bertanda tangan 32-bit ke Decimal.

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Implicit(UInt16 to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Penting

API ini bukan kompatibel CLS.

Menentukan konversi implisit dari bilangan bulat yang tidak ditandatangani 16-bit ke Decimal.

API ini bukan kompatibel CLS.

public:
 static operator System::Decimal(System::UInt16 value);
[System.CLSCompliant(false)]
public static implicit operator decimal (ushort value);
[<System.CLSCompliant(false)>]
static member op_Implicit : uint16 -> decimal
Public Shared Widening Operator CType (value As UShort) As Decimal

Parameter

value
UInt16

Bilangan bulat 16-bit yang tidak ditandatangani untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat tidak bertanda 16-bit yang dikonversi.

Atribut
CLSCompliantAttribute

Contoh

Contoh berikut mengonversi UInt16 nilai menjadi Decimal angka.

using namespace System;

void main()
{
     // Define an array of 16-bit unsigned integer values.
     array<UInt16>^ values = { UInt16::MinValue, UInt16::MaxValue,     
                               0xFFF, 12345, 40000 };
     // Convert each value to a Decimal.
     for each (UInt16 value in values) {
        Decimal decValue = value;
        Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                           value.GetType()->Name, decValue,
                           decValue.GetType()->Name);         
     }
}
// The example displays the following output:
//       0 (UInt16) --> 0 (Decimal)
//       65535 (UInt16) --> 65535 (Decimal)
//       4095 (UInt16) --> 4095 (Decimal)
//       12345 (UInt16) --> 12345 (Decimal)
//       40000 (UInt16) --> 40000 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 16-bit unsigned integer values.
        ushort[] values = { ushort.MinValue, ushort.MaxValue,
                            0xFFF, 12345, 40000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (UInt16) --> 0 (Decimal)
//       65535 (UInt16) --> 65535 (Decimal)
//       4095 (UInt16) --> 4095 (Decimal)
//       12345 (UInt16) --> 12345 (Decimal)
//       40000 (UInt16) --> 40000 (Decimal)

open System

// Define a list of 16-bit unsigned integer values.
let values = 
    [ UInt16.MinValue; UInt16.MaxValue; 0xFFFus; 12345us; 40000us ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//       0 (UInt16) --> 0 (Decimal)
//       65535 (UInt16) --> 65535 (Decimal)
//       4095 (UInt16) --> 4095 (Decimal)
//       12345 (UInt16) --> 12345 (Decimal)
//       40000 (UInt16) --> 40000 (Decimal)

Module Example
    Public Sub Main()
        ' Define an array of 16-bit unsigned integer values.
        Dim values() As Decimal = { UShort.MinValue, UShort.MaxValue,     
                                    &hFFF, 12345, 40000 }
        ' Convert each value to a Decimal.
        For Each value In values
           Dim decValue As Decimal = value
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)         
        Next
    End Sub 
End Module
' The example displays the following output:
'       0 (Decimal) --> 0 (Decimal)
'       65535 (Decimal) --> 65535 (Decimal)
'       4095 (Decimal) --> 4095 (Decimal)
'       12345 (Decimal) --> 12345 (Decimal)
'       40000 (Decimal) --> 40000 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(UInt64 to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Penting

API ini bukan kompatibel CLS.

Mendefinisikan konversi implisit dari bilangan bulat yang tidak ditandatangani 64-bit ke Decimal.

API ini bukan kompatibel CLS.

public:
 static operator System::Decimal(System::UInt64 value);
[System.CLSCompliant(false)]
public static implicit operator decimal (ulong value);
[<System.CLSCompliant(false)>]
static member op_Implicit : uint64 -> decimal
Public Shared Widening Operator CType (value As ULong) As Decimal

Parameter

value
UInt64

Bilangan bulat 64-bit yang tidak ditandatangani untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat yang tidak ditandatangani 64-bit yang dikonversi.

Atribut
CLSCompliantAttribute

Contoh

Contoh berikut mengonversi UInt64 nilai menjadi Decimal angka dengan menggunakan UInt64 operator ke Decimal konversi.

using namespace System;

void main()
{
     // Define an array of 64-bit unsigned integer values.
     array<UInt64>^ values = { UInt64::MinValue, UInt64::MaxValue, 
                               0xFFFFFFFFFFFF, 123456789123456789, 
                               1000000000000000 };
     // Convert each value to a Decimal.
     for each (UInt64 value in values) {
        Decimal decValue = value;
        Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                           value.GetType()->Name, decValue,
                           decValue.GetType()->Name);         
     }
}
// The example displays the following output:
//    0 (UInt64) --> 0 (Decimal)
//    18446744073709551615 (UInt64) --> 18446744073709551615 (Decimal)
//    281474976710655 (UInt64) --> 281474976710655 (Decimal)
//    123456789123456789 (UInt64) --> 123456789123456789 (Decimal)
//    1000000000000000 (UInt64) --> 1000000000000000 (Decimal)

using System;

public class Example
{
    public static void Main()
    {
        // Define an array of 64-bit unsigned integer values.
        ulong[] values = { ulong.MinValue, ulong.MaxValue,
                           0xFFFFFFFFFFFF, 123456789123456789,
                           1000000000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    0 (UInt64) --> 0 (Decimal)
//    18446744073709551615 (UInt64) --> 18446744073709551615 (Decimal)
//    281474976710655 (UInt64) --> 281474976710655 (Decimal)
//    123456789123456789 (UInt64) --> 123456789123456789 (Decimal)
//    1000000000000000 (UInt64) --> 1000000000000000 (Decimal)

open System

// Define a list of 64-bit unsigned integer values.
let values = 
    [ UInt64.MinValue; UInt64.MaxValue; 0xFFFFFFFFFFFFuL; 123456789123456789uL; 1000000000000000uL ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//    0 (UInt64) --> 0 (Decimal)
//    18446744073709551615 (UInt64) --> 18446744073709551615 (Decimal)
//    281474976710655 (UInt64) --> 281474976710655 (Decimal)
//    123456789123456789 (UInt64) --> 123456789123456789 (Decimal)
//    1000000000000000 (UInt64) --> 1000000000000000 (Decimal)

Module Example
    Public Sub Main()
        Dim values() As ULong = { ULong.MinValue, ULong.MaxValue, 
                           &hFFFFFFFFFFFF, 123456789123456789, 
                           1000000000000000 }
        For Each value In values
           Dim decValue As Decimal = value
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)
        Next                              
    End Sub 
End Module
' The example displays the following output:
'    0 (UInt64) --> 0 (Decimal)
'    18446744073709551615 (UInt64) --> 18446744073709551615 (Decimal)
'    281474976710655 (UInt64) --> 281474976710655 (Decimal)
'    123456789123456789 (UInt64) --> 123456789123456789 (Decimal)
'    1000000000000000 (UInt64) --> 1000000000000000 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(UInt32 to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Penting

API ini bukan kompatibel CLS.

Menentukan konversi implisit dari bilangan bulat yang tidak ditandatangani 32-bit ke Decimal.

API ini bukan kompatibel CLS.

public:
 static operator System::Decimal(System::UInt32 value);
[System.CLSCompliant(false)]
public static implicit operator decimal (uint value);
[<System.CLSCompliant(false)>]
static member op_Implicit : uint32 -> decimal
Public Shared Widening Operator CType (value As UInteger) As Decimal

Parameter

value
UInt32

Bilangan bulat 32-bit yang tidak ditandatangani untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat yang tidak ditandatangani 32-bit yang dikonversi.

Atribut
CLSCompliantAttribute

Contoh

Contoh berikut mengonversi UInt32 nilai menjadi Decimal angka.

using namespace System;

void main()
{
     // Define an array of 32-bit unsigned integer values.
     array<UInt32>^ values = { UInt32::MinValue, UInt32::MaxValue, 
                               0xFFFFFF, 123456789, 4000000000 };
     // Convert each value to a Decimal.
     for each (UInt32 value in values) {
        Decimal decValue = value;
        Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                          value.GetType()->Name, decValue,
                          decValue.GetType()->Name); 
     }                            
}
// The example displays the following output:
//       0 (UInt32) --> 0 (Decimal)
//       4294967295 (UInt32) --> 4294967295 (Decimal)
//       16777215 (UInt32) --> 16777215 (Decimal)
//       123456789 (UInt32) --> 123456789 (Decimal)
//       4000000000 (UInt32) --> 4000000000 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 32-bit unsigned integer values.
        uint[] values = { uint.MinValue, uint.MaxValue, 0xFFFFFF,
                          123456789, 4000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (UInt32) --> 0 (Decimal)
//       4294967295 (UInt32) --> 4294967295 (Decimal)
//       16777215 (UInt32) --> 16777215 (Decimal)
//       123456789 (UInt32) --> 123456789 (Decimal)
//       4000000000 (UInt32) --> 4000000000 (Decimal)

open System

// Define a list of 32-bit unsigned integer values.
let values = 
    [ UInt32.MinValue; UInt32.MaxValue; 0xFFFFFFu; 123456789u; 4000000000u ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//       0 (UInt32) --> 0 (Decimal)
//       4294967295 (UInt32) --> 4294967295 (Decimal)
//       16777215 (UInt32) --> 16777215 (Decimal)
//       123456789 (UInt32) --> 123456789 (Decimal)
//       4000000000 (UInt32) --> 4000000000 (Decimal)

Module Example
    Public Sub Main()
        ' Define an array of 32-bit unsigned integer values.
        Dim values() As UInteger = { UInteger.MinValue, UInteger.MaxValue, 
                                     &hFFFFFF, 123456789, 4000000000 }
        For Each value In values
           Dim decValue As Decimal = value
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)           
        Next   
    End Sub 
End Module
' The example displays the following output:
'       0 (UInt32) --> 0 (Decimal)
'       4294967295 (UInt32) --> 4294967295 (Decimal)
'       16777215 (UInt32) --> 16777215 (Decimal)
'       123456789 (UInt32) --> 123456789 (Decimal)
'       4000000000 (UInt32) --> 4000000000 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(Int64 to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Menentukan konversi implisit dari bilangan bulat bertanda tangan 64-bit ke Decimal.

public:
 static operator System::Decimal(long value);
public static implicit operator decimal (long value);
static member op_Implicit : int64 -> decimal
Public Shared Widening Operator CType (value As Long) As Decimal

Parameter

value
Int64

Bilangan bulat bertanda tangan 64-bit untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat bertanda tangan 64-bit yang dikonversi.

Contoh

Contoh berikut mengonversi Int64 nilai menjadi Decimal angka.

using namespace System;

void main()
{
        // Define an array of 64-bit integer values.
        array<Int64>^ values = { Int64::MinValue, Int64::MaxValue, 
                                 0xFFFFFFFFFFFF, 123456789123456789,
                                 -1000000000000000 };
        // Convert each value to a Decimal.
        for each (Int64 value in values) {
           Decimal decValue = value;
           Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                              value.GetType()->Name, decValue,
                              decValue.GetType()->Name);         
        }
}
// The example displays the following output:
//    -9223372036854775808 (Int64) --> -9223372036854775808 (Decimal)
//    9223372036854775807 (Int64) --> 9223372036854775807 (Decimal)
//    281474976710655 (Int64) --> 281474976710655 (Decimal)
//    123456789123456789 (Int64) --> 123456789123456789 (Decimal)
//    -1000000000000000 (Int64) --> -1000000000000000 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 64-bit integer values.
        long[] values = { long.MinValue, long.MaxValue,
                          0xFFFFFFFFFFFF, 123456789123456789,
                          -1000000000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    -9223372036854775808 (Int64) --> -9223372036854775808 (Decimal)
//    9223372036854775807 (Int64) --> 9223372036854775807 (Decimal)
//    281474976710655 (Int64) --> 281474976710655 (Decimal)
//    123456789123456789 (Int64) --> 123456789123456789 (Decimal)
//    -1000000000000000 (Int64) --> -1000000000000000 (Decimal)

open System

// Define a list of 64-bit integer values.
let values = 
    [ Int64.MinValue; Int64.MaxValue; 0xFFFFFFFFFFFFL; 123456789123456789L; -1000000000000000L ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//    -9223372036854775808 (Int64) --> -9223372036854775808 (Decimal)
//    9223372036854775807 (Int64) --> 9223372036854775807 (Decimal)
//    281474976710655 (Int64) --> 281474976710655 (Decimal)
//    123456789123456789 (Int64) --> 123456789123456789 (Decimal)
//    -1000000000000000 (Int64) --> -1000000000000000 (Decimal)

Module Example
    Public Sub Main()
        ' Define an array of 64-bit integer values.
        Dim values() As Long = { Long.MinValue, Long.MaxValue, 
                                 &hFFFFFFFFFFFF, 123456789123456789,
                                 -1000000000000000 }
        ' Convert each value to a Decimal.
        For Each value In values
           Dim decValue As Decimal = value
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)
        Next
    End Sub 
End Module
' The example displays the following output:
'    -9223372036854775808 (Int64) --> -9223372036854775808 (Decimal)
'    9223372036854775807 (Int64) --> 9223372036854775807 (Decimal)
'    281474976710655 (Int64) --> 281474976710655 (Decimal)
'    123456789123456789 (Int64) --> 123456789123456789 (Decimal)
'    -1000000000000000 (Int64) --> -1000000000000000 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(SByte to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Penting

API ini bukan kompatibel CLS.

Menentukan konversi implisit dari bilangan bulat bertanda tangan 8-bit ke Decimal.

API ini bukan kompatibel CLS.

public:
 static operator System::Decimal(System::SByte value);
[System.CLSCompliant(false)]
public static implicit operator decimal (sbyte value);
[<System.CLSCompliant(false)>]
static member op_Implicit : sbyte -> decimal
Public Shared Widening Operator CType (value As SByte) As Decimal

Parameter

value
SByte

Bilangan bulat bertanda tangan 8-bit untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat bertanda tangan 8-bit yang dikonversi.

Atribut
CLSCompliantAttribute

Contoh

Contoh berikut mengonversi SByte nilai menjadi Decimal angka.

using namespace System;

void main()
{
     // Define an array of 8-bit signed integer values.
     array<SByte>^ values = { SByte::MinValue, SByte::MaxValue,     
                              0x3F, 123, -100 };
     // Convert each value to a Decimal.
     for each (SByte value in values) {
        Decimal decValue = value;
        Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                          value.GetType()->Name, decValue,
                          decValue.GetType()->Name);         
     }
}
// The example displays the following output:
//       -128 (SByte) --> -128 (Decimal)
//       127 (SByte) --> 127 (Decimal)
//       63 (SByte) --> 63 (Decimal)
//       123 (SByte) --> 123 (Decimal)
//       -100 (SByte) --> -100 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 8-bit signed integer values.
        sbyte[] values = { sbyte.MinValue, sbyte.MaxValue,
                           0x3F, 123, -100 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    -128 (SByte) --> -128 (Decimal)
//    127 (SByte) --> 127 (Decimal)
//    63 (SByte) --> 63 (Decimal)
//    123 (SByte) --> 123 (Decimal)
//    -100 (SByte) --> -100 (Decimal)

open System

// Define a list of 8-bit signed integer values.
let values = 
    [ SByte.MinValue; SByte.MaxValue; 0x3Fy; 123y; -100y ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//    -128 (SByte) --> -128 (Decimal)
//    127 (SByte) --> 127 (Decimal)
//    63 (SByte) --> 63 (Decimal)
//    123 (SByte) --> 123 (Decimal)
//    -100 (SByte) --> -100 (Decimal)

Module Example
    Public Sub Main()
        ' Define an array of 8-bit signed integer values.
        Dim values() As SByte = { SByte.MinValue, SByte.MaxValue,     
                                  &h3F, 123, -100 }
        ' Convert each value to a Decimal.
        For Each value In values
           Dim decValue As Decimal = value
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)
        Next                         
    End Sub
End Module
' The example displays the following output:
'       -128 (SByte) --> -128 (Decimal)
'       127 (SByte) --> 127 (Decimal)
'       63 (SByte) --> 63 (Decimal)
'       123 (SByte) --> 123 (Decimal)
'       -100 (SByte) --> -100 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(Int16 to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Menentukan konversi implisit dari bilangan bulat bertanda tangan 16-bit ke Decimal.

public:
 static operator System::Decimal(short value);
public static implicit operator decimal (short value);
static member op_Implicit : int16 -> decimal
Public Shared Widening Operator CType (value As Short) As Decimal

Parameter

value
Int16

Bilangan bulat bertanda tangan 16-bit untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat bertanda 16-bit yang dikonversi.

Contoh

Contoh berikut mengonversi Int16 nilai menjadi Decimal angka. Konversi ini memerlukan operator op_Implicit di Visual Basic, tetapi tidak di C# dan C++.

using namespace System;

void main()
{
     // Define an array of 16-bit integer values.
     array<Int16>^ values = { Int16::MinValue, Int16::MaxValue, 
                              0xFFF, 12345, -10000 };   
     // Convert each value to a Decimal.
     for each (Int16 value in values) {
        Decimal decValue = value;
        Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                          value.GetType()->Name, decValue,
                          decValue.GetType()->Name);         
     }
}
// The example displays the following output:
//    -32768 (Int16) --> -32768 (Decimal)
//    32767 (Int16) --> 32767 (Decimal)
//    4095 (Int16) --> 4095 (Decimal)
//    12345 (Int16) --> 12345 (Decimal)
//    -10000 (Int16) --> -10000 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 16-bit integer values.
        short[] values = { short.MinValue, short.MaxValue,
                           0xFFF, 12345, -10000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       -32768 (Int16) --> -32768 (Decimal)
//       32767 (Int16) --> 32767 (Decimal)
//       4095 (Int16) --> 4095 (Decimal)
//       12345 (Int16) --> 12345 (Decimal)
//       -10000 (Int16) --> -10000 (Decimal)

open System

// Define a list of 16-bit integer values.
let values = 
    [ Int16.MinValue; Int16.MaxValue; 0xFFFs; 12345s; -10000s ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//       -32768 (Int16) --> -32768 (Decimal)
//       32767 (Int16) --> 32767 (Decimal)
//       4095 (Int16) --> 4095 (Decimal)
//       12345 (Int16) --> 12345 (Decimal)
//       -10000 (Int16) --> -10000 (Decimal)

Module Example
    Public Sub Main()
        ' Define an array of 16-bit integer values.
        Dim values() As Short = { Short.MinValue, Short.MaxValue, 
                                  &hFFF, 12345, -10000 }   
        ' Convert each value to a Decimal.
        For Each value In values
           Dim decValue As Decimal = value
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)         
        Next
    End Sub 
End Module
' The example displays the following output:
'    -32768 (Int16) --> -32768 (Decimal)
'    32767 (Int16) --> 32767 (Decimal)
'    4095 (Int16) --> 4095 (Decimal)
'    12345 (Int16) --> 12345 (Decimal)
'    -10000 (Int16) --> -10000 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(Char to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Mendefinisikan konversi implisit dari karakter Unicode ke Decimal.

public:
 static operator System::Decimal(char value);
public static implicit operator decimal (char value);
static member op_Implicit : char -> decimal
Public Shared Widening Operator CType (value As Char) As Decimal

Parameter

value
Char

Karakter Unicode yang akan dikonversi.

Mengembalikan

Decimal

Karakter Unicode yang dikonversi.

Contoh

Contoh berikut mengonversi Char nilai (karakter Unicode) menjadi Decimal angka. Konversi ini memerlukan operator op_Implicit di Visual Basic, tetapi tidak di C# dan C++.

using namespace System;

void main()
{
     // Define an array of Char values.
     array<Char>^ values = { L'\0', L' ', L'*', L'A', L'a', 
                             L'{', L'Æ' };

     // Convert each Char value to a Decimal.
     for each (wchar_t value in values) {
        Decimal decValue = value;
        Console::WriteLine("'{0}' ({1}) --> {2} ({3})", value,
                           value.GetType()->Name, decValue,
                           decValue.GetType()->Name); 
     }    
}
// This example displays the following output:
//       ' ' (Decimal) --> 0 (Decimal)
//       ' ' (Decimal) --> 32 (Decimal)
//       '*' (Decimal) --> 42 (Decimal)
//       'A' (Decimal) --> 65 (Decimal)
//       'a' (Decimal) --> 97 (Decimal)
//       '{' (Decimal) --> 123 (Decimal)
//       'A' (Decimal) --> 195 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of Char values.
        Char[] values = { '\0', ' ', '*', 'A', 'a', '{', 'Æ' };

        // Convert each Char value to a Decimal.
        foreach (var value in values) {
           decimal decValue = value;
           Console.WriteLine("'{0}' ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       ' ' (Char) --> 0 (Decimal)
//       ' ' (Char) --> 32 (Decimal)
//       '*' (Char) --> 42 (Decimal)
//       'A' (Char) --> 65 (Decimal)
//       'a' (Char) --> 97 (Decimal)
//       '{' (Char) --> 123 (Decimal)
//       'Æ' (Char) --> 198 (Decimal)

// Define a list of Char values.
let values = [ '\000'; ' '; '*'; 'A'; 'a'; '{'; 'Æ' ]

// Convert each Char value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"'{value}' ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//       ' ' (Char) --> 0 (Decimal)
//       ' ' (Char) --> 32 (Decimal)
//       '*' (Char) --> 42 (Decimal)
//       'A' (Char) --> 65 (Decimal)
//       'a' (Char) --> 97 (Decimal)
//       '{' (Char) --> 123 (Decimal)
//       'Æ' (Char) --> 198 (Decimal)

Module Example
    Public Sub Main()
        ' Define an array of Char values.
        Dim values() As Char = { ChrW(0), " "c, "*"c, "A"c, "a"c, 
                                 "{"c, "Æ"c }

        ' Convert each Char value to a Decimal.
        For Each value In values
           Dim decValue As Decimal = Decimal.op_Implicit(value)
           Console.WriteLine("'{0}' ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)      
        Next
    End Sub 
End Module
' The example displays the following output:
'       ' ' (Char) --> 0 (Decimal)
'       ' ' (Char) --> 32 (Decimal)
'       '*' (Char) --> 42 (Decimal)
'       'A' (Char) --> 65 (Decimal)
'       'a' (Char) --> 97 (Decimal)
'       '{' (Char) --> 123 (Decimal)
'       'Æ' (Char) --> 198 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(Byte to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Menentukan konversi implisit dari bilangan bulat yang tidak ditandatangani 8-bit ke Decimal.

public:
 static operator System::Decimal(System::Byte value);
public static implicit operator decimal (byte value);
static member op_Implicit : byte -> decimal
Public Shared Widening Operator CType (value As Byte) As Decimal

Parameter

value
Byte

Bilangan bulat 8-bit yang tidak ditandatangani untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat yang tidak ditandatangani 8-bit yang dikonversi.

Contoh

Contoh berikut mengonversi Byte nilai menjadi Decimal angka.

using namespace System;

void main()
{
    // Define an array of byte values.
    array<Byte>^ values = { Byte::MinValue, Byte::MaxValue, 
                            0x3F, 123, 200 };   
    // Convert each value to a Decimal.
    for each (Byte value in values) {
        Decimal decValue = value;
        Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType()->Name, decValue,
                             decValue.GetType()->Name);         
    }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Decimal)
//       255 (Byte) --> 255 (Decimal)
//       63 (Byte) --> 63 (Decimal)
//       123 (Byte) --> 123 (Decimal)
//       200 (Byte) --> 200 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of byte values.
        byte[] values = { byte.MinValue, byte.MaxValue,
                          0x3F, 123, 200 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Decimal)
//       255 (Byte) --> 255 (Decimal)
//       63 (Byte) --> 63 (Decimal)
//       123 (Byte) --> 123 (Decimal)
//       200 (Byte) --> 200 (Decimal)

open System

// Define a list of byte values.
let values = 
    [ Byte.MinValue; Byte.MaxValue; 0x3Fuy; 123uy; 200uy ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//       0 (Byte) --> 0 (Decimal)
//       255 (Byte) --> 255 (Decimal)
//       63 (Byte) --> 63 (Decimal)
//       123 (Byte) --> 123 (Decimal)
//       200 (Byte) --> 200 (Decimal)

Module Example
    Public Sub Main
        ' Define an array of byte values.
        Dim values() As Byte = { Byte.MinValue, Byte.MaxValue, 
                                 &h3F, 123, 200 }   
        ' Convert each value to a Decimal.
        For Each value In values
           Dim decValue As Decimal = value
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name)                   
        Next   
    End Sub 
End Module
' The example displays the following output:
'       0 (Byte) --> 0 (Decimal)
'       255 (Byte) --> 255 (Decimal)
'       63 (Byte) --> 63 (Decimal)
'       123 (Byte) --> 123 (Decimal)
'       200 (Byte) --> 200 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk

Implicit(Int32 to Decimal)

Sumber:
Decimal.cs
Sumber:
Decimal.cs
Sumber:
Decimal.cs

Menentukan konversi implisit dari bilangan bulat bertanda tangan 32-bit ke Decimal.

public:
 static operator System::Decimal(int value);
public static implicit operator decimal (int value);
static member op_Implicit : int -> decimal
Public Shared Widening Operator CType (value As Integer) As Decimal

Parameter

value
Int32

Bilangan bulat bertanda tangan 32-bit untuk dikonversi.

Mengembalikan

Decimal

Bilangan bulat bertanda tangan 32-bit yang dikonversi.

Contoh

Contoh berikut mengonversi Int32 nilai menjadi Decimal angka.

using namespace System;

void main()
{
    // Define an array of 32-bit integer values.
    array<Int32>^ values = { Int32::MinValue, Int32::MaxValue, 
                             0xFFFFFF, 123456789, -1000000000 };
    // Convert each value to a Decimal.
    for each (Int32 value in values) {
        Decimal decValue = value;
        Console::WriteLine("{0} ({1}) --> {2} ({3})", value,
                          value.GetType()->Name, decValue,
                          decValue.GetType()->Name);
    }                               
}
// The example displays the following output:
//    -2147483648 (Int32) --> -2147483648 (Decimal)
//    2147483647 (Int32) --> 2147483647 (Decimal)
//    16777215 (Int32) --> 16777215 (Decimal)
//    123456789 (Int32) --> 123456789 (Decimal)
//    -1000000000 (Int32) --> -1000000000 (Decimal)

using System;

class Example
{
    public static void Main()
    {
        // Define an array of 32-bit integer values.
        int[] values = { int.MinValue, int.MaxValue, 0xFFFFFF,
                         123456789, -1000000000 };
        // Convert each value to a Decimal.
        foreach (var value in values) {
           Decimal decValue = value;
           Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                             value.GetType().Name, decValue,
                             decValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    -2147483648 (Int32) --> -2147483648 (Decimal)
//    2147483647 (Int32) --> 2147483647 (Decimal)
//    16777215 (Int32) --> 16777215 (Decimal)
//    123456789 (Int32) --> 123456789 (Decimal)
//    -1000000000 (Int32) --> -1000000000 (Decimal)

open System

// Define a list of 32-bit integer values.
let values = 
    [ Int32.MinValue; Int32.MaxValue; 0xFFFFFF; 123456789; -1000000000 ]

// Convert each value to a Decimal.
for value in values do
    let decValue: decimal = value
    printfn $"{value} ({value.GetType().Name}) --> {decValue} ({decValue.GetType().Name})"

// The example displays the following output:
//    -2147483648 (Int32) --> -2147483648 (Decimal)
//    2147483647 (Int32) --> 2147483647 (Decimal)
//    16777215 (Int32) --> 16777215 (Decimal)
//    123456789 (Int32) --> 123456789 (Decimal)
//    -1000000000 (Int32) --> -1000000000 (Decimal)

Module Example
    Public Sub Main()
       ' Define an array of 32-bit integer values.
       Dim values() As Integer = { Integer.MinValue, Integer.MaxValue, 
                                   &hFFFFFF, 123456789, -1000000000 }
       ' Convert each value to a Decimal.
       For Each value In values
          Dim decValue As Decimal = value 
          Console.WriteLine("{0} ({1}) --> {2} ({3})", value,
                            value.GetType().Name, decValue,
                            decValue.GetType().Name)
       Next                     
    End Sub 
End Module
' The example displays the following output:
'       -2147483648 (Int32) --> -2147483648 (Decimal)
'       2147483647 (Int32) --> 2147483647 (Decimal)
'       16777215 (Int32) --> 16777215 (Decimal)
'       123456789 (Int32) --> 123456789 (Decimal)
'       -1000000000 (Int32) --> -1000000000 (Decimal)

Keterangan

Kelebihan beban Implicit metode menentukan jenis tempat pengkompilasi dapat secara otomatis mengonversi Decimal nilai tanpa operator transmisi eksplisit (dalam C#) atau panggilan ke fungsi konversi (di Visual Basic). Mereka adalah konversi pelebaran yang tidak melibatkan kehilangan data dan tidak melemparkan OverflowException pengecualian.

Lihat juga

Berlaku untuk