L'énumération des méthodes d'extension

Question

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

Je sais que vous pouvez écrire les méthodes d'extension à l'égard d'une énumération, mais je veux être en mesure à chaque énumération en utilisant une seule méthode d'extension. Est-ce possible?

Answer 1

Oui, le code contre la base, Enum type, comme par exemple

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

L'inconvénient est que vous allez probablement finir par faire certaines choses désagréables, comme trouver le vrai type de base à l'aide de Enum.GetUnderlyingType, lancer, et d'aller vers le bas des branches différentes selon le type de base de l'enum est, mais vous pouvez trouver quelques bonnes utilisations (par exemple, nous avons IsOneOf et IsCombinationOf méthodes qui s'appliquent à tous les énumérations).

PS: n'oubliez pas lors de l'écriture de la méthode qui, bien que mal avisé, vous pouvez utiliser float et double que les types de base pour les énumérations, de sorte que vous aurez besoin de quelques cas particuliers pour les personnes ainsi que les valeurs non signées.

Answer 2

Oui, vous le pouvez. La cible extenstion est de type Enum. En C#, ce serait le fait que:

public static void EnumExtension(this Enum e)
{
}

ou comme ça en VB:

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

Answer 3

Pour info Voici un excellent exemple d'un Enum Extension de la méthode que j'ai été en mesure d'utiliser. Il met en œuvre un casse TryParse() fonction pour les enums:

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 pouvez l'utiliser 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é pour aider à venir avec ce code:

Insensible à la casse TryParse pour les Enums

Les méthodes d'Extension pour les Enums

Answer 4

Voici un autre exemple, également plus agréable à mon humble avis, 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 la 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>();