HOWTO · Csharp

Convertir Int en Enum en C#

Apprenez à convertir un entier en enum C# par cast ou par analyse (parsing), et à vérifier si le résultat est un membre déclaré.

Sur cette page

Pour convertir un entier en énumération en C#, convertissez-le explicitement vers le type enum : MyEnum value = (MyEnum)number;. Une énumération est un type valeur composé de constantes nommées et possède un type intégral sous-jacent. La conversion transforme la valeur sous-jacente, mais ne vérifie pas si elle correspond à une constante déclarée. Utilisez Enum.IsDefined si seules les valeurs nommées sont acceptables ; si l’entrée est du texte, utilisez Enum.Parse ou Enum.TryParse.

Convertir un entier en énumération avec une conversion directe

Une conversion directe est le choix le plus simple lorsque l’entier est déjà disponible et que vous en maîtrisez la valeur. Cet exemple complet définit une énumération dont le type sous-jacent par défaut est int, convertit la valeur 2 et affiche le nom du membre correspondant.

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        int number = 2;
        MyEnum value = (MyEnum)number;
        Console.WriteLine($"Converted Enum Value: {value}");
    }
}

La conversion ne valide pas le résultat. Par exemple, convertir 7 produit une valeur d’énumération dont la valeur sous-jacente est 7, même si MyEnum ne déclare aucun membre correspondant. Si votre application doit accepter uniquement les membres déclarés, vérifiez la valeur avec Enum.IsDefined avant la conversion. Le libellé de sortie « Converted Enum Value: Two » reste en anglais dans l’exemple inchangé.

Analyser une chaîne contenant un entier avec Enum.Parse

Enum.Parse prend une chaîne en argument. Lorsqu’un entier est fourni sous forme de texte, transmettez cette chaîne à la méthode, puis convertissez l’object qu’elle renvoie vers le type enum voulu. L’exemple analyse la chaîne numérique "1".

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        string input = "1";
        MyEnum value = (MyEnum)Enum.Parse(typeof(MyEnum), input);
        Console.WriteLine($"Parsed Enum Value: {value}");
    }
}

L’analyse d’une chaîne numérique peut produire une valeur d’énumération dont le nombre sous-jacent ne correspond à aucun membre déclaré. Enum.Parse signale aussi une entrée mal formée en lançant une exception. Utilisez donc Enum.TryParse si vous voulez gérer un échec de conversion ordinaire sans vous appuyer sur les exceptions pour contrôler le flux. Une analyse réussie ne vérifie pas à elle seule l’appartenance aux membres déclarés. Le libellé de sortie « Parsed Enum Value: One » reste en anglais dans l’exemple inchangé.

Vérifier qu’une valeur d’énumération est déclarée avec Enum.IsDefined

Utilisez Enum.IsDefined pour déterminer si une valeur correspond à une constante d’énumération déclarée. Cet exemple vérifie une valeur entière déclarée et une autre qui ne l’est pas, avant de les convertir. Comme le type sous-jacent par défaut de MyEnum est int, les arguments int empaquetés correspondent au type sous-jacent de l’énumération.

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        int[] candidates = { 2, 7 };

        foreach (int number in candidates)
        {
            if (Enum.IsDefined(typeof(MyEnum), number))
            {
                MyEnum value = (MyEnum)number;
                Console.WriteLine($"{number}: defined as {value}");
            }
            else
            {
                Console.WriteLine($"{number}: not defined");
            }
        }
    }
}

Enum.IsDefined recherche une correspondance exacte avec une constante déclarée. Cette méthode convient à une énumération simple dont les valeurs sont déclarées séparément. Avec une énumération [Flags], une combinaison valide d’indicateurs peut ne pas être déclarée en tant que telle ; cette vérification peut donc rejeter des combinaisons que votre application souhaite autoriser. Dans la sortie inchangée, les libellés « defined as » et « not defined » restent en anglais.

Analyser une chaîne contenant un entier avec Enum.TryParse

Enum.TryParse renvoie un booléen indiquant si le texte a pu être converti vers le type enum et écrit la valeur analysée dans son paramètre out. Si l’entrée dont vous disposez est un entier, convertissez-le d’abord en texte. L’exemple vérifie aussi séparément l’appartenance aux membres déclarés, car une analyse numérique réussie ne prouve pas que le nombre désigne un membre déclaré.

using System;

public class Program
{
    public enum MyEnum { Zero = 0, One = 1, Two = 2 }

    public static void Main()
    {
        int number = 1;
        string input = number.ToString();

        if (Enum.TryParse<MyEnum>(input, out MyEnum value))
        {
            Console.WriteLine($"Parsed: {value}");
            Console.WriteLine($"Declared: {Enum.IsDefined(typeof(MyEnum), value)}");
        }
        else
        {
            Console.WriteLine("Could not parse the input.");
        }
    }
}

Pour une entrée constituée d’un nom, Enum.TryParse accepte aussi le nom d’un membre déclaré, par exemple "Two". Un texte numérique peut être analysé en une valeur sous-jacente non déclarée. Conservez donc la vérification avec Enum.IsDefined si l’application exige un membre déclaré exact. Utilisez la surcharge ignoreCase uniquement si une comparaison des noms sans tenir compte de la casse est appropriée. Dans la sortie inchangée, les libellés « Parsed » et « Declared » restent en anglais.

Choisir la méthode de conversion adaptée

Choisissez la méthode selon la forme de l’entrée et le type de validation nécessaire :

  • Utilisez une conversion directe pour un entier auquel vous faites déjà confiance et si une valeur d’énumération non déclarée est acceptable.
  • Utilisez Enum.Parse pour du texte si un échec d’analyse doit être traité comme une exception.
  • Utilisez Enum.TryParse pour du texte si vous voulez obtenir un résultat booléen indiquant la réussite de la conversion.
  • Utilisez Enum.IsDefined avant ou après la conversion si seules les constantes d’énumération déclarées sont acceptables.

Aucune des deux méthodes d’analyse ne garantit qu’une valeur numérique désigne une constante déclarée. Pour une entrée non fiable ou dynamique, essayez de l’analyser, puis vérifiez avec Enum.IsDefined si votre application accepte uniquement les membres déclarés. Pour les énumérations [Flags], définissez et appliquez vos propres règles de validation des combinaisons autorisées au lieu de vous fier uniquement à Enum.IsDefined.