Como adicionar métodos de extensão ao Enums

Eu tenho este código Enum:

enum Duration { Day, Week, Month };

Posso adicionar métodos de extensão para este Enum?

De acordo com este site :

Os métodos de extensão fornecem uma maneira de escrever métodos para as classes existentes de uma maneira que outras pessoas da sua equipe possam descobrir e usar. Dado que enums são classes como qualquer outra, não deve ser muito surpreendente que você possa estendê-las, como:

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

Eu acho que enums não são a melhor escolha em geral, mas pelo menos isso permite centralizar parte do switch / se manipular e abstraí-los um pouco até que você possa fazer algo melhor. Lembre-se de verificar se os valores também estão no intervalo.

Você pode ler mais aqui no Microsft MSDN.

Você também pode adicionar um método de extensão ao tipo Enum, em vez de uma instância do 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;
        }
    }
}

Você pode invocar o método de extensão acima fazendo:

var result = Enum<Duration>.Count;

Não é um verdadeiro método de extensão. Funciona apenas porque Enum <> é um tipo diferente de System.Enum.

Claro que você pode, digamos, por exemplo, que você queira usar o valor DescriptionAttribueem seus enumvalores:

using System.ComponentModel.DataAnnotations;

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

    [Description("Five days")]
    Week,

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

Agora você deseja poder fazer algo como:

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

Seu método de extensão GetDescription()pode ser escrito da seguinte maneira:

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

Todas as respostas são ótimas, mas elas estão falando sobre adicionar um método de extensão a um tipo específico de enumeração.

E se você quiser adicionar um método a todas as enumerações, como retornar um int do valor atual, em vez da conversão explícita?

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

O truque por trás IConvertibleé sua hierarquia de herança, veja MDSN

Obrigado a ShawnFeatherly por sua resposta

Você pode criar uma extensão para qualquer coisa, mesmo object(embora isso não seja considerado uma prática recomendada ). Entenda um método de extensão como um public staticmétodo. Você pode usar qualquer tipo de parâmetro que desejar nos métodos.

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

Veja MSDN .

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

acabamos de fazer uma extensão de enum para c # https://github.com/simonmau/enum_ext

É apenas uma implementação para o typesafeenum, mas funciona muito bem, então criamos um pacote para compartilhar - divirta-se com ele

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

Eu sei que o exemplo é meio inútil, mas você entendeu;)

Uma solução simples.

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

        return ( int ) ( IConvertible ) payLoad;

    }
}

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