Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Enum, classe

Fournit la classe de base pour les énumérations.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Enum : ValueType, 
	IComparable, IFormattable, IConvertible

Le type Enum expose les membres suivants.

  NomDescription
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEnumInitialise une nouvelle instance de la classe Enum.
Début

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompareToCompare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEqualsRenvoie une valeur indiquant si cette instance équivaut à un objet spécifié. (Substitue ValueType.Equals(Object).)
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFinalize Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFormatConvertit la valeur spécifiée d'un type énuméré spécifié en sa représentation équivalente sous forme de chaîne conformément au format spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeRetourne le code de hachage de la valeur de cette instance. (Substitue ValueType.GetHashCode().)
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetNameRécupère le nom de la constante dans l'énumération spécifiée qui a la valeur spécifiée.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetNamesRécupère un tableau des noms des constantes dans une énumération spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkGetTypeCodeRetourne le TypeCode sous-jacent pour cette instance.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetUnderlyingTypeRetourne le type sous-jacent de l'énumération spécifiée.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetValuesRécupère un tableau des valeurs des constantes dans une énumération spécifiée.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreHasFlagDétermine si un ou plusieurs champs de bits sont définis dans l'instance actuelle.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsDefinedRetourne une indication spécifiant si une constante avec une valeur spécifiée existe dans une énumération spécifiée.
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMemberwiseCloneCrée une copie superficielle de l'objet Object actuel. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(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 un objet énuméré équivalent.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(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 un objet énuméré équivalent. Le dernier paramètre spécifie si l'opération est sensible à la casse.
Méthode publiqueMembre statiqueToObject(Type, Byte)Convertit l'entier non signé 8 bits spécifié en un membre de l'énumération.
Méthode publiqueMembre statiqueToObject(Type, Int16)Convertit l'entier signé 16 bits spécifié en un membre de l'énumération.
Méthode publiqueMembre statiqueToObject(Type, Int32)Convertit l'entier signé 32 bits spécifié en un membre de l'énumération.
Méthode publiqueMembre statiqueToObject(Type, Int64)Convertit l'entier signé 64 bits spécifié en un membre de l'énumération.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToObject(Type, Object)Convertit l'objet spécifié avec une valeur entière en un membre de l'énumération.
Méthode publiqueMembre statiqueToObject(Type, SByte)Convertit la valeur de l'entier signé 8 bits spécifié en un membre de l'énumération.
Méthode publiqueMembre statiqueToObject(Type, UInt16)Convertit la valeur de l'entier non signé 16 bits spécifié en un membre de l'énumération.
Méthode publiqueMembre statiqueToObject(Type, UInt32)Convertit la valeur de l'entier non signé 32 bits spécifié en un membre de l'énumération.
Méthode publiqueMembre statiqueToObject(Type, UInt64)Convertit la valeur de l'entier non signé 64 bits spécifié en un membre de l'énumération.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString()Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente. (Substitue ValueType.ToString().)
Méthode publiquePris en charge par XNA FrameworkToString(IFormatProvider) Obsolète. Cette surcharge de méthode est obsolète ; utilisez Enum.ToString().
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(String)Convertit la valeur de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.
Méthode publiquePris en charge par XNA FrameworkToString(String, IFormatProvider) Obsolète. Cette surcharge de méthode est obsolète ; utilisez Enum.ToString(String).
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTryParse<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 un objet énuméré équivalent. La valeur de retour indique si la conversion a réussi.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTryParse<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 un objet énuméré équivalent. Un paramètre spécifie si l'opération respecte la casse. La valeur de retour indique si la conversion a réussi.
Début

  NomDescription
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToBooleanInfrastructure. Convertit la valeur actuelle en valeur booléenne basée sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToByteInfrastructure. Convertit la valeur actuelle en un entier non signé de 8 bits basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToCharInfrastructure. Convertit la valeur actuelle en caractère Unicode basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDateTimeInfrastructure. Convertit la valeur actuelle en DateTime basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDecimalInfrastructure. Convertit la valeur actuelle en Decimal basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDoubleInfrastructure. Convertit la valeur actuelle en nombre à virgule flottante double précision basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt16Infrastructure. Convertit la valeur actuelle en un entier signé de 16 bits basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt32Infrastructure. Convertit la valeur actuelle en un entier signé de 32 bits basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt64Infrastructure. Convertit la valeur actuelle en un entier signé de 64 bits basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSByteInfrastructure. Convertit la valeur actuelle en un entier signé de 8 bits basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSingleInfrastructure. Convertit la valeur actuelle en nombre à virgule flottante simple précision basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToTypeInfrastructure. Convertit la valeur actuelle en un type spécifié basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt16Infrastructure. Convertit la valeur actuelle en un entier non signé de 16 bits basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt32Infrastructure. Convertit la valeur actuelle en un entier non signé de 32 bits basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt64Infrastructure. Convertit la valeur actuelle en un entier 64 bits non signé basé sur le type sous-jacent.
Implémentation d'interface expliciteMéthode privéePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIFormattable.ToStringInfrastructure. Obsolète. Cette surcharge de méthode est obsolète ; utilisez Enum.ToString(String).
Début

