So fügen Sie Enums Erweiterungsmethoden hinzu

Ich habe diesen Enum-Code:

enum Duration { Day, Week, Month };

Kann ich eine Erweiterungsmethode für diese Aufzählung hinzufügen?

Laut dieser Seite :

Erweiterungsmethoden bieten eine Möglichkeit, Methoden für vorhandene Klassen so zu schreiben, wie andere Personen in Ihrem Team sie möglicherweise tatsächlich entdecken und verwenden. Angesichts der Tatsache, dass Aufzählungen Klassen wie jede andere sind, sollte es nicht allzu überraschend sein, dass Sie sie erweitern können, wie zum Beispiel:

enum Duration { Day, Week, Month };

static class DurationExtensions 
{
  public static DateTime From(this Duration duration, DateTime dateTime) 
  {
    switch (duration) 
    {
      case Day:   return dateTime.AddDays(1);
      case Week:  return dateTime.AddDays(7);
      case Month: return dateTime.AddMonths(1);
      default:    throw new ArgumentOutOfRangeException("duration");
    }
  }
}

Ich denke, Aufzählungen sind im Allgemeinen nicht die beste Wahl, aber zumindest können Sie so einen Teil des Schalters / der Handhabung zentralisieren und ein wenig abstrahieren, bis Sie etwas Besseres tun können. Denken Sie daran, zu überprüfen, ob die Werte ebenfalls im Bereich liegen.

Weitere Informationen finden Sie hier bei Microsft MSDN.

Sie können dem Aufzählungstyp auch eine Erweiterungsmethode anstelle einer Instanz der Aufzählung hinzufügen:

/// <summary> Enum Extension Methods </summary>
/// <typeparam name="T"> type of Enum </typeparam>
public class Enum<T> where T : struct, IConvertible
{
    public static int Count
    {
        get
        {
            if (!typeof(T).IsEnum)
                throw new ArgumentException("T must be an enumerated type");

            return Enum.GetNames(typeof(T)).Length;
        }
    }
}

Sie können die oben beschriebene Erweiterungsmethode aufrufen, indem Sie Folgendes tun:

var result = Enum<Duration>.Count;

Es ist keine echte Erweiterungsmethode. Dies funktioniert nur, weil Enum <> ein anderer Typ als System.Enum ist.

Natürlich können Sie zum Beispiel das DescriptionAttribuefür Ihre enumWerte verwenden:

using System.ComponentModel.DataAnnotations;

public enum Duration 
{ 
    [Description("Eight hours")]
    Day,

    [Description("Five days")]
    Week,

    [Description("Twenty-one days")] 
    Month 
}

Jetzt möchten Sie in der Lage sein, etwas zu tun wie:

Duration duration = Duration.Week;
var description = duration.GetDescription(); // will return "Five days"

Ihre Erweiterungsmethode GetDescription()kann wie folgt geschrieben werden:

using System.ComponentModel;
using System.Reflection;

public static string GetDescription(this Enum value)
{
    FieldInfo fieldInfo = value.GetType().GetField(value.ToString());
    if (fieldInfo == null) return null;
    var attribute = (DescriptionAttribute)fieldInfo.GetCustomAttribute(typeof(DescriptionAttribute));
    return attribute.Description;
}

Alle Antworten sind großartig, aber es geht darum, einer bestimmten Art von Aufzählung eine Erweiterungsmethode hinzuzufügen.

Was ist, wenn Sie allen Aufzählungen eine Methode hinzufügen möchten, z. B. die Rückgabe eines int mit dem aktuellen Wert anstelle einer expliziten Umwandlung?

public static class EnumExtensions
{
    public static int ToInt<T>(this T soure) where T : IConvertible//enum
    {
        if (!typeof(T).IsEnum)
            throw new ArgumentException("T must be an enumerated type");

        return (int) (IConvertible) soure;
    }

    //ShawnFeatherly funtion (above answer) but as extention method
    public static int Count<T>(this T soure) where T : IConvertible//enum
    {
        if (!typeof(T).IsEnum)
            throw new ArgumentException("T must be an enumerated type");

        return Enum.GetNames(typeof(T)).Length;
    }
}

Der Trick dahinter IConvertibleist die Vererbungshierarchie, siehe MDSN

Vielen Dank an ShawnFeatherly für seine Antwort

Sie können auch für alles eine Erweiterung erstellen object(obwohl dies nicht als Best Practice angesehen wird ). Verstehen Sie eine Erweiterungsmethode nur als public staticMethode. Sie können für Methoden einen beliebigen Parametertyp verwenden.

public static class DurationExtensions
{
  public static int CalculateDistanceBetween(this Duration first, Duration last)
  {
    //Do something here
  }
}

Siehe MSDN .

public static class Extensions
{
  public static string SomeMethod(this Duration enumValue)
  {
    //Do something here
    return enumValue.ToString("D"); 
  }
}

Wir haben gerade eine Enum-Erweiterung für c # https://github.com/simonmau/enum_ext erstellt

Es ist nur eine Implementierung für das Typensafeenum, aber es funktioniert großartig, also haben wir ein Paket zum Teilen erstellt - viel Spaß damit

public sealed class Weekday : TypeSafeNameEnum<Weekday, int>
{
    public static readonly Weekday Monday = new Weekday(1, "--Monday--");
    public static readonly Weekday Tuesday = new Weekday(2, "--Tuesday--");
    public static readonly Weekday Wednesday = new Weekday(3, "--Wednesday--");
    ....

    private Weekday(int id, string name) : base(id, name)
    {
    }

    public string AppendName(string input)
    {
        return $"{Name} {input}";
    }
}

Ich weiß, dass das Beispiel irgendwie nutzlos ist, aber Sie bekommen die Idee;)

Eine einfache Problemumgehung.

public static class EnumExtensions
{
    public static int ToInt(this Enum payLoad) {

        return ( int ) ( IConvertible ) payLoad;

    }
}

int num = YourEnum.AItem.ToInt();
Console.WriteLine("num : ", num);