Enum Classe

Définition

Fournit la classe de base pour les énumérations.Provides the base class for enumerations.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable
Héritage
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant illustre l’utilisation d’une énumération pour représenter des valeurs nommées et une autre énumération pour représenter des champs de bits nommés.The following example demonstrates using an enumeration to represent named values and another enumeration to represent named bit fields.

using namespace System;
enum class Days
{
   Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday
};

enum class BoilingPoints
{
   Celsius = 100,
   Fahrenheit = 212
};

[Flags]

enum class Colors
{
   Red = 1,
   Green = 2,
   Blue = 4,
   Yellow = 8
};

int main()
{
   Type^ weekdays = Days::typeid;
   Type^ boiling = BoilingPoints::typeid;
   Console::WriteLine(  "The days of the week, and their corresponding values in the Days Enum are:" );
   Array^ a = Enum::GetNames( weekdays );
   Int32 i = 0;
   do
   {
      Object^ o = a->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( weekdays, Enum::Parse( weekdays, o->ToString() ),  "d" ) );
   }
   while ( ++i < a->Length );

   Console::WriteLine();
   Console::WriteLine(  "Enums can also be created which have values that represent some meaningful amount." );
   Console::WriteLine(  "The BoilingPoints Enum defines the following items, and corresponding values:" );
   i = 0;
   Array^ b = Enum::GetNames( boiling );
   do
   {
      Object^ o = b->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( boiling, Enum::Parse( boiling, o->ToString() ),  "d" ) );
   }
   while ( ++i < b->Length );

   Array^ c = Enum::GetNames( Colors::typeid );
   Colors myColors = Colors::Red | Colors::Blue | Colors::Yellow;
   Console::WriteLine();
   Console::Write(  "myColors holds a combination of colors. Namely:" );
   for ( i = 0; i < 3; i++ )
      Console::Write(  " {0}", c->GetValue( i ) );
}
using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [Flags]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main() {

        Type weekdays = typeof(Days);
        Type boiling = typeof(BoilingPoints);

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:");

        foreach ( string s in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( weekdays, Enum.Parse(weekdays, s), "d"));

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:");

        foreach ( string s in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(boiling, Enum.Parse(boiling, s), "d"));

        Colors myColors = Colors.Red | Colors.Blue | Colors.Yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors);
    }
}
Public Class EnumTest
    Enum Days
        Saturday
        Sunday
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
    End Enum 
    
    Enum BoilingPoints
        Celsius = 100
        Fahrenheit = 212
    End Enum 
    
    <Flags()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum 

    Public Shared Sub Main()
        Dim weekdays As Type = GetType(Days)
        Dim boiling As Type = GetType(BoilingPoints)

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:")

        Dim s As String
        For Each s In  [Enum].GetNames(weekdays)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(weekdays, [Enum].Parse(weekdays, s), "d"))
        
        Next s
        Console.WriteLine()
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.")
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:")

        For Each s In  [Enum].GetNames(boiling)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(boiling, [Enum].Parse(boiling, s), "d"))
        Next s

        Dim myColors As Colors = Colors.Red Or Colors.Blue Or Colors.Yellow
        Console.WriteLine()
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors)
    End Sub 
End Class 

Remarques

Une énumération est un ensemble de constantes nommées dont le type sous-jacent est tout type intégral.An enumeration is a set of named constants whose underlying type is any integral type. Si aucun type sous-jacent n’est Int32 déclaré explicitement, est utilisé.If no underlying type is explicitly declared, Int32 is used. Enumest la classe de base pour toutes les énumérations dans le .NET Framework.Enum is the base class for all enumerations in the .NET Framework. Les types énumération sont définis enum par le C# mot clé Enumdans et... End Enum construction dans Visual Basic.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enumfournit des méthodes pour la comparaison des instances de cette classe, la conversion de la valeur d’une instance en sa représentation sous forme de chaîne, la conversion de la représentation sous forme de chaîne d’un nombre en une instance de cette classe et la création d’une instance d’une énumération et d’une valeur spécifiées.Enum provides methods for comparing instances of this class, converting the value of an instance to its string representation, converting the string representation of a number to an instance of this class, and creating an instance of a specified enumeration and value.

Vous pouvez également traiter une énumération comme un champ de bits.You can also treat an enumeration as a bit field. Pour plus d’informations, consultez la section membres non exclusifs et l’attribut flags et la FlagsAttribute rubrique.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

Dans cette rubrique :In this topic:

