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