如何遍历静态类常量？

Question

Instead of using a Switch statement as shown in the code below, is there an alternative way to check if foo.Type is a match to any of the constants in the Parent.Child class?

The intended goal is to loop through all of the constant values to see if foo.Type is a match, rather than having to specify each constant as a case .

Parent Class:

public class Parent
{
    public static class Child
    {
        public const string JOHN = "John";
        public const string MARY = "Mary";
        public const string JANE = "Jane";
    }
}

Code:

switch (foo.Type)
{
     case Parent.Child.JOHN:
     case Parent.Child.MARY:
     case Parent.Child.JANE:
         // Do Something
         break;
}

Answer 1

You can find all constant values in the class:

var values = typeof(Parent.Child).GetFields(BindingFlags.Static | BindingFlags.Public)
                                 .Where(x => x.IsLiteral && !x.IsInitOnly)
                                 .Select(x => x.GetValue(null)).Cast<string>();

Then you can check if values contains something:

if(values.Contains("something")) {/**/}

Answer 2

While you can loop through constants that are declared like that using reflection (as the other answers show), it's not ideal.

It would be much more efficient to store them in some kind of enumerable object: an array, List, ArrayList, whatever fits your requirements best.

Something like:

public class Parent {
    public static List<string> Children = new List<string> {"John", "Mary", "Jane"}
}

Then:

if (Parent.Children.Contains(foo.Type) {
    //do something
}

Answer 3

You can use reflection to get all constants of given class:

var type = typeof(Parent.Child);
FieldInfo[] fieldInfos = type.GetFields(BindingFlags.Public |
BindingFlags.Static | BindingFlags.FlattenHierarchy);

var constants = fieldInfos.Where(f => f.IsLiteral && !f.IsInitOnly).ToList();
var constValue = Console.ReadLine();
var match = constants.FirstOrDefault(c => (string)c.GetRawConstantValue().ToString() == constValue.ToString());