Nombre total d'éléments définis dans une énumération

Comment puis-je obtenir le nombre d'éléments définis dans une énumération?

Vous pouvez utiliser la méthode statique Enum.GetNamesqui renvoie un tableau représentant les noms de tous les éléments de l'énumération. La propriété length de ce tableau est égale au nombre d'éléments définis dans l'énumération

var myEnumMemberCount = Enum.GetNames(typeof(MyEnum)).Length;

La question est:

Comment puis-je obtenir le nombre d'éléments définis dans une énumération?

Le nombre «d'articles» pourrait vraiment signifier deux choses complètement différentes. Prenons l'exemple suivant.

enum MyEnum
{
    A = 1,
    B = 2,
    C = 1,
    D = 3,
    E = 2
}

Quel est le nombre «d'articles» défini dans MyEnum?

Le nombre d'articles est-il 5? ( A, B, C, D, E)

Ou est-ce 3? ( 1, 2, 3)

Le nombre de noms définis en MyEnum(5) peut être calculé comme suit.

var namesCount = Enum.GetNames(typeof(MyEnum)).Length;

Le nombre de valeurs définies en MyEnum(3) peut être calculé comme suit.

var valuesCount = Enum.GetValues(typeof(MyEnum)).Cast<MyEnum>().Distinct().Count();

Enum.GetValues (typeof (MyEnum)). Length;

Une astuce astucieuse que j'ai vue dans une réponse C à cette question, il suffit d'ajouter un dernier élément à l'énumération et de l'utiliser pour dire combien d'éléments sont dans l'énumération:

enum MyType {
  Type1,
  Type2,
  Type3,
  NumberOfTypes
}

Dans le cas où vous définissez une valeur de départ autre que 0, vous pouvez utiliser NumberOfTypes - Type1 pour déterminer le nombre d'éléments.

Je ne sais pas si cette méthode serait plus rapide que d'utiliser Enum, et je ne sais pas non plus si elle serait considérée comme la bonne façon de le faire, car nous avons Enum pour vérifier ces informations pour nous.

À partir des réponses précédentes, il suffit d'ajouter un exemple de code.

 class Program
    {
        static void Main(string[] args)
        {
            int enumlen = Enum.GetNames(typeof(myenum)).Length;
            Console.Write(enumlen);
            Console.Read();
        }
        public enum myenum
        {
            value1,
            value2
        }
    }

Vous pouvez utiliser Enum.GetNames pour renvoyer un IEnumerable de valeurs dans votre énumération, puis .Count the IEnumerable résultant.

GetNames produit à peu près le même résultat que GetValues ​​mais est plus rapide.

Si vous vous retrouvez à écrire la solution ci-dessus aussi souvent que moi, vous pouvez l'implémenter en tant que générique:

public static int GetEnumEntries<T>() where T : struct, IConvertible 
{
    if (!typeof(T).IsEnum)
        throw new ArgumentException("T must be an enumerated type");

    return Enum.GetNames(typeof(T)).Length;
}

J'étais en train d'examiner cette question tout à l'heure et je n'étais pas satisfait de la lisibilité de la solution actuelle. Si vous écrivez du code de manière informelle ou sur un petit projet, vous pouvez simplement ajouter un autre élément à la fin de votre énumération appelé "Longueur". De cette façon, il vous suffit de taper:

var namesCount = (int)MyEnum.Length;

Bien sûr, si d'autres vont utiliser votre code - ou je suis sûr que dans de nombreuses autres circonstances qui ne s'appliquent pas à moi dans ce cas - cette solution peut être de mal avisée à terrible.

Pour Visual Basic:

[Enum].GetNames(typeof(MyEnum)).Lengthn'a pas travaillé avec moi, mais l'a [Enum].GetNames(GetType(Animal_Type)).lengthfait.