Une énumération est un jeu de constantes nommées dont le type sous-jacent est un type intégral. Si aucun type sous-jacent n'est explicitement déclaré, Int32 est utilisé. Enum est la classe de base pour toutes les énumérations du .NET Framework.

Enum fournit les méthodes permettant de comparer les instances de cette classe, de convertir la valeur d'une instance en représentation sous forme de chaîne, de convertir la représentation sous forme de chaîne d'un nombre en une instance de cette classe et de créer une instance d'une énumération et d'une valeur spécifiées.

Vous pouvez aussi considérer une énumération comme un champ de bits. Pour plus d'informations, consultez la section Membres non exclusifs et l'attribut Flags et la rubrique FlagsAttribute.

Création d'un type énumération

Les langages de programmation fournissent généralement la syntaxe permettant de déclarer une énumération composée de constantes nommées et de leurs valeurs. L'exemple suivant illustre la syntaxe utilisée par C# et Visual Basic pour définir une énumération. Il crée une énumération nommée ArrivalStatus qui a trois membres: ArrivalStatus.Early, ArrivalStatus.OnTime et ArrivalStatus.Late. Notez que dans les deux cas, l'énumération n'hérite pas explicitement de Enum ; la relation d'héritage est contrôlée implicitement par le compilateur.


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


Mise en gardeAttention

Vous ne devez jamais créer un type énumération dont le type sous-jacent est non intégrant ou Char. Bien que vous puissiez créer un tel type énumération en utilisant la réflexion, les appels de méthode qui utilisent le type résultant sont peu fiables et peuvent également lever des exceptions supplémentaires.

Instanciation d'un type énumération

Vous pouvez instancier un type d'énumération comme pour tout autre type valeur : en déclarant une variable et en lui affectant l'une des constantes de l'énumération. L'exemple suivant instancie un ArrivalStatus dont la valeur est 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)


Vous pouvez également instancier une valeur d'énumération en procédant comme suit :

  • En utilisant les fonctionnalités d'un langage de programmation spécifique pour caster (comme en C#) ou convertir (comme en Visual Basic) une valeur entière en une valeur d'énumération. Cela crée un objet ArrivalStatus dont la valeur est ArrivalStatus.Early de cette façon.

    
    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    
    
  • En appelant son constructeur par défaut implicite. Comme l'indique l'exemple suivant, la valeur sous-jacente de l'instance d'énumération est 0 dans ce cas. Toutefois, ce n'est pas nécessairement la valeur d'une constante valide dans l'énumération.

    
    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    
    
  • En appelant la méthode Parse ou TryParse pour analyser une chaîne qui contient le nom d'une constante dans l'énumération. Pour plus d'informations, consultez la section Analyse des valeurs d'énumération.

  • En appelant la méthode ToObject pour convertir une valeur intégrale en un type énumération. Pour plus d'informations, consultez la section Exécution de conversions.

Meilleures pratiques d'énumération

Nous vous recommandons d'utiliser les meilleures pratiques suivantes lorsque vous définissez des types énumération :

  • Si vous n'avez pas défini un membre d'énumération avec la valeur égale à 0, pensez à créer une constante None énumérée. Par défaut, la mémoire utilisée pour l'énumération est initialisée à zéro par le common language runtime. Par conséquent, si vous n'affectez pas la valeur null à une constante, l'énumération contiendra une valeur non conforme lorsqu'elle sera créée.

  • Si votre application doit représenter un cas par défaut évident, utilisez une constante énumérée dont la valeur est nulle pour le représenter. S'il n'y a aucun cas par défaut, utilisez plutôt une constante énumérée dont la valeur est nulle pour spécifier le cas qui n'est représenté par aucune autre constante énumérée.

  • Ne spécifiez pas de constantes énumérées en vue d'une utilisation future.

  • Lorsque vous définissez une méthode ou une propriété qui utilise une constante énumérée comme une valeur, pensez à valider la valeur. En effet, vous pouvez caster une valeur numérique en type énumération, même si cette valeur numérique n'est pas définie dans l'énumération.

