Jak dodać metody rozszerzające do wyliczeń

Mam ten kod Enum:

enum Duration { Day, Week, Month };

Czy mogę dodać metody rozszerzenia dla tego wyliczenia?

Według tej strony :

Metody rozszerzające umożliwiają pisanie metod dla istniejących klas w sposób, w jaki inne osoby w Twoim zespole mogą faktycznie je odkrywać i używać. Biorąc pod uwagę, że wyliczenia są klasami jak wszystkie inne, nie powinno dziwić, że można je rozszerzyć, na przykład:

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

Myślę, że wyliczenia nie są ogólnie najlepszym wyborem, ale przynajmniej pozwala to scentralizować niektóre przełączniki / jeśli je obsługiwać i nieco je oddzielić, aż będziesz mógł zrobić coś lepszego. Pamiętaj, aby sprawdzić, czy wartości również mieszczą się w zakresie.

Możesz przeczytać więcej tutaj w Microsft MSDN.

Możesz również dodać metodę rozszerzenia do typu Enum zamiast wystąpienia Enum:

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

Możesz wywołać powyższą metodę rozszerzenia, wykonując:

var result = Enum<Duration>.Count;

To nie jest prawdziwa metoda rozszerzenia. Działa tylko dlatego, że Enum <> jest innego typu niż System.Enum.

Oczywiście możesz na przykład powiedzieć, że chcesz użyć DescriptionAttribuena swoich enumwartościach:

using System.ComponentModel.DataAnnotations;

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

    [Description("Five days")]
    Week,

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

Teraz chcesz móc zrobić coś takiego:

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

Twoja metoda rozszerzenia GetDescription()może być zapisana w następujący sposób:

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

Wszystkie odpowiedzi są świetne, ale mówią o dodaniu metody rozszerzenia do określonego typu wyliczenia.

A co, jeśli chcesz dodać metodę do wszystkich wyliczeń, na przykład zwracającą int bieżącej wartości zamiast jawnego rzutowania?

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

Sztuczka IConvertiblepolega na tym, że Hierarchia dziedziczenia, patrz MDSN

Dziękuję ShawnFeatherly za odpowiedź

Możesz utworzyć rozszerzenie dla wszystkiego, nawet object(chociaż nie jest to uważane za najlepszą praktykę ). Zrozum metodę rozszerzania tak samo, jak public staticmetodę. Możesz użyć dowolnego typu parametru w metodach.

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

Zobacz MSDN .

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

właśnie stworzyliśmy rozszerzenie wyliczenia dla c # https://github.com/simonmau/enum_ext

To tylko implementacja dla typesafeenum, ale działa świetnie, więc stworzyliśmy pakiet do udostępnienia - baw się dobrze

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

Wiem, że przykład jest trochę bezużyteczny, ale masz pomysł;)

Proste obejście.

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

        return ( int ) ( IConvertible ) payLoad;

    }
}

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