Conception d'énumérations

Les énumérations fournissent des ensembles de valeurs constantes très utiles pour créer des membres fortement typés et améliorer la lisibilité du code. Vous pouvez avoir des énumérations simples ou des énumérations d'indicateurs. Les énumérations simples contiennent des valeurs qui ne sont pas combinées ou utilisées dans des comparaisons de bits. Les énumérations d'indicateurs sont conçues pour être combinées à l'aide d'opérations de bits OR. Les combinaisons de valeurs d'énumération d'indicateurs sont examinées à l'aide d'opérations de bits AND.

Les règles suivantes décrivent les méthodes conseillées en matière de conception d'énumérations.

Utilisez une énumération pour attribuer un type fort aux paramètres, propriétés et valeurs de retour qui représentent des ensembles de valeurs.

Utilisez de préférence une énumération plutôt que des constantes statiques.

L'exemple de code suivant illustre un design incorrect.

Public Class BadFurnishings

    Public Shared Table As Integer = 1
    Public Shared Chair As Integer = 2
    Public Shared Lamp As Integer = 3

End Class

public static class BadFurnishings
{
    public static int Table = 1;
    public static int Chair = 2;
    public static int Lamp = 3;
}

L'exemple de code suivant illustre l'énumération qui doit être utilisée à la place de constantes statiques.

Public Enum GoodFurnishings

    Table
    Chair
    Lamp

End Enum

public enum GoodFurnishings
{
    Table,
    Chair,
    Lamp
}

N'utilisez pas d'énumération pour des ensembles ouverts, tels que la version du système d'exploitation.

L'ajout de valeurs à une énumération déjà livrée peut provoquer un arrêt du code existant. Cette opération est admise dans certains cas mais vous ne devez pas concevoir d'énumération si vous pensez que des valeurs devront lui être ajoutées.

Ne définissez pas de valeurs d'énumération réservées, prévues pour un usage ultérieur.

Dans certains cas, vous pouvez décider que l'ajout de valeurs à l'énumération livrée vaut le risque d'un arrêt possible du code existant. Vous pouvez également définir une nouvelle énumération et les membres qui utilisent ses valeurs.

Évitez d'exposer publiquement des énumérations avec une seule valeur.

N'incluez pas de valeurs de sentinelle dans les énumérations.

Les valeurs de sentinelle servent à identifier les limites des valeurs dans l'énumération. En général, une valeur de sentinelle est utilisée dans les vérifications de plage et ne constitue pas une valeur de donnée valide. L'exemple de code suivant définit une énumération avec une valeur de sentinelle.

Public Enum Furniture

    Desk
    Chair
    Lamp
    Rug
    LastValue

End Enum

public enum Furniture
{
    Desk,
    Chair,
    Lamp,
    Rug,
    LastValue   // The sentinel value.
}

Fournissez une valeur zéro sur les énumérations simples.

Si possible, nommez cette valeur None. Si None ne convient pas, assignez la valeur zéro à la valeur la plus utilisée (la valeur par défaut).

Envisagez d'utiliser System.Int32 (type de données par défaut dans la plupart des langages de programmation) comme type de données sous-jacent d'une énumération sauf si l'une des conditions suivantes est vraie :

• L'énumération est une énumération d'indicateurs et vous possédez plus de 32 indicateurs ou vous prévoyez d'en avoir plus dans le futur.

• Le type sous-jacent doit être différent de Int32 pour simplifier l'interopérabilité avec du code non managé attendant des énumérations de taille différentes.

• Un type sous-jacent plus petit permet d'économiser sensiblement l'espace. Si vous pensez qu'une énumération sera principalement utilisée comme argument d'un flux de contrôle, la taille importe peu. Le gain d'espace peut être important dans les cas suivants :

  • Vous prévoyez que l'énumération sera utilisée comme champ dans une classe ou une structure très fréquemment instanciée.

  • Vous pensez que les utilisateurs créeront de grands tableaux ou collections d'instances d'énumération.

  • Vous prévoyez la sérialisation d'un grand nombre d'instances de l'énumération.

Attribuez aux énumérations d'indicateurs des syntagmes nominaux ou des noms au pluriel. Les noms des énumérations simples doivent être des syntagmes nominaux ou des noms au singulier.

N'étendez pas directement System.Enum.

Certains compilateurs ne vous permettent pas d'étendre Enum sauf si vous le faites de façon indirecte à l'aide du mot clé spécifique au langage, utilisé pour générer des énumérations.

Portions Copyright 2005 Microsoft Corporation. Tous droits réservés.

Portions Copyright Addison-Wesley Corporation. Tous droits réservés.

Pour plus d'informations sur les règles de conception, consultez « règles de conception d'infrastructure : Conventions idiomes et modèles carnet de bibliothèques réutilisables framework » Krzysztof Cwalina et Brad Abrams, publiés par Addison-Wesley, 2005.

Voir aussi

Concepts

Conception d'énumérations d'indicateurs

Ajout de valeurs à des énumérations

Autres ressources

Instructions de conception de types

Instructions de conception pour le développement de bibliothèques de classes