我有一个枚举类型，定义如下：
public enum eRat { A = 0, B=3, C=5, D=8 };
假设给定值为eRat.B，我想获取下一个值eRat.C
我看到的解决方法是（不包括范围检查）
Array a = Enum.GetValues(typeof(eRat));
int i=0 ;
for (i = 0; i < a.GetLength(); i++)
{
if (a.GetValue(i) == eRat.B)
break;
}
return (eRat)a.GetValue(i+1):
现在这太过复杂了，对于这么简单的东西。你知道任何更好的解决方案吗？像eRat.B+1或者Enum.Next(Erat.B)这样的？
谢谢。
感谢大家的回答和反馈。我很惊讶能得到这么多的回复。查看了它们并使用其中一些想法，我想出了这个最适合我的解决方案:
public static class Extensions
{
public static T Next<T>(this T src) where T : struct
{
if (!typeof(T).IsEnum) throw new ArgumentException(String.Format("Argument {0} is not an Enum", typeof(T).FullName));
T[] Arr = (T[])Enum.GetValues(src.GetType());
int j = Array.IndexOf<T>(Arr, src) + 1;
return (Arr.Length==j) ? Arr[0] : Arr[j];
}
}
return eRat.B.Next();
注意，我正在使用通用扩展方法，因此在调用时不需要指定类型，只需使用 .Next() 即可。
struct 而不是 where T : Enum ？ - Vencovsky可能有点过头了，但：
eRat value = eRat.B;
eRat nextValue = Enum.GetValues(typeof(eRat)).Cast<eRat>()
.SkipWhile(e => e != value).Skip(1).First();
eRat nextValue = Enum.GetValues(typeof(eRat)).Cast<eRat>()
.First(e => (int)e > (int)value);
或者对于下一个更大的数字（自己进行排序）：
eRat nextValue = Enum.GetValues(typeof(eRat)).Cast<eRat>()
.Where(e => (int)e > (int)value).OrderBy(e => e).First();
嘿，拿着LINQ这个工具，世界上的钉子都可以被敲打得服服帖帖 ;-p
eRat value = eRat.D 时，这个不起作用 "InvalidOperationException Sequence contains no elements" http://rextester.com/live/YRGPO87367 - David d C e Freitas你真的需要将这个问题泛化吗？你能否尝试直接这样做呢？
public void SomeMethod(MyEnum myEnum)
{
MyEnum? nextMyEnum = myEnum.Next();
if (nextMyEnum.HasValue)
{
...
}
}
public static MyEnum? Next(this MyEnum myEnum)
{
switch (myEnum)
{
case MyEnum.A:
return MyEnum.B;
case MyEnum.B:
return MyEnum.C;
case MyEnum.C:
return MyEnum.D;
default:
return null;
}
}
在“D”之后该返回什么答案并没有得到解答，因此只能处理到“C”。
[更新1]：根据Marc Gravell的建议进行了更新。
[更新2]：根据husayt的要求进行了更新 - 返回下一个“D”的值为“A”。
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine("Next enum of A = {0}", eRatEnumHelper.GetNextEnumValueOf(eRat.A));
Console.WriteLine("Next enum of B = {0}", eRatEnumHelper.GetNextEnumValueOf(eRat.B));
Console.WriteLine("Next enum of C = {0}", eRatEnumHelper.GetNextEnumValueOf(eRat.C));
}
}
public enum eRat { A = 0, B = 3, C = 5, D = 8 };
public class eRatEnumHelper
{
public static eRat GetNextEnumValueOf(eRat value)
{
return (from eRat val in Enum.GetValues(typeof (eRat))
where val > value
orderby val
select val).DefaultIfEmpty().First();
}
}
结果
A的下一个枚举值为B
B的下一个枚举值为C
C的下一个枚举值为D
D的下一个枚举值为A
C#比C++更好，我会向他展示这个示例，以显示(1)在C#中无法轻松获取下一个或上一个枚举值，以及(2)可以使用select来实现。哦我的天啊！（这不是关于你的问题，而是关于你可以在C#中做什么：有些人会说随心所欲做任何事情很好，有些人会说这是邪恶的。在我看来，这是邪恶的。） - Olivier Ponspublic static class eRat
{
public static readonly eRatValue A;
public static readonly eRatValue B;
public static readonly eRatValue C;
public static readonly eRatValue D;
static eRat()
{
D = new eRatValue(8, null);
C = new eRatValue(5, D);
B = new eRatValue(3, C);
A = new eRatValue(0, B);
}
#region Nested type: ERatValue
public class eRatValue
{
private readonly eRatValue next;
private readonly int value;
public eRatValue(int value, eRatValue next)
{
this.value = value;
this.next = next;
}
public int Value
{
get { return value; }
}
public eRatValue Next
{
get { return next; }
}
public static implicit operator int(eRatValue eRatValue)
{
return eRatValue.Value;
}
}
#endregion
}
int something = eRat.A + eRat.B;
和这个
eRat.eRatValue current = eRat.A;
while (current != null)
{
Console.WriteLine(current.Value);
current = current.Next;
}
using System;
using System.Linq;
public static class Enums
{
public static T Next<T>(this T v) where T : struct
{
return Enum.GetValues(v.GetType()).Cast<T>().Concat(new[] { default(T) }).SkipWhile(e => !v.Equals(e)).Skip(1).First();
}
public static T Previous<T>(this T v) where T : struct
{
return Enum.GetValues(v.GetType()).Cast<T>().Concat(new[] { default(T) }).Reverse().SkipWhile(e => !v.Equals(e)).Skip(1).First();
}
}
使用：
using System;
using System.Linq;
public enum Test { F1, F2, F3 }
public class Program
{
public static void Main()
{
Test t = Test.F3;
Console.WriteLine(t);
Console.WriteLine(t.Next());
Console.WriteLine(t.Previous());
Console.WriteLine("\n");
t = Test.F1;
Console.WriteLine(t);
Console.WriteLine(t.Next());
Console.WriteLine(t.Previous());
}
}
结果：
F3
F1
F2
F1
F2
F3
using System; 和 using System.Linq;。 - user2513149您是否因为某些您无法控制的因素而被限制使用枚举类型？
如果不是这样的话，我建议您使用另一种替代方案——Dictionary<string, int> rat;
如果您创建了一个 Dictionary 并填充了数据，遍历它会更加简单。此外，这是一种更清晰的映射意图方式——你正在将数字映射到字符串上，并试图利用该映射。
如果必须使用枚举类型，我建议您考虑其他方案：
var rats = new List<eRat>() {eRat.A, eRat.B, eRat.C, eRat.D};
IEnumerable<Foo> GetFoosByBar()
IEnumerable<Foo> GetFoosByBaz()
etc...
对于简单的解决方案，您可以从枚举中提取数组。
eRat[] list = (eRat[])Enum.GetValues(typeof(eRat));
foreach (eRat item in list)
//Do something
或查找下一个项目
int index = Array.IndexOf<eRat>(list, eRat.B);
eRat nextItem = list[index + 1];
将数组存储起来比每次从枚举中提取下一个值更好。
但如果您想要更美观的解决方案，请创建类。
public class EnumEnumerator<T> : IEnumerator<T>, IEnumerable<T> {
int _index;
T[] _list;
public EnumEnumerator() {
if (!typeof(T).IsEnum)
throw new NotSupportedException();
_list = (T[])Enum.GetValues(typeof(T));
}
public T Current {
get { return _list[_index]; }
}
public bool MoveNext() {
if (_index + 1 >= _list.Length)
return false;
_index++;
return true;
}
public bool MovePrevious() {
if (_index <= 0)
return false;
_index--;
return true;
}
public bool Seek(T item) {
int i = Array.IndexOf<T>(_list, item);
if (i >= 0) {
_index = i;
return true;
} else
return false;
}
public void Reset() {
_index = 0;
}
public IEnumerator<T> GetEnumerator() {
return ((IEnumerable<T>)_list).GetEnumerator();
}
void IDisposable.Dispose() { }
object System.Collections.IEnumerator.Current {
get { return Current; }
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return _list.GetEnumerator();
}
}
实例化
var eRatEnum = new EnumEnumerator<eRat>();
迭代
foreach (eRat item in eRatEnum)
//Do something
MoveNext
eRatEnum.Seek(eRat.B);
eRatEnum.MoveNext();
eRat nextItem = eRatEnum.Current;
您可以将其简化并概括：
static Enum GetNextValue(Enum e){
Array all = Enum.GetValues(e.GetType());
int i = Array.IndexOf(all, e);
if(i < 0)
throw new InvalidEnumArgumentException();
if(i == all.Length - 1)
throw new ArgumentException("No more values", "e");
return (Enum)all.GetValue(i + 1);
}
编辑： 请注意，如果您的枚举包含重复值（同义词条目），则使用此方法（或此处列出的任何其他技术）将会失败，给定其中一个值。例如：
enum BRUSHSTYLE{
SOLID = 0,
HOLLOW = 1,
NULL = 1,
HATCHED = 2,
PATTERN = 3,
DIBPATTERN = 5,
DIBPATTERNPT = 6,
PATTERN8X8 = 7,
DIBPATTERN8X8 = 8
}
如果给定的是BRUSHSTYLE.NULL或者BRUSHSTYLE.HOLLOW，那么返回值将会是BRUSHSTYLE.HOLLOW。
<leppie>
Update: a generics version:
static T GetNextValue<T>(T e) { T[] all = (T[]) Enum.GetValues(typeof(T)); int i = Array.IndexOf(all, e); if (i < 0) throw new InvalidEnumArgumentException(); if (i == all.Length - 1) throw new ArgumentException("No more values", "e"); return all[i + 1]; }
</leppie>
@leppie:
你的通用版本允许意外传递非枚举值，这只能在运行时捕获。我最初是将其编写为通用版本，但当编译器拒绝 where T : Enum 时，我将其删除，并意识到我并没有从通用性中获得太多好处。唯一的真正缺点是你必须将结果强制转换回你特定的枚举类型。