enumerador - enum to list c#

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

Question

Tengo este código Enum:

enum Duration { Day, Week, Month };

¿Puedo agregar un método de extensión para este Enum?

Answer 1

De acuerdo con este site :

Los métodos de extensión proporcionan una forma de escribir métodos para las clases existentes de una manera que otras personas en su equipo podrían descubrir y usar. Dado que las enumeraciones son clases como cualquier otra, no debería ser demasiado sorprendente que puedas 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 / si los manejas y abstraerlos un poco hasta que puedas hacer algo mejor. Recuerde verificar que los valores estén dentro del rango también.

Puede leer más here en Microsft MSDN.

Answer 2

Por supuesto, puede decir, por ejemplo, que desea utilizar la DescriptionAttribue en sus valores enum :

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

Answer 3

Puede crear una extensión para cualquier cosa, incluso para object (aunque eso no se considera la mejor práctica ). Comprender un método de extensión solo como un método public static . Puede usar 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
  }
}

Answer 4

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 un tipo diferente de System.Enum.

Answer 5

Todas las respuestas son geniales, pero están hablando de agregar el método de extensión al tipo específico de enum

¿Qué ocurre 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 EnumExtentions
{
    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 de IConvertible es su Jerarquía de herencia ver MDSN

gracias por ShawnFeatherly por su respuesta

Answer 6

Ver here .

public static class Extensions
{
  public static void SomeMethod(this Duration enumValue)
  {
    //Do something here
  }
}