Decimal.Implicit Opérateur

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Définit une conversion implicite de la valeur d'un type en une valeur Decimal.

Surcharges

Implicit(UInt16 to Decimal)	Définit une conversion implicite d’un entier non signé 16 bits en Decimal. Cette API n'est pas conforme CLS.
Implicit(UInt64 to Decimal)	Définit une conversion implicite d’un entier non signé 64 bits en Decimal. Cette API n'est pas conforme CLS.
Implicit(UInt32 to Decimal)	Définit une conversion implicite d’un entier non signé 32 bits en Decimal. Cette API n'est pas conforme CLS.
Implicit(SByte to Decimal)	Définit une conversion implicite d’un entier signé 8 bits en Decimal. Cette API n'est pas conforme CLS.
Implicit(Int64 to Decimal)	Définit une conversion implicite d’un entier signé 64 bits en Decimal.
Implicit(Int32 to Decimal)	Définit une conversion implicite d’un entier signé 32 bits en Decimal.
Implicit(Int16 to Decimal)	Définit une conversion implicite d’un entier signé 16 bits en Decimal.
Implicit(Char to Decimal)	Définit une conversion implicite d’un caractère Unicode en Decimal.
Implicit(Byte to Decimal)	Définit une conversion implicite d’un entier non signé 8 bits en Decimal.

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Implicit(UInt16 to Decimal)

Source:

Decimal.cs

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d’un entier non signé 16 bits en Decimal.

Cette API n'est pas conforme CLS.

C#

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

Paramètres

value

UInt16

Entier non signé 16 bits à convertir.

Retours

Decimal

Entier non signé 16 bits converti.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit des valeurs en Decimal nombresUInt16.

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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• UInt16

Implicit(UInt64 to Decimal)

Source:

Decimal.cs

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d’un entier non signé 64 bits en Decimal.

Cette API n'est pas conforme CLS.

C#

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

Paramètres

value

UInt64

Entier non signé 64 bits à convertir.

Retours

Decimal

Entier non signé 64 bits converti.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit des valeurs en nombres UInt64 à Decimal l’aide de l’opérateur UInt64 de conversion to 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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• UInt64

Implicit(UInt32 to Decimal)

Source:

Decimal.cs

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d’un entier non signé 32 bits en Decimal.

Cette API n'est pas conforme CLS.

C#

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

Paramètres

value

UInt32

Entier non signé 32 bits à convertir.

Retours

Decimal

Entier non signé 32 bits converti.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit des valeurs en Decimal nombresUInt32.

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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• UInt32

Implicit(SByte to Decimal)

Source:

Decimal.cs

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d’un entier signé 8 bits en Decimal.

Cette API n'est pas conforme CLS.

C#

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

Paramètres

value

SByte

Entier signé 8 bits à convertir.

Retours

Decimal

Entier signé 8 bits converti.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit des valeurs en Decimal nombresSByte.

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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• SByte

Implicit(Int64 to Decimal)

Source:

Decimal.cs

Définit une conversion implicite d’un entier signé 64 bits en Decimal.

C#

public static implicit operator decimal(long value);

Paramètres

value

Int64

Entier signé 64 bits à convertir.

Retours

Decimal

Entier signé 64 bits converti.

Exemples

L’exemple suivant convertit des valeurs en Decimal nombresInt64.

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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• Int64

Implicit(Int32 to Decimal)

Source:

Decimal.cs

Définit une conversion implicite d’un entier signé 32 bits en Decimal.

C#

public static implicit operator decimal(int value);

Paramètres

value

Int32

Entier signé 32 bits à convertir.

Retours

Decimal

Entier signé 32 bits converti.

Exemples

L’exemple suivant convertit des valeurs en Decimal nombresInt32.

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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• Int32

Implicit(Int16 to Decimal)

Source:

Decimal.cs

Définit une conversion implicite d’un entier signé 16 bits en Decimal.

C#

public static implicit operator decimal(short value);

Paramètres

value

Int16

Entier signé 16 bits à convertir.

Retours

Decimal

Entier signé 16 bits converti.

Exemples

L’exemple suivant convertit des valeurs en Decimal nombresInt16. Cette conversion nécessite l’opérateur op_Implicit en Visual Basic, mais pas en C# et 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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• Int16

Implicit(Char to Decimal)

Source:

Decimal.cs

Définit une conversion implicite d’un caractère Unicode en Decimal.

C#

public static implicit operator decimal(char value);

Paramètres

value

Char

Caractère Unicode à convertir.

Retours

Decimal

Caractère Unicode converti.

Exemples

L’exemple suivant convertit des valeurs (caractères Unicode) en Decimal nombresChar. Cette conversion nécessite l’opérateur op_Implicit en Visual Basic, mais pas en C# et 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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• Char

Implicit(Byte to Decimal)

Source:

Decimal.cs

Définit une conversion implicite d’un entier non signé 8 bits en Decimal.

C#

public static implicit operator decimal(byte value);

Paramètres

value

Byte

Entier non signé 8 bits à convertir.

Retours

Decimal

Entier non signé 8 bits converti.

Exemples

L’exemple suivant convertit des valeurs en Decimal nombresByte.

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)

Remarques

Les surcharges de la Implicit méthode définissent les types à partir desquels le compilateur peut convertir automatiquement une Decimal valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas d’exception OverflowException .

Voir aussi

• Byte