Création d’un type énumération Creating an enumeration type
Instanciation d’un type énumération Instantiating an enumeration type
Meilleures pratiques pour l’énumération Enumeration best practices
Exécution d’opérations avec des énumérations Performing operations with enumerations
Exécution de conversionsPerforming conversions
Analyse des valeurs d’énumérationParsing enumeration values
Mise en forme des valeurs d’énumérationFormatting enumeration values
Itération des membres de l’énumérationIterating enumeration members
Membres non exclusifs et attribut flagsNon-exclusive members and the Flags attribute
Ajout de méthodes d’énumérationAdding enumeration methods

Création d’un type énumérationCreating an enumeration type

Les langages de programmation fournissent généralement une syntaxe pour déclarer une énumération qui se compose d’un ensemble de constantes nommées et de leurs valeurs.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. L’exemple suivant illustre la syntaxe utilisée par C# et Visual Basic pour définir une énumération.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Elle crée une énumération ArrivalStatus nommée qui a trois membres ArrivalStatus.Early: ArrivalStatus.OnTime, et ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Notez que dans les deux cas, l’énumération n’hérite Enumpas explicitement de ; la relation d’héritage est gérée implicitement par le compilateur.Note that in both cases, the enumeration does not explicitly inherit from Enum; the inheritance relationship is handled implicitly by the compiler.

public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };
Public Enum ArrivalStatus As Integer
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Avertissement

Vous ne devez jamais créer un type d’énumération dont le type sous- Charjacent est non intégral ou.You should never create an enumeration type whose underlying type is non-integral or Char. Bien que vous puissiez créer ce type d’énumération à l’aide de la réflexion, les appels de méthode qui utilisent le type résultant sont non fiables et peuvent également lever des exceptions supplémentaires.Although you can create such an enumeration type by using reflection, method calls that use the resulting type are unreliable and may also throw additional exceptions.

Instanciation d’un type énumérationInstantiating an enumeration type

Vous pouvez instancier un type énumération de la même façon que vous instanciez tout autre type valeur : en déclarant une variable et en lui assignant l’une des constantes de l’énumération.You can instantiate an enumeration type just as you instantiate any other value type: by declaring a variable and assigning one of the enumeration's constants to it. L’exemple suivant instancie un ArrivalStatus dont la valeur ArrivalStatus.OnTimeest.The following example instantiates an ArrivalStatus whose value is ArrivalStatus.OnTime.

public class Example
{
   public static void Main()
   {
      ArrivalStatus status = ArrivalStatus.OnTime;
      Console.WriteLine("Arrival Status: {0} ({0:D})", status);
   }
}
// The example displays the following output:
//       Arrival Status: OnTime (0)
Public Module Example
   Public Sub Main()
      Dim status As ArrivalStatus = ArrivalStatus.OnTime
      Console.WriteLine("Arrival Status: {0} ({0:D})", status)
   End Sub
End Module
' The example displays the following output:
'        Arrival Status: OnTime (0)

Vous pouvez également instancier une valeur d’énumération des manières suivantes :You can also instantiate an enumeration value in the following ways:

  • En utilisant les fonctionnalités d’un langage de programmation particulier pour effectuer un C#Cast (comme dans) ou convertir (comme dans Visual Basic) une valeur entière en valeur d’énumération.By using a particular programming language's features to cast (as in C#) or convert (as in Visual Basic) an integer value to an enumeration value. L’exemple suivant crée un ArrivalStatus objet dont la valeur ArrivalStatus.Early est de cette manière.The following example creates an ArrivalStatus object whose value is ArrivalStatus.Early in this way.

    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    Dim status2 As ArrivalStatus = CType(1, ArrivalStatus)
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2)
    ' The example displays the following output:
    '       Arrival Status: Early (1)
    
  • En appelant son constructeur sans paramètre implicite.By calling its implicit parameterless constructor. Comme l’illustre l’exemple suivant, dans ce cas, la valeur sous-jacente de l’instance d’énumération est 0.As the following example shows, in this case the underlying value of the enumeration instance is 0. Toutefois, il ne s’agit pas nécessairement de la valeur d’une constante valide dans l’énumération.However, this is not necessarily the value of a valid constant in the enumeration.

    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    Dim status1 As New ArrivalStatus()
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1)
    ' The example displays the following output:
    '        Arrival Status: OnTime (0)
    
  • En appelant la Parse méthode TryParse ou pour analyser une chaîne qui contient le nom d’une constante dans l’énumération.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Pour plus d’informations, consultez la section analyse des valeurs d’énumération .For more information, see the Parsing Enumeration Values section.

  • En appelant la ToObject méthode pour convertir une valeur intégrale en un type énumération.By calling the ToObject method to convert an integral value to an enumeration type. Pour plus d’informations, consultez la section exécution de conversions .For more information, see the Performing Conversions section.

Meilleures pratiques pour l’énumérationEnumeration best practices

