Decimal.Implicit 操作员

定义

命名空间:

System

程序集:

netstandard.dll, System.Runtime.dll

定义从类型值到 Decimal 值的隐式转换。

重载

Implicit(UInt16 to Decimal)	定义从 16 位无符号整数到 Decimal 的隐式转换。 此 API 不兼容 CLS。
Implicit(UInt64 to Decimal)	定义从 64 位无符号整数到 Decimal 的隐式转换。 此 API 不兼容 CLS。
Implicit(UInt32 to Decimal)	定义从 32 位无符号整数到 Decimal 的隐式转换。 此 API 不兼容 CLS。
Implicit(SByte to Decimal)	定义从 8 位有符号整数到 Decimal 值的隐式转换。 此 API 不兼容 CLS。
Implicit(Int64 to Decimal)	定义从 64 位有符号整数到 Decimal 的隐式转换。
Implicit(Int32 to Decimal)	定义从 32 位有符号整数到 Decimal 的隐式转换。
Implicit(Int16 to Decimal)	定义从 16 位有符号整数到 Decimal 的隐式转换。
Implicit(Char to Decimal)	定义从 Unicode 字符到 Decimal 的隐式转换。
Implicit(Byte to Decimal)	定义从 8 位无符号整数到 Decimal 的隐式转换。

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

Implicit(UInt16 to Decimal)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

定义从 16 位无符号整数到 Decimal 的隐式转换。

此 API 不兼容 CLS。

C#

[System.CLSCompliant(false)]
public static implicit operator decimal(ushort value);

参数

value

UInt16

要转换的 16 位无符号整数。

返回

Decimal

已转换的 16 位无符号整数。

属性

CLSCompliantAttribute

示例

以下示例将 UInt16 值转换为 Decimal 数字。

C#

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• UInt16

Implicit(UInt64 to Decimal)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

定义从 64 位无符号整数到 Decimal 的隐式转换。

此 API 不兼容 CLS。

C#

[System.CLSCompliant(false)]
public static implicit operator decimal(ulong value);

参数

value

UInt64

要转换的 64 位无符号整数。

返回

Decimal

已转换的 64 位无符号整数。

属性

CLSCompliantAttribute

示例

以下示例使用 UInt64Decimal to 转换UInt64运算符将值Decimal转换为数字。

C#

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• UInt64

Implicit(UInt32 to Decimal)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

定义从 32 位无符号整数到 Decimal 的隐式转换。

此 API 不兼容 CLS。

C#

[System.CLSCompliant(false)]
public static implicit operator decimal(uint value);

参数

value

UInt32

要转换的 32 位无符号整数。

返回

Decimal

已转换的 32 位无符号整数。

属性

CLSCompliantAttribute

示例

以下示例将 UInt32 值转换为 Decimal 数字。

C#

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• UInt32

Implicit(SByte to Decimal)

Source:

Decimal.cs

重要

此 API 不符合 CLS。

定义从 8 位有符号整数到 Decimal 值的隐式转换。

此 API 不兼容 CLS。

C#

[System.CLSCompliant(false)]
public static implicit operator decimal(sbyte value);

参数

value

SByte

要转换的 8 位带符号整数。

返回

Decimal

转换后的 8 位有符号整数。

属性

CLSCompliantAttribute

示例

以下示例将 SByte 值转换为 Decimal 数字。

C#

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• SByte

Implicit(Int64 to Decimal)

Source:

Decimal.cs

定义从 64 位有符号整数到 Decimal 的隐式转换。

C#

public static implicit operator decimal(long value);

参数

value

Int64

要转换的 64 位带符号整数。

返回

Decimal

转换后的 64 位有符号整数。

示例

以下示例将 Int64 值转换为 Decimal 数字。

C#

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• Int64

Implicit(Int32 to Decimal)

Source:

Decimal.cs

定义从 32 位有符号整数到 Decimal 的隐式转换。

C#

public static implicit operator decimal(int value);

参数

value

Int32

要转换的 32 位带符号整数。

返回

Decimal

转换后的 32 位有符号整数。

示例

以下示例将 Int32 值转换为 Decimal 数字。

C#

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• Int32

Implicit(Int16 to Decimal)

Source:

Decimal.cs

定义从 16 位有符号整数到 Decimal 的隐式转换。

C#

public static implicit operator decimal(short value);

参数

value

Int16

要转换的 16 位带符号整数。

返回

Decimal

转换后的 16 位有符号整数。

示例

以下示例将 Int16 值转换为 Decimal 数字。 此转换需要在 Visual Basic 中使用 op_Implicit 运算符，但在 C# 和 C++ 中则不需要。

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• Int16

Implicit(Char to Decimal)

Source:

Decimal.cs

定义从 Unicode 字符到 Decimal 的隐式转换。

C#

public static implicit operator decimal(char value);

参数

value

Char

要转换的 Unicode 字符。

返回

Decimal

转换后的 Unicode 字符。

示例

以下示例将 Char unicode 字符 (值) 转换为 Decimal 数字。 此转换需要在 Visual Basic 中使用 op_Implicit 运算符，但在 C# 和 C++ 中则不需要。

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• Char

Implicit(Byte to Decimal)

Source:

Decimal.cs

定义从 8 位无符号整数到 Decimal 的隐式转换。

C#

public static implicit operator decimal(byte value);

参数

value

Byte

要转换的 8 位无符号整数。

返回

Decimal

已转换的 8 位无符号整数。

示例

以下示例将 Byte 值转换为 Decimal 数字。

C#

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)

注解

方法的 Implicit 重载定义类型，编译器可以从中自动转换 Decimal 值的类型，而无需在 C# ) 中 (显式强制转换运算符或调用 Visual Basic) 中 (转换函数。 它们正在扩大不涉及数据丢失且不引发异常的 OverflowException 转换。

另请参阅

• Byte