Decimal.Implicit Operator

Definition

Namespace:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Definiert eine implizite Konvertierung des Werts eines Typs in einen Decimal Wert.

Überlädt

Name	Beschreibung
Implicit(UInt16 to Decimal)	Definiert eine implizite Konvertierung einer 16-Bit-ganzzahligen 16-Bit-Ganzzahl in eine Decimal. Diese API ist nicht CLS-kompatibel.
Implicit(UInt64 to Decimal)	Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in eine Decimal. Diese API ist nicht CLS-kompatibel.
Implicit(UInt32 to Decimal)	Definiert eine implizite Konvertierung einer nicht signierten 32-Bit-Ganzzahl in eine Decimal. Diese API ist nicht CLS-kompatibel.
Implicit(SByte to Decimal)	Definiert eine implizite Konvertierung einer 8-Bit-ganzzahligen Vorzeichen in eine Decimal. Diese API ist nicht CLS-kompatibel.
Implicit(Int64 to Decimal)	Definiert eine implizite Konvertierung einer 64-Bit-ganzzahligen Vorzeichen in eine Decimal.
Implicit(Int32 to Decimal)	Definiert eine implizite Konvertierung einer 32-Bit-ganzzahligen Vorzeichen in eine Decimal.
Implicit(Int16 to Decimal)	Definiert eine implizite Konvertierung einer 16-Bit-ganzzahligen Vorzeichen in eine Decimal.
Implicit(Char to Decimal)	Definiert eine implizite Konvertierung eines Unicode-Zeichens in ein Decimal.
Implicit(Byte to Decimal)	Definiert eine implizite Konvertierung einer 8-Bit-Ganzzahl ohne Vorzeichen in eine Decimal.

Hinweise

Die Überladungen der Implicit-Methode definieren die Typen, aus denen der Compiler automatisch einen Decimal-Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keine OverflowException Ausnahme auslösen.

Implicit(UInt16 to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Definiert eine implizite Konvertierung einer 16-Bit-ganzzahligen 16-Bit-Ganzzahl in eine Decimal.

Diese API ist nicht CLS-kompatibel.

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

Die zu konvertierende 16-Bit-Ganzzahl ohne Vorzeichen.

Gibt zurück

Decimal

Die konvertierte 16-Bit-Ganzzahl ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Beispiele

Im folgenden Beispiel werden Werte in UInt16 Zahlen konvertiertDecimal.

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)

Hinweise

Weitere Informationen

UInt16

Gilt für:

Implicit(UInt64 to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in eine Decimal.

Diese API ist nicht CLS-kompatibel.

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

Die zu konvertierende 64-Bit-Ganzzahl ohne Vorzeichen.

Gibt zurück

Decimal

Die konvertierte 64-Bit-Ganzzahl ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Beispiele

Im folgenden Beispiel werden Werte mithilfe des UInt64 Decimal Konvertierungsoperators UInt64 in Decimal Zahlen konvertiert.

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)

Hinweise

Weitere Informationen

UInt64

Gilt für:

Implicit(UInt32 to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Definiert eine implizite Konvertierung einer nicht signierten 32-Bit-Ganzzahl in eine Decimal.

Diese API ist nicht CLS-kompatibel.

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

Die zu konvertierende 32-Bit-Ganzzahl ohne Vorzeichen.

Gibt zurück

Decimal

Die konvertierte 32-Bit-Ganzzahl ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Beispiele

Im folgenden Beispiel werden Werte in UInt32 Zahlen konvertiertDecimal.

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)

Hinweise

Weitere Informationen

UInt32

Gilt für:

Implicit(SByte to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Definiert eine implizite Konvertierung einer 8-Bit-ganzzahligen Vorzeichen in eine Decimal.

Diese API ist nicht CLS-kompatibel.

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

Die zu konvertierende 8-Bit-Ganzzahl mit Vorzeichen.

Gibt zurück

Decimal

Die konvertierte 8-Bit-Ganzzahl mit Vorzeichen.

Attribute: CLSCompliantAttribute

Beispiele

Im folgenden Beispiel werden Werte in SByte Zahlen konvertiertDecimal.

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)

Hinweise

Weitere Informationen

SByte

Gilt für:

Implicit(Int64 to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Definiert eine implizite Konvertierung einer 64-Bit-ganzzahligen Vorzeichen in eine 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

Die zu konvertierende 64-Bit-Ganzzahl mit Vorzeichen.

Gibt zurück

Decimal

Die konvertierte 64-Bit-Ganzzahl mit Vorzeichen.

Beispiele

Im folgenden Beispiel werden Werte in Int64 Zahlen konvertiertDecimal.

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)

Hinweise

Weitere Informationen

Int64

Gilt für:

Implicit(Int32 to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Definiert eine implizite Konvertierung einer 32-Bit-ganzzahligen Vorzeichen in eine 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

Die zu konvertierende 32-Bit-Ganzzahl mit Vorzeichen.

Gibt zurück

Decimal

Die konvertierte 32-Bit-Ganzzahl mit Vorzeichen.

Beispiele

Im folgenden Beispiel werden Werte in Int32 Zahlen konvertiertDecimal.

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)

Hinweise

Weitere Informationen

Int32

Gilt für:

Implicit(Int16 to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Definiert eine implizite Konvertierung einer 16-Bit-ganzzahligen Vorzeichen in eine 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

Die zu konvertierende 16-Bit-Ganzzahl.

Gibt zurück

Decimal

Die konvertierte 16-Bit-Ganzzahl mit Vorzeichen.

Beispiele

Im folgenden Beispiel werden Werte in Int16 Zahlen konvertiertDecimal. Diese Konvertierung erfordert den op_Implicit-Operator in Visual Basic, jedoch nicht in C#.

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)

Hinweise

Weitere Informationen

Int16

Gilt für:

Implicit(Char to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Definiert eine implizite Konvertierung eines Unicode-Zeichens in ein 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

Das zu konvertierende Unicode-Zeichen.

Gibt zurück

Decimal

Das konvertierte Unicode-Zeichen.

Beispiele

Im folgenden Beispiel werden Werte (Unicode-Zeichen) in Char Zahlen konvertiertDecimal. Diese Konvertierung erfordert den op_Implicit-Operator in Visual Basic, jedoch nicht in C#.

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)

Hinweise

Weitere Informationen

Char

Gilt für:

Implicit(Byte to Decimal)

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Quelle:: Decimal.cs

Definiert eine implizite Konvertierung einer 8-Bit-Ganzzahl ohne Vorzeichen in eine 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

Die zu konvertierende 8-Bit-Ganzzahl ohne Vorzeichen.

Gibt zurück

Decimal

Die konvertierte 8-Bit-Ganzzahl ohne Vorzeichen.

Beispiele

Im folgenden Beispiel werden Werte in Byte Zahlen konvertiertDecimal.

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)

Hinweise

Weitere Informationen

Byte

Gilt für:

Feedback

War diese Seite hilfreich?