Nous vous recommandons d’utiliser les meilleures pratiques suivantes lorsque vous définissez des types énumération :We recommend that you use the following best practices when you define enumeration types:

  • Si vous n’avez pas défini de membre d’énumération dont la valeur est 0 None , envisagez de créer une constante énumérée.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. Par défaut, la mémoire utilisée pour l’énumération est initialisée à zéro par la common language runtime.By default, the memory used for the enumeration is initialized to zero by the common language runtime. Par conséquent, si vous ne définissez pas une constante dont la valeur est égale à zéro, l’énumération contient une valeur non conforme quand elle est créée.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Si votre application doit représenter un cas par défaut évident, envisagez d’utiliser une constante énumérée dont la valeur est égale à zéro pour la représenter.If there is an obvious default case that your application has to represent, consider using an enumerated constant whose value is zero to represent it. S’il n’existe pas de cas par défaut, envisagez d’utiliser une constante énumérée dont la valeur est égale à zéro pour spécifier le cas qui n’est pas représenté par les autres constantes énumérées.If there is no default case, consider using an enumerated constant whose value is zero to specify the case that is not represented by any of the other enumerated constants.

  • Ne spécifiez pas les constantes énumérées qui sont réservées pour une utilisation ultérieure.Do not specify enumerated constants that are reserved for future use.

  • Quand vous définissez une méthode ou une propriété qui prend une constante énumérée comme valeur, envisagez de valider la valeur.When you define a method or property that takes an enumerated constant as a value, consider validating the value. La raison est que vous pouvez effectuer un cast d’une valeur numérique dans le type d’énumération même si cette valeur numérique n’est pas définie dans l’énumération.The reason is that you can cast a numeric value to the enumeration type even if that numeric value is not defined in the enumeration.

Les meilleures pratiques pour les types énumération dont les constantes sont des champs de bits sont répertoriées dans la section membres non exclusifs et l’attribut flags .Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Exécution d’opérations avec des énumérationsPerforming operations with enumerations

Vous ne pouvez pas définir de nouvelles méthodes lorsque vous créez une énumération.You cannot define new methods when you are creating an enumeration. Toutefois, un type énumération hérite d’un ensemble complet de méthodes statiques et Enum d’instances de la classe.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. Les sections suivantes étudient la plupart de ces méthodes, en plus de plusieurs autres méthodes couramment utilisées lors de l’utilisation de valeurs d’énumération.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Exécution de conversionsPerforming conversions

Vous pouvez effectuer une conversion entre un membre de l’énumération et son type sous- C#jacent à l’aide d’un opérateur de cast (in) ou de conversion (en Visual Basic).You can convert between an enumeration member and its underlying type by using a casting (in C#) or conversion (in Visual Basic) operator. L’exemple suivant utilise des opérateurs de cast ou de conversion pour effectuer des conversions à la fois d’un entier à une valeur d’énumération et d’une valeur d’énumération à un entier.The following example uses casting or conversion operators to perform conversions both from an integer to an enumeration value and from an enumeration value to an integer.

int value3 = 2;
ArrivalStatus status3 = (ArrivalStatus) value3;

int value4 = (int) status3;
Dim value3 As Integer = 2
Dim status3 As ArrivalStatus = CType(value3, ArrivalStatus)

Dim value4 As Integer = CInt(status3)

La Enum classe comprend également une ToObject méthode qui convertit une valeur d’un type intégral en valeur d’énumération.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. L’exemple suivant utilise la ToObject(Type, Int32) méthode pour convertir un Int32 en ArrivalStatus valeur.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Notez que, étant donné ToObject que le retourne une valeur Objectde type, l’utilisation d’un opérateur de cast ou de conversion peut encore être nécessaire pour effectuer un cast de l’objet vers le type d’énumération.Note that, because the ToObject returns a value of type Object, the use of a casting or conversion operator may still be necessary to cast the object to the enumeration type.

int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);
Dim number As Integer = -1
Dim arrived As ArrivalStatus = CType(ArrivalStatus.ToObject(GetType(ArrivalStatus), number), ArrivalStatus)

Lors de la conversion d’un entier en valeur d’énumération, il est possible d’assigner une valeur qui n’est pas réellement un membre de l’énumération.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Pour éviter cela, vous pouvez passer l’entier à la IsDefined méthode avant d’effectuer la conversion.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. L’exemple suivant utilise cette méthode pour déterminer si les éléments d’un tableau de valeurs entières peuvent être convertis ArrivalStatus en valeurs.The following example uses this method to determine whether the elements in an array of integer values can be converted to ArrivalStatus values.

using System;

public enum ArrivalStatus { Unknown=-3, Late=-1, OnTime=0, Early=1 };

public class Example
{
   public static void Main()
   {
      int[] values = { -3, -1, 0, 1, 5, Int32.MaxValue };
      foreach (var value in values)
      {
         ArrivalStatus status;
         if (Enum.IsDefined(typeof(ArrivalStatus), value))
            status = (ArrivalStatus) value;
         else
            status = ArrivalStatus.Unknown;
         Console.WriteLine("Converted {0:N0} to {1}", value, status);
      }
   }
}
// The example displays the following output:
//       Converted -3 to Unknown
//       Converted -1 to Late
//       Converted 0 to OnTime
//       Converted 1 to Early
//       Converted 5 to Unknown
//       Converted 2,147,483,647 to Unknown
Public Enum ArrivalStatus As Integer
   Unknown = -3
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Module Example
   Public Sub Main()
      Dim values() As Integer = { -3, -1, 0, 1, 5, Int32.MaxValue }
      For Each value In values
         Dim status As ArrivalStatus
         If [Enum].IsDefined(GetType(ArrivalStatus), value)
            status = CType(value, ArrivalStatus) 
         Else
            status = ArrivalStatus.Unknown
         End If
         Console.WriteLine("Converted {0:N0} to {1}", value, status)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Converted -3 to Unknown
'       Converted -1 to Late
'       Converted 0 to OnTime
'       Converted 1 to Early
'       Converted 5 to Unknown
'       Converted 2,147,483,647 to Unknown

Bien que Enum la classe fournisse des implémentations d' IConvertible interface explicites de l’interface pour la conversion d’une valeur d’énumération en type intégral, Convert vous devez utiliser les ToInt32méthodes de la classe, telles que, pour Effectuez ces conversions.Although the Enum class provides explicit interface implementations of the IConvertible interface for converting from an enumeration value to an integral type, you should use the methods of the Convert class, such as ToInt32, to perform these conversions. L’exemple suivant montre comment vous pouvez utiliser la GetUnderlyingType méthode avec la Convert.ChangeType méthode pour convertir une valeur d’énumération en son type sous-jacent.The following example illustrates how you can use the GetUnderlyingType method along with the Convert.ChangeType method to convert an enumeration value to its underlying type. Notez que cet exemple ne requiert pas que le type sous-jacent de l’énumération soit connu au moment de la compilation.Note that this example does not require the underlying type of the enumeration to be known at compile time.

ArrivalStatus status = ArrivalStatus.Early;
var number = Convert.ChangeType(status, Enum.GetUnderlyingType(typeof(ArrivalStatus)));
Console.WriteLine("Converted {0} to {1}", status, number);
// The example displays the following output:
//       Converted Early to 1
Dim status As ArrivalStatus = ArrivalStatus.Early
Dim number = Convert.ChangeType(status, [Enum].GetUnderlyingType(GetType(ArrivalStatus)))
Console.WriteLine("Converted {0} to {1}", status, number)
' The example displays the following output:
'       Converted Early to 1

Analyse des valeurs d’énumérationParsing enumeration values

Les Parse méthodes TryParse et vous permettent de convertir la représentation sous forme de chaîne d’une valeur d’énumération en cette valeur.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. La représentation sous forme de chaîne peut être soit le nom soit la valeur sous-jacente d’une constante d’énumération.The string representation can be either the name or the underlying value of an enumeration constant. Notez que les méthodes d’analyse convertissent correctement des représentations sous forme de chaîne de nombres qui ne sont pas membres d’une énumération particulière si les chaînes peuvent être converties en une valeur du type sous-jacent de l’énumération.Note that the parsing methods will successfully convert string representations of numbers that are not members of a particular enumeration if the strings can be converted to a value of the enumeration's underlying type. Pour éviter cela, la IsDefined méthode peut être appelée pour s’assurer que le résultat de la méthode d’analyse est une valeur d’énumération valide.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. L’exemple illustre cette approche et illustre les appels aux Parse(Type, String) méthodes et. Enum.TryParse<TEnum>(String, TEnum)The example illustrates this approach and demonstrates calls to both the Parse(Type, String) and Enum.TryParse<TEnum>(String, TEnum) methods. Notez que la méthode d’analyse non générique retourne un objet que vous devrez peut-être caster ( C#en) ou convertir (en Visual Basic) en type d’énumération approprié.Note that the non-generic parsing method returns an object that you may have to cast (in C#) or convert (in Visual Basic) to the appropriate enumeration type.

string number = "-1";
string name = "Early";

try {
   ArrivalStatus status1 = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), number);
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status1)))
      status1 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", number, status1);
}
catch (FormatException) {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}   
   
