Decimal.Implicit Operator
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Defines an implicit conversion of the value of a type to a Decimal value.
Implicit(UInt16 to Decimal) |
Defines an implicit conversion of a 16-bit unsigned integer to a Decimal. This API is not CLS-compliant. |
Implicit(UInt64 to Decimal) |
Defines an implicit conversion of a 64-bit unsigned integer to a Decimal. This API is not CLS-compliant. |
Implicit(UInt32 to Decimal) |
Defines an implicit conversion of a 32-bit unsigned integer to a Decimal. This API is not CLS-compliant. |
Implicit(SByte to Decimal) |
Defines an implicit conversion of an 8-bit signed integer to a Decimal. This API is not CLS-compliant. |
Implicit(Int64 to Decimal) |
Defines an implicit conversion of a 64-bit signed integer to a Decimal. |
Implicit(Int32 to Decimal) |
Defines an implicit conversion of a 32-bit signed integer to a Decimal. |
Implicit(Int16 to Decimal) |
Defines an implicit conversion of a 16-bit signed integer to a Decimal. |
Implicit(Char to Decimal) |
Defines an implicit conversion of a Unicode character to a Decimal. |
Implicit(Byte to Decimal) |
Defines an implicit conversion of an 8-bit unsigned integer to a Decimal. |
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Important
This API is not CLS-compliant.
Defines an implicit conversion of a 16-bit unsigned integer to a Decimal.
This API is not CLS-compliant.
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
Parameters
- value
- UInt16
The 16-bit unsigned integer to convert.
Returns
The converted 16-bit unsigned integer.
- Attributes
Examples
The following example converts UInt16 values to Decimal numbers.
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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Important
This API is not CLS-compliant.
Defines an implicit conversion of a 64-bit unsigned integer to a Decimal.
This API is not CLS-compliant.
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
Parameters
- value
- UInt64
The 64-bit unsigned integer to convert.
Returns
The converted 64-bit unsigned integer.
- Attributes
Examples
The following example converts UInt64 values to Decimal numbers by using the UInt64 to Decimal conversion operator.
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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Important
This API is not CLS-compliant.
Defines an implicit conversion of a 32-bit unsigned integer to a Decimal.
This API is not CLS-compliant.
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
Parameters
- value
- UInt32
The 32-bit unsigned integer to convert.
Returns
The converted 32-bit unsigned integer.
- Attributes
Examples
The following example converts UInt32 values to Decimal numbers.
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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Important
This API is not CLS-compliant.
Defines an implicit conversion of an 8-bit signed integer to a Decimal.
This API is not CLS-compliant.
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
Parameters
- value
- SByte
The 8-bit signed integer to convert.
Returns
The converted 8-bit signed integer.
- Attributes
Examples
The following example converts SByte values to Decimal numbers.
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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Defines an implicit conversion of a 64-bit signed integer to a 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
Parameters
- value
- Int64
The 64-bit signed integer to convert.
Returns
The converted 64-bit signed integer.
Examples
The following example converts Int64 values to Decimal numbers.
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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Defines an implicit conversion of a 32-bit signed integer to a 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
Parameters
- value
- Int32
The 32-bit signed integer to convert.
Returns
The converted 32-bit signed integer.
Examples
The following example converts Int32 values to Decimal numbers.
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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Defines an implicit conversion of a 16-bit signed integer to a 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
Parameters
- value
- Int16
The 16-bit signed integer to convert.
Returns
The converted 16-bit signed integer.
Examples
The following example converts Int16 values to Decimal numbers. This conversion requires the op_Implicit operator in Visual Basic, but not in C# and 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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Defines an implicit conversion of a Unicode character to a 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
Parameters
- value
- Char
The Unicode character to convert.
Returns
The converted Unicode character.
Examples
The following example converts Char values (Unicode characters) to Decimal numbers. This conversion requires the op_Implicit operator in Visual Basic, but not in C# and 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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Defines an implicit conversion of an 8-bit unsigned integer to a 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
Parameters
- value
- Byte
The 8-bit unsigned integer to convert.
Returns
The converted 8-bit unsigned integer.
Examples
The following example converts Byte values to Decimal numbers.
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)
Remarks
The overloads of the Implicit method define the types from which the compiler can automatically convert a Decimal value without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). They are widening conversions that do not involve data loss and do not throw an OverflowException exception.
See also
Applies to
.NET 9 and other versions
Product | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
.NET feedback
.NET is an open source project. Select a link to provide feedback: