Cómo agregar métodos de extensión a Enums

Tengo este código Enum:

enum Duration { Day, Week, Month };

¿Puedo agregar métodos de extensión para esta enumeración?

Según este sitio :

Los métodos de extensión proporcionan una forma de escribir métodos para clases existentes de una manera que otras personas de su equipo podrían descubrir y utilizar. Dado que las enumeraciones son clases como cualquier otra, no debería ser demasiado sorprendente que pueda extenderlas, 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");
    }
  }
}

Creo que las enumeraciones no son la mejor opción en general, pero al menos esto te permite centralizar algunos de los cambios / if manipularlos y abstraerlos un poco hasta que puedas hacer algo mejor. Recuerde verificar que los valores también estén dentro del rango.

Puede leer más aquí en Microsft MSDN.

También puede agregar un método de extensión al tipo Enum en lugar de una instancia de 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;
        }
    }
}

Puede invocar el método de extensión anterior haciendo:

var result = Enum<Duration>.Count;

No es un verdadero método de extensión. Solo funciona porque Enum <> es de un tipo diferente a System.Enum.

Por supuesto que puede, digamos, por ejemplo, que desea utilizar DescriptionAttribueen sus enumvalores:

using System.ComponentModel.DataAnnotations;

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

    [Description("Five days")]
    Week,

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

Ahora quieres poder hacer algo como:

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

Su método de extensión GetDescription()se puede escribir de la siguiente manera:

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 las respuestas son geniales, pero están hablando de agregar un método de extensión a un tipo específico de enumeración.

¿Qué sucede si desea agregar un método a todas las enumeraciones, como devolver un int del valor actual en lugar de la conversión 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;
    }
}

El truco detrás IConvertiblees su jerarquía de herencia ver MDSN

Gracias a ShawnFeatherly por su respuesta.

Puede crear una extensión para cualquier cosa, incluso object(aunque eso no se considera una práctica recomendada ). Comprenda un método de extensión solo como un public staticmétodo. Puede utilizar el tipo de parámetro que desee en los métodos.

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

Consulte MSDN .

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

acabamos de hacer una extensión de enumeración para c # https://github.com/simonmau/enum_ext

Es solo una implementación para typesafeenum, pero funciona muy bien, así que creamos un paquete para compartir, diviértete con él

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

Sé que el ejemplo es algo inútil, pero entiendes la idea;)

Una solución alternativa sencilla.

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

        return ( int ) ( IConvertible ) payLoad;

    }
}

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