ArrivalStatus status2;
if (Enum.TryParse<ArrivalStatus>(name, out status2)) {
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status2)))
      status2 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", name, status2);
}
else {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early
Dim number As String = "-1"
Dim name As String = "Early"
Dim invalid As String = "32"

Try 
   Dim status1 As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), number), ArrivalStatus)
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status1) Then status1 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", number, status1)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End Try   
   
Dim status2 As ArrivalStatus
If [Enum].TryParse(Of ArrivalStatus)(name, status2) Then
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status2) Then status2 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", name, status2)
Else
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End If
' The example displays the following output:
'       Converted '-1' to Late
'       Converted 'Early' to Early

Mise en forme des valeurs d’énumérationFormatting enumeration values

Vous pouvez convertir des valeurs d’énumération en représentations sous forme de Format chaîne en appelant la méthode statique, ainsi que les surcharges de la méthode d’instance. ToStringYou can convert enumeration values to their string representations by calling the static Format method, as well as the overloads of the instance ToString method. Vous pouvez utiliser une chaîne de format pour contrôler la façon dont une valeur d’énumération est représentée sous la forme d’une chaîne.You can use a format string to control the precise way in which an enumeration value is represented as a string. Pour plus d’informations, consultez chaînes de format d’énumération.For more information, see Enumeration Format Strings. L’exemple suivant utilise chacune des chaînes de format d’énumération prises en charge ("g" ou "g", "d" ou "d", "x" ou "x", et "f" ou "f") pour convertir ArrivalStatus un membre de l’énumération en ses représentations sous forme de chaîne.The following example uses each of the supported enumeration format strings ("G" or "g", "D" or "d", "X" or "x", and "F" or "f" ) to convert a member of the ArrivalStatus enumeration to its string representations.

string[] formats= { "G", "F", "D", "X"};
ArrivalStatus status = ArrivalStatus.Late;
foreach (var fmt in formats)
   Console.WriteLine(status.ToString(fmt));

// The example displays the following output:
//       Late
//       Late
//       -1
//       FFFFFFFF
Dim formats() As String = { "G", "F", "D", "X"}
Dim status As ArrivalStatus = ArrivalStatus.Late
For Each fmt As String In formats
   Console.WriteLine(status.ToString(fmt))
Next
' The example displays the following output:
'       Late
'       Late
'       -1
'       FFFFFFFF

Itération des membres de l’énumérationIterating enumeration members

