Méthodes d’extension d’énumération

Dans vs2008, est-il possible d’écrire des méthodes d’extension qui s’appliqueraient à toute énumération.

Je sais que vous pouvez écrire des méthodes d’extension contre une énumération spécifique, mais je veux pouvoir réaliser chaque énumération en utilisant une seule méthode d’extension. Est-ce possible?

Oui, il suffit de coder avec le type de base Enum , par exemple

 public static void Something(this Enum e) { // code here } 

L’ Enum.GetUnderlyingType est que vous allez probablement finir par faire des choses assez désagréables comme trouver le vrai type de base en utilisant Enum.GetUnderlyingType , lancer et descendre différentes twigs en fonction du type de base de l’énumération, mais vous pouvez en trouver bonnes utilisations (par exemple, nous avons des méthodes IsOneOf et IsCombinationOf qui s’appliquent à toutes les énumérations).

PS: Rappelez-vous lors de l’écriture de la méthode que, bien que mal conseillé, vous pouvez utiliser float et double comme types de base pour les enums, vous aurez donc besoin de cas particuliers pour ces valeurs ainsi que des valeurs non signées.

Oui, vous pouvez. Le type d’extension cible est de type Enum . En C #, cela se ferait comme:

 public static void EnumExtension(this Enum e) { } 

ou comme ça dans VB:

  _ Public Sub EnumExtension(ByVal s As Enum) End Sub 

FYI Voici un excellent exemple de méthode d’extension Enum que j’ai pu utiliser. Il implémente une fonction TryParse () insensible à la casse pour les énumérations:

 public static class ExtensionMethods { public static bool TryParse(this Enum theEnum, ssortingng strType, out T result) { ssortingng strTypeFixed = strType.Replace(' ', '_'); if (Enum.IsDefined(typeof(T), strTypeFixed)) { result = (T)Enum.Parse(typeof(T), strTypeFixed, true); return true; } else { foreach (ssortingng value in Enum.GetNames(typeof(T))) { if (value.Equals(strTypeFixed, SsortingngComparison.OrdinalIgnoreCase)) { result = (T)Enum.Parse(typeof(T), value); return true; } } result = default(T); return false; } } } 

Vous l’utiliseriez de la manière suivante:

 public enum TestEnum { A, B, C } public void TestMethod(ssortingng SsortingngOfEnum) { TestEnum myEnum; myEnum.TryParse(SsortingngOfEnum, out myEnum); } 

Voici les deux sites que j’ai visités pour vous aider à trouver ce code:

Insensible à la casse TryParse for Enums

Méthodes d’extension pour les Enums

Voici un autre exemple – IMHO plus agréable que d’avoir à créer et initialiser une variable temporaire.

 public static class ExtensionMethods { public static void ForEach(this Enum enumType, Action action) { foreach (var type in Enum.GetValues(enumType.GetType())) { action((Enum)type); } } } public enum TestEnum { A,B,C } public void TestMethod() { default(TestEnum).ForEach(Console.WriteLine); } 

Vous pouvez également implémenter la méthode de conversion comme suit:

 public static class Extensions { public static ConvertType Convert(this Enum e) { object o = null; Type type = typeof(ConvertType); if (type == typeof(int)) { o = Convert.ToInt32(e); } else if (type == typeof(long)) { o = Convert.ToInt64(e); } else if (type == typeof(short)) { o = Convert.ToInt16(e); } else { o = Convert.ToSsortingng(e); } return (ConvertType)o; } } 

Voici un exemple d’utilisation:

 int a = MyEnum.A.Convert(); 

Parfois, il est nécessaire de convertir un enum en un autre, en fonction du nom ou de la valeur de l’énumération. Voici comment cela peut être fait avec les méthodes d’extension:

 enum Enum1 { One = 1, Two = 2, Three = 3 }; enum Enum2 { Due = 2, Uno = 1 }; enum Enum3 { Two, One }; Enum2 e2 = Enum1.One.ConvertByValue(); Enum3 e3 = Enum1.One.ConvertByName(); Enum3 x2 = Enum1.Three.ConvertByValue(); public static class EnumConversionExtensions { public static T ConvertByName(this Enum value) { return (T)Enum.Parse(typeof(T), Enum.GetName(value.GetType(), value)); } public static T ConvertByValue(this Enum value) { return (T)((dynamic)((int)((object)value))); } } 

Un autre exemple d’extension Enum – mais cette fois, il retourne le type enum en entrée.

 public static IEnumerable toElementsCollection(this T value) where T : struct, IConvertible { if (typeof(T).IsEnum == false) throw new Exception("typeof(T).IsEnum == false"); return Enum.GetValues(typeof(T)).Cast(); } 

Exemple d’utilisation:

 public enum TestEnum { A,B,C }; TestEnum.A.toElementsCollection();