Méthodes d'extension d'énumération

Question

Dans vs2008, est-il possible d’écrire une méthode d’extension qui s’appliquerait à toute énumération?

Je sais que vous pouvez écrire des méthodes d'extension par rapport à une énumération spécifique, mais je veux pouvoir effectuer chaque énumération à l'aide d'une seule méthode d'extension. Est-ce possible?

Answer 1

Oui, codez simplement contre le type Enum de base, par exemple

.

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

L'inconvénient, c'est que vous finirez probablement par faire des choses assez désagréables, telles que trouver le type de base réel à l'aide de Enum.GetUnderlyingType , en diffusant et en descendant différentes branches en fonction du type de base de l'énum, ??mais vous pouvez trouver de bons utilise pour cela (par exemple, nous avons les méthodes IsOneOf et IsCombinationOf qui s'appliquent à tous les enums).

PS: N'oubliez pas, 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 énumérations, vous aurez donc besoin de cas particuliers. pour ceux-ci ainsi que les valeurs non signées.

Answer 2

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

public static void EnumExtension(this Enum e)
{
}

ou comme ceci en VB:

<Extension()> _
Public Sub EnumExtension(ByVal s As Enum)
End Sub

Answer 3

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<T>(this Enum theEnum, string strType, 
        out T result)
    {
        string strTypeFixed = strType.Replace(' ', '_');
        if (Enum.IsDefined(typeof(T), strTypeFixed))
        {
            result = (T)Enum.Parse(typeof(T), strTypeFixed, true);
            return true;
        }
        else
        {
            foreach (string value in Enum.GetNames(typeof(T)))
            {
                if (value.Equals(strTypeFixed, 
                    StringComparison.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(string StringOfEnum)
{
    TestEnum myEnum;
    myEnum.TryParse(StringOfEnum, out myEnum);
}

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

TryParse insensible à la casse pour Enums

Méthodes d'extension pour Enums

Answer 4

Voici un autre exemple - un 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<Enum> 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); 
} 

Answer 5

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

public static class Extensions
{
    public static ConvertType Convert<ConvertType>(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.ToString(e);
        }

        return (ConvertType)o;
    }
}

Voici un exemple d'utilisation:

int a = MyEnum.A.Convert<int>();

Answer 6

Parfois, il est nécessaire de convertir une énumération en une autre, en fonction du nom ou de la valeur de l'énumération. Voici comment procéder 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<Enum2>();
Enum3 e3 = Enum1.One.ConvertByName<Enum3>();
Enum3 x2 = Enum1.Three.ConvertByValue<Enum3>();

public static class EnumConversionExtensions
{
    public static T ConvertByName<T>(this Enum value)
    {
        return (T)Enum.Parse(typeof(T), Enum.GetName(value.GetType(), value));
    }

    public static T ConvertByValue<T>(this Enum value)
    {
        return (T)((dynamic)((int)((object)value)));
    }
}

Answer 7

Un autre exemple de création d’extension Enum - mais cette fois, il retourne le type d’énumération en entrée.

public static IEnumerable<T> toElementsCollection<T>(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<T>();
    }

Exemple d'utilisation:

public enum TestEnum { A,B,C };

TestEnum.A.toElementsCollection();