Le Enum type n’implémente pas IEnumerable l' IEnumerable<T> interface ou, ce qui vous permet d’itérer les membres d’une collection à foreach l’aide C#d’une For Each construction (dans) ou (en Visual Basic).The Enum type does not implement the IEnumerable or IEnumerable<T> interface, which would enable you to iterate members of a collection by using a foreach (in C#) or For Each (in Visual Basic) construct. Toutefois, vous pouvez énumérer les membres de deux manières.However, you can enumerate members in either of two ways.

  • Vous pouvez appeler la GetNames méthode pour récupérer un tableau de chaînes contenant les noms des membres de l’énumération.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Ensuite, pour chaque élément du tableau de chaînes, vous pouvez appeler la Parse méthode pour convertir la chaîne en sa valeur d’énumération équivalente.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. L'exemple suivant illustre cette approche.The following example illustrates this approach.

    string[] names = Enum.GetNames(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    Array.Sort(names);
    foreach (var name in names) {
       ArrivalStatus status = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), name);
       Console.WriteLine("   {0} ({0:D})", status);
    }
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          Early (1)
    //          Late (-1)
    //          OnTime (0)
    //          Unknown (-3)      
    
    Dim names() As String = [Enum].GetNames(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    Array.Sort(names)
    For Each name In names
       Dim status As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), name),
                                     ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          Early (1)
    '          Late (-1)
    '          OnTime (0)
    '          Unknown (-3)      
    
  • Vous pouvez appeler la GetValues méthode pour récupérer un tableau qui contient les valeurs sous-jacentes dans l’énumération.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Ensuite, pour chaque élément du tableau, vous pouvez appeler la ToObject méthode pour convertir l’entier en sa valeur d’énumération équivalente.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. L'exemple suivant illustre cette approche.The following example illustrates this approach.

    var values = Enum.GetValues(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    foreach (ArrivalStatus status in values) {
       Console.WriteLine("   {0} ({0:D})", status);
    }                                       
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    Dim values = [Enum].GetValues(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    For Each value In values
       Dim status As ArrivalStatus = CType([Enum].ToObject(GetType(ArrivalStatus), value),
                                           ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next                                       
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          OnTime (0)
    '          Early (1)
    '          Unknown (-3)
    '          Late (-1)
    

Membres non exclusifs et attribut flagsNon-exclusive members and the Flags attribute

Une utilisation courante d’une énumération consiste à représenter un ensemble de valeurs s’excluant mutuellement.One common use of an enumeration is to represent a set of mutually exclusive values. Par exemple, une ArrivalStatus instance peut avoir la Earlyvaleur, OnTimeou Late.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Il n’est pas judicieux que la valeur d' ArrivalStatus une instance reflète plusieurs constantes d’énumération.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

Dans d’autres cas, toutefois, la valeur d’un objet d’énumération peut inclure plusieurs membres de l’énumération, et chaque membre représente un champ de bits dans la valeur d’énumération.In other cases, however, the value of an enumeration object can include multiple enumeration members, and each member represents a bit field in the enumeration value. L' FlagsAttribute attribut peut être utilisé pour indiquer que l’énumération est composée de champs de bits.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Par exemple, une énumération Pets nommée peut être utilisée pour indiquer les types d’animaux familiers dans un ménage.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Il peut être défini comme suit.It can be defined as follows.

[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };

<Flags> Public Enum Pets As Integer
   None = 0
   Dog = 1
   Cat = 2
   Bird = 4
   Rodent = 8
   Reptile = 16
   Other = 32
End Enum

L' Pets énumération peut ensuite être utilisée comme indiqué dans l’exemple suivant.The Pets enumeration can then be used as shown in the following example.

Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// The example displays the following output:
//       Pets: Dog, Cat (3)      
Dim familyPets As Pets = Pets.Dog Or Pets.Cat
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets)
' The example displays the following output:
'       Pets: Dog, Cat (3)      

Les meilleures pratiques suivantes doivent être utilisées lors de la définition d’une énumération FlagsAttribute au niveau du bit et de l’application de l’attribut.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Utilisez l' FlagsAttribute attribut personnalisé pour une énumération uniquement si une opération au niveau du bit (and, or, exclusive ou) doit être effectuée sur une valeur numérique.Use the FlagsAttribute custom attribute for an enumeration only if a bitwise operation (AND, OR, EXCLUSIVE OR) is to be performed on a numeric value.

  • Définissez des constantes d’énumération dans les puissances de deux, c’est-à-dire 1, 2, 4, 8 et ainsi de suite.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Cela signifie que les indicateurs individuels des constantes d’énumération combinées ne se chevauchent pas.This means the individual flags in combined enumeration constants do not overlap.

  • Envisagez de créer une constante énumérée pour les combinaisons d’indicateurs couramment utilisées.Consider creating an enumerated constant for commonly used flag combinations. Par exemple, si vous avez une énumération utilisée pour les opérations d’e/s de fichier qui contient les Read = 1 constantes énumérées et Write = 2, envisagez de créer la Read constante Write ReadWrite = Read OR Writeénumérée, qui combine les fonctions et père.For example, if you have an enumeration used for file I/O operations that contains the enumerated constants Read = 1 and Write = 2, consider creating the enumerated constant ReadWrite = Read OR Write, which combines the Read and Write flags. En outre, l’opération or au niveau du bit utilisée pour combiner les indicateurs peut être considérée comme un concept avancé dans certaines circonstances, qui ne doit pas être nécessaire pour les tâches simples.In addition, the bitwise OR operation used to combine the flags might be considered an advanced concept in some circumstances that should not be required for simple tasks.

  • Soyez prudent si vous définissez un nombre négatif comme constante énumérée d’indicateur, car de nombreuses positions d’indicateur peuvent avoir la valeur 1, ce qui peut rendre votre code confus et encourager les erreurs de codage.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

  • Un moyen pratique de tester si un indicateur est défini dans une valeur numérique consiste à appeler la méthode HasFlag d’instance, comme indiqué dans l’exemple suivant.A convenient way to test whether a flag is set in a numeric value is to call the instance HasFlag method, as shown in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets.HasFlag(Pets.Dog))
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets.HasFlag(Pets.Dog) Then
       Console.WriteLine("The family has a dog.")
    End If
    ' The example displays the following output:
    '       The family has a dog.      
    

    Cela équivaut à effectuer une opération and au niveau du bit entre la valeur numérique et la constante énumérée de l’indicateur, qui définit tous les bits de la valeur numérique sur zéro qui ne correspondent pas à l’indicateur, puis à tester si le résultat de cette opération est égal au indicateur de constante énumérée.It is equivalent to performing a bitwise AND operation between the numeric value and the flag enumerated constant, which sets all bits in the numeric value to zero that do not correspond to the flag, and then testing whether the result of that operation is equal to the flag enumerated constant. L'exemple suivant illustre cette opération.This is illustrated in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if ((familyPets & Pets.Dog) == Pets.Dog)
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets And Pets.Dog = Pets.Dog Then
       Console.WriteLine("The family has a dog.")
    End If   
    ' The example displays the following output:
    '       The family has a dog.      
    
  • Utilisez None comme nom de la constante énumérée d’indicateur dont la valeur est égale à zéro.Use None as the name of the flag enumerated constant whose value is zero. Vous ne pouvez pas None utiliser la constante énumérée dans une opération and au niveau du bit pour tester un indicateur, car le résultat est toujours égal à zéro.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. Toutefois, vous pouvez effectuer une comparaison logique, et non une opération de bits, entre la valeur None numérique et la constante énumérée pour déterminer si des bits de la valeur numérique sont définis.However, you can perform a logical, not a bitwise, comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set. L'exemple suivant illustre cette opération.This is illustrated in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets == Pets.None)
       Console.WriteLine("The family has no pets.");
    else
       Console.WriteLine("The family has pets.");   
    // The example displays the following output:
    //       The family has pets.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets = Pets.None Then
       Console.WriteLine("The family has no pets.")
    Else
       Console.WriteLine("The family has pets.")   
    End If
    ' The example displays the following output:
    '       The family has pets.      
    
  • Ne définissez pas une valeur d’énumération uniquement pour refléter l’état de l’énumération elle-même.Do not define an enumeration value solely to mirror the state of the enumeration itself. Par exemple, ne définissez pas une constante énumérée qui marque simplement la fin de l’énumération.For example, do not define an enumerated constant that merely marks the end of the enumeration. Si vous devez déterminer la dernière valeur de l’énumération, vérifiez cette valeur explicitement.If you need to determine the last value of the enumeration, check for that value explicitly. En outre, vous pouvez effectuer un contrôle de plage pour la première et la dernière constante énumérée si toutes les valeurs de la plage sont valides.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Ajout de méthodes d’énumérationAdding enumeration methods

Étant donné que les types énumération sont définis par les enum structures de langage Enum , tels que (C#) et (Visual Basic), vous ne pouvez pas définir de méthodes personnalisées pour Enum un type d’énumération autre que celles héritées de la classe.Because enumeration types are defined by language structures, such as enum (C#) and Enum (Visual Basic), you cannot define custom methods for an enumeration type other than those methods inherited from the Enum class. Toutefois, vous pouvez utiliser des méthodes d’extension pour ajouter des fonctionnalités à un type d’énumération particulier.However, you can use extension methods to add functionality to a particular enumeration type.

Dans l’exemple suivant, l’énumération Grades représente les notes qu’un étudiant peut obtenir dans une classe.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Une méthode d’extension nommée Passing est ajoutée au type Grades pour que chaque instance de ce type « sache » maintenant si elle représente une note au-dessus de la moyenne.An extension method named Passing is added to the Grades type so that each instance of that type now "knows" whether it represents a passing grade or not. La Extensions classe contient également une variable statique en lecture-écriture qui définit le niveau de passage minimal.The Extensions class also contains a static read-write variable that defines the minimum passing grade. La valeur de retour de Passing la méthode d’extension reflète la valeur actuelle de cette variable.The return value of the Passing extension method reflects the current value of that variable.

using System;

// Define an enumeration to represent student grades.
public enum Grades { F = 0, D = 1, C = 2, B = 3, A = 4 };

// Define an extension method for the Grades enumeration.
public static class Extensions
{        
  public static Grades minPassing = Grades.D;

  public static bool Passing(this Grades grade)
  {
      return grade >= minPassing;
  }
}

class Example
{       
  static void Main()
  {
      Grades g1 = Grades.D;
      Grades g2 = Grades.F;
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");

      Extensions.minPassing = Grades.C;
      Console.WriteLine("\nRaising the bar!\n");
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");
  }
}
// The exmaple displays the following output:
//       D is a passing grade.
//       F is not a passing grade.
//       
//       Raising the bar!
//       
//       D is not a passing grade.
//       F is not a passing grade.
Imports System.Runtime.CompilerServices

' Define an enumeration to represent student grades.
Public Enum Grades As Integer
   F = 0
   D = 1
   C = 2
   B = 3
   A = 4
End Enum   

' Define an extension method for the Grades enumeration.
Public Module Extensions
  Public minPassing As Grades = Grades.D
 
  <Extension>
  Public Function Passing(grade As Grades) As Boolean
     Return grade >= minPassing
  End Function
End Module

Public Module Example
  Public Sub Main()
      Dim g1 As Grades = Grades.D
      Dim g2 As Grades = Grades.F
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
      Console.WriteLine()
      
      Extensions.minPassing = Grades.C
      Console.WriteLine("Raising the bar!")
      Console.WriteLine()
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
  End Sub
End Module
' The exmaple displays the following output:
'       D is a passing grade.
'       F is not a passing grade.
'       
'       Raising the bar!
'       
'       D is not a passing grade.
'       F is not a passing grade.

Constructeurs

Enum()

Initialise une nouvelle instance de la classe Enum.Initializes a new instance of the Enum class.

Méthodes

CompareTo(Object)

Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Convertit la valeur spécifiée d'un type énuméré spécifié en sa représentation sous forme de chaîne équivalente conformément au format spécifié.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Retourne le code de hachage de la valeur de cette instance.Returns the hash code for the value of this instance.

GetName(Type, Object)

Récupère le nom de la constante dans l'énumération spécifiée associée à la valeur spécifiée.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Récupère un tableau de noms des constantes dans une énumération spécifiée.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
GetTypeCode()

Retourne le code du type sous-jacent de ce membre d’énumération.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Retourne le type sous-jacent de l'énumération spécifiée.Returns the underlying type of the specified enumeration.

GetValues(Type)

Récupère un tableau des valeurs des constantes dans une énumération spécifiée.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Détermine si un ou plusieurs champs de bits sont définis dans l'instance actuelle.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Retourne un Boolean indiquant si une valeur intégrale donnée, ou son nom sous forme de chaîne, existe dans une énumération spécifiée.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Parse(Type, String)

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d'une ou de plusieurs constantes énumérées en objet énuméré équivalent.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

Parse(Type, String, Boolean)

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d'une ou de plusieurs constantes énumérées en objet énuméré équivalent.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Un paramètre spécifie si l'opération ne respecte pas la casse.A parameter specifies whether the operation is case-insensitive.

Parse<TEnum>(String)
Parse<TEnum>(String, Boolean)
ToObject(Type, Byte)

Convertit l'entier non signé 8 bits spécifié en membre de l'énumération.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Convertit l'entier signé 16 bits spécifié en membre de l'énumération.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Convertit l'entier signé 32 bits spécifié en membre de l'énumération.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Convertit l'entier signé 64 bits spécifié en membre de l'énumération.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Convertit l'objet spécifié avec une valeur entière en membre de l'énumération.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Convertit la valeur de l'entier signé 8 bits spécifié en membre de l'énumération.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Convertit la valeur de l'entier non signé 16 bits spécifié en membre de l'énumération.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Convertit la valeur de l'entier non signé 32 bits spécifié en membre de l'énumération.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Convertit la valeur de l'entier non signé 64 bits spécifié en membre de l'énumération.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Cette surcharge de méthode est obsolète ; utilisez ToString().This method overload is obsolete; use ToString().

ToString(String)

Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Cette surcharge de méthode est obsolète ; utilisez ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)
TryParse(Type, String, Object)
TryParse<TEnum>(String, Boolean, TEnum)

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d'une ou de plusieurs constantes énumérées en objet énuméré équivalent.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Un paramètre spécifie si l'opération respecte la casse.A parameter specifies whether the operation is case-sensitive. La valeur de retour indique si la conversion a réussi.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Convertit la représentation sous forme de chaîne du nom ou de la valeur numérique d'une ou de plusieurs constantes énumérées en objet énuméré équivalent.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. La valeur de retour indique si la conversion a réussi.The return value indicates whether the conversion succeeded.

Implémentations d’interfaces explicites

IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Convertit la valeur actuelle en valeur booléenne basée sur le type sous-jacent.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Convertit la valeur actuelle en entier non signé 8 bits en fonction du type sous-jacent.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Convertit la valeur actuelle en caractère Unicode en fonction du type sous-jacent.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Convertit la valeur actuelle en DateTime basé sur le type sous-jacent.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Convertit la valeur actuelle en Decimal basé sur le type sous-jacent.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Convertit la valeur actuelle en nombre à virgule flottante double précision en fonction du type sous-jacent.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Convertit la valeur actuelle en entier signé 16 bits en fonction du type sous-jacent.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Convertit la valeur actuelle en entier signé 32 bits en fonction du type sous-jacent.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Convertit la valeur actuelle en entier signé 64 bits en fonction du type sous-jacent.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Convertit la valeur actuelle en entier signé 8 bits en fonction du type sous-jacent.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Convertit la valeur actuelle en nombre à virgule flottante simple précision en fonction du type sous-jacent.Converts the current value to a single-precision floating-point number based on the underlying type.

IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider)

Convertit la valeur actuelle en type spécifié en fonction du type sous-jacent.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Convertit la valeur actuelle en entier non signé 16 bits en fonction du type sous-jacent.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Convertit la valeur actuelle en entier non signé 32 bits en fonction du type sous-jacent.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Convertit la valeur actuelle en entier non signé 64 bits en fonction du type sous-jacent.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

Cette surcharge de méthode est obsolète ; utilisez ToString(String).This method overload is obsolete; use ToString(String).

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi