Question

假设我有两个枚举：

    public enum eFruits : int
    {
        Apple = 1,
        Pear = 2,
        Banana = 3
    }

    public enum eAnimals : int
    {
        Dog = 1,
        Cat = 2,
        Rabbit = 3
    }

我想在下拉列表/清单等中使用这些；基本上作为列表项。我目前正在试用的代码是这个；

    public static class EnumHelper
    {     
        public static IEnumerable<(int eCode, eFruits eType)> GetFruitTypesAsListItems()
        {
            var enums = new List<(int eCode, eFruits eType)>();
            foreach (var item in (eFruits[])Enum.GetValues(typeof(eFruits)))
            {
                enums.Add(((int)item, item));
            }
            return enums;
        }
    }

与此有关的两个问题；

1）我想以一种通用的方式来拥有它

2）在列表/下拉列表等内部看起来不太好，所以我想使用ToString覆盖。

因此我想到了这样的东西：

    public class EnumListItem : Tuple<int, T>
    {
        public EnumListItem(int eCode, T eType) 
            : base(eCode, eType)
        { }

        public override string ToString() => $"{base.Item2.ToString()} ({base.Item1})";
    }

实际上有效；

1）我想使用带有元组的泛型

2）希望使用泛型能够基于该元组生成列表项。

这可能吗？我不确定该声明的样子。在这一点上，我无法正常工作。有人可以指出我正确的方向吗？

更新

由于下面的2个答案，我回想起了我容易忘记的地方。

目前的解决方案如下：

    public static class EnumHelper<T> where T : Enum
    {
        public static IEnumerable<EnumListItem<T>> GetEnumElementsAsListItems()
        {
            var enums = new List<EnumListItem<T>>();
            foreach (var item in (T[])Enum.GetValues(typeof(T)))
            {
                var tp = new EnumListItem<T>(Convert.ToInt32(item), item);
                enums.Add(tp);
            }
            return enums;
        }
    }

像元组一样：

    public class EnumListItem<T> : Tuple<int, T>
    {
        public EnumListItem(int item1, T item2)
            : base(item1, item2)
        { }

        public override string ToString() => $"{base.Item2.ToString().Replace("_", " ")} ({base.Item1})";
    }

想尝试为枚举而不是辅助类创建扩展方法。但是现在没有时间解决这个问题。

Answer 1

您可以尝试以下通用方法。

public static class EnumHelper<T>
{
    public static IEnumerable<(int eCode, T eType)> GetListItem()
    {
        var enums = new List<(int eCode, T eType)>();
        foreach (var item in (T[])Enum.GetValues(typeof(T)))
        {
            enums.Add((Convert.ToInt32(item), item));
        }
        return enums;
    }
}

您可以这样称呼，

public static void Main(string[] args)
{
    var animals = EnumHelper<eAnimals>.GetListItem();

    var fruits = EnumHelper<eFruits>.GetListItem();
}

输出：

Answer 2

使其成为通用函数非常简单。您可以使用yield返回可枚举的生成器，而不是使用缓冲的List来消除不必要的内存使用。

public static IEnumerable<(int, TEnum)> GetValues<TEnum>()
where TEnum : struct, Enum
{
    foreach (var item in Enum.GetValues(typeof(TEnum)))
    {
        yield return ((int)item, (TEnum)item);
    }
}

如何在值元组中使用泛型？

2 个答案: