Enumeration Erweiterungsmethoden

https://stackoverflow.com/questions/276585

07-07-2019
|

Frage

In VS2008 ist es möglich, eine Erweiterung Methoden zu schreiben, die auf jede Aufzählung gelten würden.

Ich weiß, dass Sie Erweiterungsmethoden gegen eine bestimmte Aufzählung schreiben können, aber ich mag jede Aufzählung der Lage sein, ein einzelnen Verlängerungsverfahren. Ist das möglich?

Lösung

Ja, nur Code gegen die Basis Enum Typen, z.

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

Die Kehrseite ist, dass Sie werden wahrscheinlich einige ziemlich üble Sachen am Ende tun wie der realen Basistyp zu finden, mit

Andere Tipps

Ja, Sie können. Das Ziel extenstion Typ ist vom Typ Enum. In C #, würde dies getan, wie:

public static void EnumExtension(this Enum e)
{
}

oder wie dies in VB:

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

Zu Ihrer Information ist hier ein gutes Beispiel für eine Enum Erweiterung Methode, die ich in der Lage gewesen, zu verwenden. Es implementiert einen Fall unempfindlich TryParse () Funktion für Aufzählungen:

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

Sie würden es auf die folgende Weise verwendet werden:

public enum TestEnum
{
    A,
    B,
    C
}

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

Hier sind die beiden Seiten, die ich mit diesem Code kommen zu helfen besucht:

Case Insensitive TryParse für Aufzählungen

Erweiterungsmethoden für Aufzählungen

Hier ist ein weiteres Beispiel -. Auch schöner IMHO, als wenn zu erstellen und eine temporäre Variable initialisieren

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

Sie können auch Konvertierungsmethode implementieren wie folgt:

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

Hier ist ein Beispiel für die Verwendung:

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

Manchmal ist es notwendig, von einer Enum in einem anderes zu konvertieren, basierend auf dem Namen oder den Wert der Enumeration. Hier ist, wie kann es gut mit Erweiterungsmethoden erfolgen:

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

Ein weiteres Beispiel zur Herstellung von Enum-Erweiterung -. Aber diesmal ist es die Eingabe Aufzählungstyp gibt

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

Beispiel für die Verwendung:

public enum TestEnum { A,B,C };

TestEnum.A.toElementsCollection();

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow