如何在Enum中指向一个变量？

Question

例如，我想用下面代码中的Dogs for Cats（在这个例子中，字符串“蓬松”将总是从其他地方检索并设置为相同的Enum，在本例中将为't'）。

该代码btw不起作用，但你可以看到我想要做的。

private enum Cats { Fluffy, Furry, Bald }; 
private enum Dogs { Big, Fat, Ugly }; 

sometype CurrentEnum = Cats; 

var x = Enum.Parse(typeof(CurrentEnum), "fluffy", true); 

更新1

从我不认为我已经说得很清楚了我想实现，所以我做了一些变化的响应。

有时CurrentEnum将指向猫，有时指向狗（字符串“蓬松”将相应地不同）。因此，在这个例子中，我可以返回“蓬松”作为枚举，然后获得序列中的下一个项目，如果需要的话可以使用“毛茸茸”。如果CurrentEnum指向狗和字符串是“胖”，我可以去Dogs.Ugly。合理？

更新2

下面是我在哪里：

class Program 
{ 
    enum Cats { Fluffy, Furry, Bald }; 
    enum Dogs { Big, Fat, Ugly }; 

    static Type CurrentEnum; 

    static void Main(string[] args) 
    { 
     CurrentEnum = typeof(Cats); // set elsewhere in program 

     Int32 i = (Int32)Enum.Parse(CurrentEnum, "fluffy", true); 
     Array a = CurrentEnum.GetEnumValues(); 

     Console.WriteLine(a.GetValue(i + 1)); // next in sequence 
    } 
} 

注意CurrentEnum可以在程序的其他地方，但为了确定在枚举下一个值检索需要。我觉得有点奇怪，我必须将枚举转储到数组才能访问这些值。

更新3

现在我已经满足了自己，这是最好的解决办法：

class Program 
{ 
    enum Cats { Fluffy, Furry, Bald }; 
    enum Dogs { Big, Fat, Ugly }; 

    static Type CurrentEnum = typeof(Cats); 

    static void Main(string[] args) 
    { 
     Int32 i = (Int32)Enum.Parse(CurrentEnum, "Bald", true);   
     i = i == CurrentEnum.GetEnumValues().Length - 1 ? 0 : i++; 
     String nextValue = CurrentEnum.GetEnumValues().GetValue(i).ToString(); 

     Console.WriteLine(nextValue); 
     Console.ReadKey(); 
    } 
} 

Answer 1

最后两行可以与

Cats x = (Cats)Enum.Parse(typeof(Cats), "fluffy", true); 

替代这是一个如果您还想避免使用var，则可选择IAbstract的完美答案。

Answer 2

我会给你一个使用泛型的小例子，给你更多的选择。

class Program 
{ 
    private enum Cats { Fluffy, Furry, Bald }; 
    private enum Dogs { Big, Fat, Ugly }; 

    static void Main (string [] args) 
    { 
     var testValue = "Fluffy"; 

     Cats? tempCat; 
     Dogs? tempDog; 

     if( TryParse(testValue, false, out tempCat)) 
      Console.WriteLine ("'{0}' was parsed to a cat", testValue); 

     testValue = "Ugly"; 

     if (TryParse (testValue, false, out tempDog)) 
      Console.WriteLine ("'{0}' was parsed to a dog", testValue); 

     Console.ReadKey (); 

    } 

    public static bool TryParse<T> (string value, bool ignoreCase, out T? result) where T : struct, IComparable, IFormattable, IConvertible 
    { 
     result = null; 
     if (!Enum.IsDefined (typeof (T), value)) 
      return false; 

     result = (T)Enum.Parse (typeof (T), value, ignoreCase); 
     return true; 
    } 
} 

如果您希望它更具动态性，则不必采用“TryParse”方式。如果传递的字符串没有被定义或者T不是枚举，你可以修改它返回T并且让它抛出异常。

public static T Parse<T> (string value, bool ignoreCase = false) where T : struct, IComparable, IFormattable, IConvertible 
    { 
     if (!typeof (T).IsEnum) 
      throw new ArgumentException(string.Format("The type ({0}) must be an enum", typeof (T).FullName)); 


     if (!Enum.IsDefined (typeof (T), value)) 
      throw new ArgumentException(string.Format("{0} is not defined for the enum {1}", value, typeof (T).FullName)); 

     return (T)Enum.Parse (typeof (T), value, ignoreCase); 
    } 

编辑： 对不起，你会召唤第二方法，这样，处理过程中的异常：

var x = Parse<Cats>(testValue); 

Answer 3

试试这个代码了：

class Program 
{ 
    enum Cats { Fluffy, Furry, Bald }; 
    enum Dogs { Big, Fat, Ugly }; 

    static void Main(string[] args) 
    { 
     string name = "Fluffy"; 
     Type currentEnum = typeof(Cats); 

     if(currentEnum.Equals(typeof(Cats))) 
     { 
      Cats cat = (Cats)Enum.Parse(typeof(Cats), name); 
      Console.WriteLine("old " + cat);      // Prints "old Fluffy" 
      Console.WriteLine("new " + (cat + 1));     // Prints "new Furry" // TODO: Add error check for the + 1 
     } 
     else if (currentEnum.Equals(typeof(Dogs))) 
     { 
      Dogs dog = (Dogs)Enum.Parse(typeof(Cats), name); 
      Console.WriteLine("old " + dog); 
      Console.WriteLine("new " + (dog + 1)); 
     } 

     Console.ReadKey(); 
    } 
}