Les meilleures pratiques supplémentaires pour les types énumération dont les constantes sont des champs de bits apparaissent dans la section Membres non exclusifs et l'attribut Flags.

Exécution d'opérations avec les énumérations

Vous ne pouvez pas définir de nouvelles méthodes lorsque vous créez une énumération. Toutefois, un type énumération hérite d'un ensemble complet de méthodes statiques et de méthodes d'instance de la classe Enum. Les sections suivantes inspectent la plupart de ces méthodes, en plus de plusieurs autres méthodes utilisées communément lors de l'utilisation de valeurs d'énumération.

1zt1ybx4.collapse_all(fr-fr,VS.110).gifExécution de conversions

Vous pouvez effectuer une conversion entre un membre d'énumération et son type sous-jacent à l'aide d'un opérateur de cast (en C#) ou de conversion (en Visual Basic). L'exemple suivant utilise des opérateurs de casting ou de conversion pour effectuer des conversions d'un entier en une valeur d'énumération et d'une valeur d'énumération en un entier.


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

int value4 = (int) status3;


La classe Enum inclut également une méthode ToObject qui convertit une valeur d'un type intégral quelconque en valeur d'énumération. L'exemple suivant utilise la méthode ToObject(Type, Int32) pour convertir une valeur Int32 en valeur ArrivalStatus. Notez que, car ToObject retourne une valeur de type Object, l'utilisation d'un cast ou d'un opérateur de conversion peut toujours être nécessaire pour convertir l'objet en type énumération.


int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);


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. Pour empêcher cette situation, vous pouvez passer l'entier à la méthode IsDefined avant d'exécuter la conversion. L'exemple suivant utilise cette méthode pour déterminer si les éléments dans un tableau de valeurs entières peuvent être convertis en valeurs ArrivalStatus.


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


Bien que la classe Enum fournisse des implémentations d'interface explicites de l'interface IConvertible pour la conversion d'une valeur d'énumération en un type intégral, vous devez utiliser les méthodes de la classe Convert, telle que ToInt32, pour exécuter ces conversions. L'exemple suivant illustre comment utiliser la méthode GetUnderlyingType avec la méthode Convert.ChangeType pour convertir une valeur d'énumération en son type sous-jacent. Notez que dans cet exemple, il n'est pas nécessaire de connaître le type sous-jacent de l'énumération au moment de la compilation.


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


1zt1ybx4.collapse_all(fr-fr,VS.110).gifAnalyse des valeurs d'énumération

