C# 4.0 扩展和枚举类型

我正在尝试向枚举类型添加扩展方法，但下面的代码失败。编译器在第

StoreType.GetAllItems

行给出错误，如何将扩展方法添加到枚举类型

namespace ConsoleApplication1
{

    public static class EnumExtensions
    {
        public static IEnumerable<T> GetAllItems<T>(this Enum value)
        {
            foreach (object item in Enum.GetValues(typeof(T)))
            {
                yield return (T)item;
            }
        }


    }

    class Program
    {

        [Flags]
        public enum StoreType
        {
            Paypal = 1,
            Plimus = 2,
            Other = 3
        };

        static void Main(string[] args)
        {            
           StoreType.GetAllItems //Fail here
        }
    }
}

命名空间控制台应用程序1
{
公共静态类枚举扩展
{
公共静态IEnumerable GetAllItems（此枚举值）
{
foreach（Enum.GetValues（typeof（T））中的对象项）
{
收益回报（T）项；
}
}
}
班级计划
{
[旗帜]
公共枚举存储类型
{
贝宝=1，
Plimus=2，
其他=3
};
静态void Main（字符串[]参数）
{            
StoreType.GetAllItems//此处失败
}
}
}

必须对值而不是类型调用GetAllItems：

StoreType.Paypal.GetAllItems()

但如果不将其作为扩展方法并声明为：

public static class EnumExtensions
{
    public static IEnumerable<T> GetAllItems<T>()
    {
        foreach (object item in Enum.GetValues(typeof(T)))
        {
            yield return (T)item;
        }
    }
}
static void Main(string[] args)
{            
    var allEnumItems = EnumExtensions.GetAllItems<StoreType>()
}

---

之后，您可以使用Enum.TryParse（…）将名称解析回Enum，我认为这是您想要的？

您会看到编译器错误，因为您无法覆盖默认的c#Enum，请尝试通过将方法添加到自定义类来覆盖您的Enum：

public class MyEnum
{
    public static readonly MyEnum A = new MyEnum("A");
    public static readonly MyEnum B = new MyEnum("B");
    public static readonly MyEnum C = new MyEnum("C");
    public static IEnumerable<T> GetAllItems<T>(this Enum value)
    {
        foreach (object item in Enum.GetValues(typeof(T)))
        {
            yield return (T)item;
        }
    }

    public override string ToString()
    {
        return Value;
    }

    protected MyEnum(string value)
    {
        this.Value = value;
    }

    public string Value { get; private set; }
}

public sealed class MyDerivedEnum : MyEnum
{
    public static readonly MyDerivedEnum D = new MyDerivedEnum("D");

    private MyDerivedEnum(string value)
        : base(value)
    {
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyEnum blah = MyEnum.A;
        System.Console.WriteLine(blah);
        blah = MyDerivedEnum.D;
        System.Console.WriteLine(blah);
    }
}

公共类MyEnum
{
公共静态只读MyEnum A=新MyEnum（“A”）；
public static readonly MyEnum B=新的MyEnum（“B”）；
public static readonly MyEnum C=新的MyEnum（“C”）；
公共静态IEnumerable GetAllItems（此枚举值）
{
foreach（Enum.GetValues（typeof（T））中的对象项）
{
收益回报（T）项；
}
}
公共重写字符串ToString（）
{
返回值；
}
受保护的MyEnum（字符串值）
{
这个。值=值；
}
公共字符串值{get；private set；}
}
公共密封类MyDerivedEnum:MyEnum
{
公共静态只读MyDerivedEnum D=新MyDerivedEnum（“D”）；
私有MyDerivedEnum（字符串值）
：基准（值）
{
}
}
班级计划
{
静态void Main（字符串[]参数）
{
MyEnum blah=MyEnum.A；
系统控制台写入线（blah）；
blah=MyDerivedEnum.D；
系统控制台写入线（blah）；
}
}

我认为这是一个带有伪扩展的类。可能是这样的：

用法：

List<HttpStatusCode> list = EnumUtils<HttpStatusCode>.ToList();

Dictionary<int, HttpStatusCode> map = EnumUtils<HttpStatusCode>.ToDictionary();

List List=EnumUtils.ToList（）；
Dictionary map=enumultils.ToDictionary（）；

伪扩展类：

/// <summary>Pseudo extension class for enumerations</summary>
/// <typeparam name="TEnum">Enumeration type</typeparam>
public class EnumUtils<TEnum> where TEnum : struct, IConvertible
{
    public static List<TEnum> ToList()
    {
        var enumType = typeof(TEnum);

        return enumType.IsEnum
            ? enumType.GetEnumValues().OfType<TEnum>().ToList()
            : throw new ArgumentException($"{enumType.Name} is not enum");
    }

    public static Dictionary<int, TEnum> ToDictionary()
    {
        Type enumType = typeof(TEnum);

        return enumType.IsEnum
            ? enumType.GetEnumValues().OfType<TEnum>().ToDictionary(
                e => Convert.ToInt32(Enum.Parse(typeof(TEnum), e.ToString()) as Enum), 
                e => e)
            : throw new ArgumentException($"{enumType.Name} is not enum");
    }
}

///枚举的伪扩展类
///枚举类型
公共类枚举，其中TEnum:struct，IConvertible
{
公共静态列表ToList（）
{
var enumType=typeof（TEnum）；
返回enumType.IsEnum
？enumType.GetEnumValues（）.OfType（）.ToList（）
：抛出新ArgumentException（$“{enumType.Name}不是枚举”）；
}
公共静态字典ToDictionary（）
{
类型enumType=typeof（TEnum）；
返回enumType.IsEnum
？enumType.GetEnumValues（）.OfType（）.ToDictionary(
e=>Convert.ToInt32（Enum.Parse（typeof（TEnum），e.ToString（））作为Enum），
e=>e）
：抛出新ArgumentException（$“{enumType.Name}不是枚举”）；
}
}

享受吧

/// <summary>Pseudo extension class for enumerations</summary>
/// <typeparam name="TEnum">Enumeration type</typeparam>
public class EnumUtils<TEnum> where TEnum : struct, IConvertible
{
    public static List<TEnum> ToList()
    {
        var enumType = typeof(TEnum);

        return enumType.IsEnum
            ? enumType.GetEnumValues().OfType<TEnum>().ToList()
            : throw new ArgumentException($"{enumType.Name} is not enum");
    }

    public static Dictionary<int, TEnum> ToDictionary()
    {
        Type enumType = typeof(TEnum);

        return enumType.IsEnum
            ? enumType.GetEnumValues().OfType<TEnum>().ToDictionary(
                e => Convert.ToInt32(Enum.Parse(typeof(TEnum), e.ToString()) as Enum), 
                e => e)
            : throw new ArgumentException($"{enumType.Name} is not enum");
    }
}