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

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?

InformationsquelleAutor Eric Haskins | 2008-11-09
  1. 81

    Oui, juste le code par rapport à la base Enum type, comme par exemple

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

    Le bas-côté 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.

    • Les exemples que vous citez sont exactement ce que je veux faire, même le même nom. 🙂
    • La langue dans laquelle vous pouvez utiliser les float et double comme le type sous-jacent pour un enum? Vous ne pouvez pas en C# vous obtenez l'erreur CS1008: Type byte, sbyte, short, ushort, int, uint, long, ou ulong prévu
    • La seule langue que je connaisse qui la supporte est CIL. Je n'ai pas réellement essayé de le prouver, car il semble que généralement une mauvaise idée, mais voir Rico commentaires vers le bas ici: en.csharp-online.net/...
    • Non, vous avez besoin de C# 3.0 syntaxe pour les méthodes d'extension, ce qui n'est pas pris en charge dans VS2005.
    • Êtes-vous en mesure d'aider avec ce post? stackoverflow.com/q/18145161/175893
    InformationsquelleAutor Greg Beech
  2. 18

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

    public static void EnumExtension(this Enum e)
{
}

    ou comme ça en VB:

    <Extension()> _
Public Sub EnumExtension(ByVal s As Enum)
End Sub
    InformationsquelleAutor Scott Dorman
  3. 18

    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;
        }
    }
}

    Que 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

    InformationsquelleAutor Michael La Voie
  4. 9

    Voici un autre exemple, également plus agréable à mon humble avis, que d'avoir à créer et initialiser une variable temp.

    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); 
}
    • Vous êtes encore en train de créer une instance temporaire de l'enum dans default(TestEnum), mais celui qui est anonyme et immédiatement en place pour la collecte des ordures. Il est intéressant de souligner que les méthodes d'extension ne fonctionnent tout simplement pas sans une instance de ce qui est étendu, donc la plus proche que nous pouvons obtenir est d'instancier le Type de l'enum lui-même et d'avoir une méthode d'extension hors de ce type. Voir stackoverflow.com/questions/2422113/... pour une intéressante voie de l'accomplissement de cette.
    InformationsquelleAutor Adriaan de Beer
  5. 4

    Vous pouvez également mettre en œuvre 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>();
    • Je pense que chaque Enum implémente IConvertible de toute façon.
    InformationsquelleAutor Koray Bayram
  6. 2

    Il est parfois nécessaire de convertir à partir d'un enum à l'autre, en fonction du nom ou de la valeur de l'enum. Voici comment on peut le faire très bien 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)));
    }
}
    InformationsquelleAutor Esge
  7. 1

    Un autre exemple de faire de la Enum extension - mais cette fois il retourne à l'entrée d'un type enum.

    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();
    InformationsquelleAutor Bronek