Enumerationserweiterungsmethoden

Question

In vs2008 ist es möglich, eine Erweiterungsmethode zu schreiben, die auf jede Enumeration angewendet wird.

Ich weiß, dass man Erweiterungsmethoden gegen eine bestimmte Enumeration schreiben kann, aber ich möchte in der Lage sein, jede Enumeration mit einer einzelnen Erweiterungsmethode zu verwenden. Ist das möglich?

Answer 1

Ja, einfach gegen den Basistyp Enum coden, z.B.

public static void Etwas(this Enum e)
{
    // Code hier
}

Als Nachteil ist jedoch, dass Sie wahrscheinlich einige ziemlich böse Dinge tun müssen, wie z.B. den echten Basistyp finden mit Enum.GetUnderlyingType, Casten und je nach Basistyp des Enums verschiedene Zweige durchlaufen müssen, aber Sie können einige gute Verwendungen dafür finden (z.B. haben wir Methoden wie IsOneOf und IsCombinationOf, die für alle Enums gelten).

PS: Denken Sie daran, beim Schreiben der Methode, dass Sie, obwohl es nicht empfohlen wird, float und double als Basistypen für Enums verwenden können, sodass Sie auch für diese besondere Fälle benötigen und auch für unsignierte Werte.

Answer 2

Ja, du kannst es. Der Ziel-Erweiterungstyp ist vom Typ Enum. In C# würde dies so gemacht werden:

public static void EnumExtension(this Enum e)
{
}

oder so in VB:

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

Answer 3

Zur Information: Hier ist ein großartiges Beispiel für eine Enum-Erweiterungsmethode, die ich verwenden konnte. Sie implementiert eine Case-Insensitive TryParse() Funktion für Enums:

public static class ExtensionMethods
{
    public static bool TryParse(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;
        }
    }
}

Sie würden sie folgendermaßen verwenden:

public enum TestEnum
{
    A,
    B,
    C
}

public void TestMethod(string StringOfEnum)
{
    TestEnum myEnum;
    myEnum.TryParse(StringOfEnum, out myEnum);
}

Hier sind die zwei Seiten, die ich besucht habe, um diesen Code zu entwickeln:

Case Insensitive TryParse für Enums

Erweiterungsmethoden für Enums

Answer 4

Hier ist ein weiteres Beispiel - meiner Meinung nach auch schöner als die Notwendigkeit, eine temporäre Variable zu erstellen und zu initialisieren.

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

Answer 5

Sie können die Konvertierungsmethode auch wie folgt implementieren:

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.ToString(e);
        }

        return (ConvertType)o;
    }
}

Hier ist ein Beispiel zur Verwendung:

int a = MyEnum.A.Convert();