Les méthodes Parse et TryParse vous permettent de convertir la représentation sous forme de chaîne d'une valeur d'énumération en cette valeur. La représentation sous forme de chaîne peut être le nom ou la valeur sous-jacente d'une constante d'énumération. Notez que les méthodes d'analyse convertiront avec succès des représentations sous forme de chaîne des 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. Pour l'empêcher, la méthode IsDefined peut être appelée pour vérifier si le résultat de la méthode d'analyse est une valeur d'énumération valide. L'exemple illustre cette approche et montre les appels des méthodes Parse(Type, String) et Enum.TryParse<TEnum>(String, TEnum). Notez que la méthode d'analyse non générique retourne un objet que vous devrez peut-être caster (en C#) ou convertir (en Visual Basic) en type d'énumération approprié.


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


1zt1ybx4.collapse_all(fr-fr,VS.110).gifMise en forme de valeurs d'énumération

Vous pouvez convertir les valeurs d'énumération en chaînes à l'aide de la méthode Format statique, ainsi que les surcharges de la méthode ToString de l'instance. Vous pouvez utiliser une chaîne de format pour contrôler précisément le mode de représentation d'une valeur d'énumération sous forme de chaîne. Pour plus d'informations, consultez Chaînes de format d'énumération. L'exemple suivant utilise chaque chaîne de format d'énumération prise en charge pour convertir un membre de l'énumération ArrivalStatus en ses représentations sous forme de chaîne.


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


1zt1ybx4.collapse_all(fr-fr,VS.110).gifItération au sein des membres d'énumération

Le type Enum n'implémente pas l'interface IEnumerable ou IEnumerable<T>, qui vous permettrait d'itérer des membres d'une collection à l'aide d'une construction foreach (en C#) ou For Each (en Visual Basic). Toutefois, vous pouvez énumérer des membres de deux façons.

  • Vous pouvez appeler la méthode GetNames pour extraire un tableau de chaînes qui contient les noms des membres d'énumération. Ensuite, pour chaque élément du tableau de chaînes, vous pouvez appeler la méthode Parse pour convertir la chaîne dans sa valeur d'énumération équivalente. L'exemple suivant illustre cette approche.

    
    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)      
    
    
    
  • Vous pouvez appeler la méthode GetValues pour extraire un tableau qui contient les valeurs sous-jacentes dans l'énumération. Ensuite, pour chaque élément du tableau, vous pouvez appeler la méthode ToObject pour convertir l'entier dans sa valeur d'énumération équivalente. L'exemple suivant illustre cette approche.

    
    var values = Enum.GetValues(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    foreach (var value in values) {
       ArrivalStatus status = (ArrivalStatus) Enum.ToObject(typeof(ArrivalStatus), value);
       Console.WriteLine("   {0} ({0:D})", status);
    }                                       
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    
    

Membres non exclusifs et l'attribut Flags

Une utilisation courante d'une énumération est la représentation d'un ensemble de valeurs qui s'excluent mutuellement. Par exemple, une instance ArrivalStatus peut avoir la valeur Early, OnTimeou Late. Cela n'a aucun sens que la valeur d'une instance ArrivalStatus reflète plusieurs constantes d'énumération.

Dans d'autres cas, toutefois, la valeur d'un objet d'énumération peut inclure plusieurs membres d'énumération, et chaque membre représente un champ de bits dans la valeur d'énumération. L'attribut FlagsAttribute peut être utilisé pour indiquer que l'énumération se compose de champs de bits. Par exemple, une énumération nommée Pets peut être utilisée pour indiquer les types d'animaux familiers d'un ménage. Il peut être défini comme suit.


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



L'énumération Pets peut ensuite être utilisée comme indiqué dans l'exemple suivant.


Pets familyPets = Pets.Dog | 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 de bits et de l'application de l'attribut FlagsAttribute.

  • Utilisez uniquement l'attribut personnalisé FlagsAttribute pour une énumération si une opération de bits (AND, OR, EXCLUSIVE OR) doit être exécutée sur une valeur numérique.

  • Définissez des constantes d'énumération à la puissance deux, soit 1, 2, 4, 8, et ainsi de suite. Cela signifie que les indicateurs individuels inclus dans des constantes d'énumération combinées ne se chevauchent pas.

  • Examinons la création d'une constante énumérée pour des combinaisons d'indicateurs couramment utilisées. Par exemple, si une énumération utilisée pour les opérations d'E/S de fichier contient les constantes énumérées Read = 1 et Write = 2, créez la constante énumérée ReadWrite = Read OR Write qui associe les indicateurs Read et Write. De plus, l'opération de bits OR utilisée pour combiner les indicateurs peut être considérée comme un concept avancé dans un contexte qui ne concerne pas les tâches simples.

  • Soyez prudent si vous définissez un nombre négatif comme constante énumérée d'indicateur, car la valeur 1 est souvent affectée aux positions d'indicateur, ce qui peut être source de confusion dans votre code, voire d'erreurs de codage.

  • Pour savoir si un indicateur a une valeur numérique, il suffit d'appeler la méthode HasFlag de l'instance, comme il est indiqué dans l'exemple suivant.

    
    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.      
    
    
    

    Cela revient à effectuer une opération de bits AND entre la valeur numérique et la constante énumérée d'indicateur qui affecte à tous les bits la valeur numérique zéro ne correspondant pas à l'indicateur, puis à tester si le résultat de cette opération est égal à la constante énumérée d'indicateur. L'exemple suivant illustre ce principe.

    
    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.      
    
    
    
  • Utilisez None comme nom de la constante énumérée d'indicateur dont la valeur est nulle. Vous ne pouvez pas utiliser la constante énumérée None dans une opération de bits AND pour tester un indicateur, car le résultat est toujours nul. Toutefois, vous pouvez effectuer une comparaison logique (pas une comparaison de bits) entre la valeur numérique et la constante énumérée None pour déterminer si des bits de la valeur numérique sont définis. L'exemple suivant illustre ce principe.

    
    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.      
    
    
    
  • Ne définissez pas uniquement une valeur d'énumération pour refléter l'état de l'énumération elle-même. Par exemple, ne définissez pas une constante énumérée qui marque simplement la fin de l'énumération. Si vous devez déterminer la dernière valeur de l'énumération, vérifiez explicitement cette valeur. De plus, vous pouvez exécuter un contrôle de plage pour la première et dernière constante énumérée si toutes les valeurs dans la plage sont valides.

L'exemple suivant illustre l'utilisation d'une énumération pour représenter des valeurs nommées et d'une autre énumération pour représenter des champs de bits nommés.


using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [FlagsAttribute]
    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);
    }
}


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ce type est thread-safe.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft