Jak dodać metody rozszerzeń do Enum

Możesz również dodać metodę rozszerzenia do typu Enum, a nie instancję 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 innym typem niż System.Enum.

Oczywiście możesz na przykład użyć DescriptionAttribue na swoich wartościach enum:

using System.ComponentModel.DataAnnotations;

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

    [Description("Five days")]
    Week,

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

Teraz chcesz być w stanie zrobić coś takiego:

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

Twoją metodę rozszerzenia GetDescription() można zapisać 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 enum.

Co zrobić, jeśli chcesz dodać metodę do wszystkich enum, na przykład zwracając int bieżącej wartości zamiast jawnego odlewania?

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

Sztuką stojącą za IConvertible jest hierarchia dziedziczenia patrz MDSN

Podziękowania dlaShawnFeatherly za odpowiedź

Możesz utworzyć rozszerzenie dla wszystkiego, nawet object (chociaż nie jest to uważane za najlepszą praktykę). Zrozum metodę rozszerzenia tak jak metodę public static. 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
  }
}

Patrz MSDN .

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

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

Właśnie zrobiliśmy rozszerzenie enum 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ę z nim

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