Les énumérations (enums) sont un outil précieux en C# pour définir des ensembles de constantes nommées. Fréquemment, vous aurez besoin de convertir une valeur entière en son membre d’énumération correspondant. Cet article explore plusieurs techniques pour effectuer cette conversion de manière sûre et efficace, en mettant l’accent sur les meilleures pratiques.
Table des matières
- Conversion directe
- Utilisation de
Enum.Parse - Utilisation de
Enum.IsDefined - Utilisation de
Enum.TryParse - Conclusion
Conversion directe
La méthode la plus simple est la conversion directe. Cela fonctionne uniquement si vous êtes certain que l’entier représente un membre d’énumération valide. Cependant, elle est sujette aux erreurs et peut entraîner des exceptions au moment de l’exécution si l’entier est invalide.
public enum DaysOfWeek
{
Monday = 1,
Tuesday = 2,
Wednesday = 3,
Thursday = 4,
Friday = 5,
Saturday = 6,
Sunday = 7
}
public class Example
{
public static void Main(string[] args)
{
int dayValue = 3;
DaysOfWeek day = (DaysOfWeek)dayValue;
Console.WriteLine(day); // Sortie : Wednesday
// Ceci lancera une exception au moment de l'exécution si dayValue n'est pas un membre d'énumération valide.
int invalidDayValue = 10;
DaysOfWeek invalidDay = (DaysOfWeek)invalidDayValue;
Console.WriteLine(invalidDay);
}
}
Évitez la conversion directe à moins d’avoir une certitude absolue quant à la validité de l’entier. L’absence de gestion des erreurs la rend risquée pour le code de production.
Utilisation de Enum.Parse
Enum.Parse offre une solution plus robuste. Il prend le type d’énumération et la représentation sous forme de chaîne d’entier en entrée, renvoyant le membre d’énumération correspondant. Il lève une exception ArgumentException si l’entier n’est pas une valeur d’énumération définie.
public class Example
{
public static void Main(string[] args)
{
int dayValue = 3;
try
{
DaysOfWeek day = (DaysOfWeek)Enum.Parse(typeof(DaysOfWeek), dayValue.ToString());
Console.WriteLine(day); // Sortie : Wednesday
}
catch (ArgumentException)
{
Console.WriteLine("Valeur d'énumération invalide.");
}
}
}
Enum.Parse est plus sûr que la conversion directe car il gère explicitement les entrées invalides, empêchant les plantages inattendus. Cependant, la gestion des exceptions ajoute des frais généraux.
Utilisation de Enum.IsDefined
Pour une meilleure efficacité et sécurité, vérifiez l’existence de l’entier dans l’énumération à l’aide de Enum.IsDefined avant d’appeler Enum.Parse.
public class Example
{
public static void Main(string[] args)
{
int dayValue = 3;
if (Enum.IsDefined(typeof(DaysOfWeek), dayValue))
{
DaysOfWeek day = (DaysOfWeek)Enum.Parse(typeof(DaysOfWeek), dayValue.ToString());
Console.WriteLine(day); // Sortie : Wednesday
}
else
{
Console.WriteLine("Valeur d'énumération invalide.");
}
}
}
Cela combine la sécurité de Enum.Parse avec une vérification de validité préliminaire, réduisant les risques d’exceptions.
Utilisation de Enum.TryParse
Enum.TryParse est l’approche recommandée. Il tente la conversion, renvoyant un booléen indiquant le succès ou l’échec sans lever d’exceptions. Cela permet une gestion des erreurs plus propre et plus efficace.
public class Example
{
public static void Main(string[] args)
{
int dayValue = 3;
DaysOfWeek day;
if (Enum.TryParse(dayValue.ToString(), out day))
{
Console.WriteLine(day); // Sortie : Wednesday
}
else
{
Console.WriteLine("Valeur d'énumération invalide.");
}
}
}
Enum.TryParse est la méthode la plus robuste et la plus recommandée en raison de sa gestion des erreurs sans exception et de son efficacité.
Conclusion
Plusieurs méthodes existent pour convertir des entiers en énumérations en C#. Bien que la conversion directe soit concise, elle est la moins sûre. Enum.Parse offre une gestion basée sur les exceptions, et Enum.IsDefined ajoute une vérification préemptive. Cependant, Enum.TryParse se distingue comme la solution la plus robuste et la plus efficace, offrant une gestion des erreurs propre et sans exception. Choisissez la méthode qui convient le mieux à votre contexte, en privilégiant toujours la sécurité et la maintenabilité. Gérez les erreurs potentielles avec élégance pour éviter les comportements inattendus de l’application.