Jak mogę uzyskać wszystkie stałe typu według odbicia?

Question

Jak mogę uzyskać wszystkie stałe dowolnego rodzaju za pomocą odbicia?

Answer 1

Mimo to stary kod:

private FieldInfo[] GetConstants(System.Type type) 
{ 
    ArrayList constants = new ArrayList(); 

    FieldInfo[] fieldInfos = type.GetFields(
     // Gets all public and static fields 

     BindingFlags.Public | BindingFlags.Static | 
     // This tells it to get the fields from all base types as well 

     BindingFlags.FlattenHierarchy); 

    // Go through the list and only pick out the constants 
    foreach(FieldInfo fi in fieldInfos) 
     // IsLiteral determines if its value is written at 
     // compile time and not changeable 
     // IsInitOnly determine if the field can be set 
     // in the body of the constructor 
     // for C# a field which is readonly keyword would have both true 
     // but a const field would have only IsLiteral equal to true 
     if(fi.IsLiteral && !fi.IsInitOnly) 
      constants.Add(fi);   

    // Return an array of FieldInfos 
    return (FieldInfo[])constants.ToArray(typeof(FieldInfo)); 
} 

Source

można łatwo przekształcić go czystsze kod za pomocą leków generycznych i LINQ:

private List<FieldInfo> GetConstants(Type type) 
{ 
    FieldInfo[] fieldInfos = type.GetFields(BindingFlags.Public | 
     BindingFlags.Static | BindingFlags.FlattenHierarchy); 

    return fieldInfos.Where(fi => fi.IsLiteral && !fi.IsInitOnly).ToList(); 
} 

lub jednym wierszu:

type.GetFields(BindingFlags.Public | BindingFlags.Static | 
       BindingFlags.FlattenHierarchy) 
    .Where(fi => fi.IsLiteral && !fi.IsInitOnly).ToList(); 

Answer 2

użycie property.GetConstantValue(), aby uzyskać wartość

Answer 3

Jako rozszerzeń Rodzaj:

public static class TypeExtensions 
{ 
    public static IEnumerable<FieldInfo> GetConstants(this Type type) 
    { 
     var fieldInfos = type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy); 

     return fieldInfos.Where(fi => fi.IsLiteral && !fi.IsInitOnly); 
    } 

    public static IEnumerable<T> GetConstantsValues<T>(this Type type) where T : class 
    { 
     var fieldInfos = GetConstants(type); 

     return fieldInfos.Select(fi => fi.GetRawConstantValue() as T); 
    } 
} 

Answer 4

Jeśli chcieliby Państwo uzyskać wartości wszystkich stałych określonego typu, od rodzaju docelowej, tutaj jest to metoda rozszerzenie (rozszerzenie niektórych odpowiedziach na tej stronie):

public static class TypeUtilities 
{ 
    public static List<T> GetAllPublicConstantValues<T>(this Type type) 
    { 
     return type 
      .GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy) 
      .Where(fi => fi.IsLiteral && !fi.IsInitOnly && fi.FieldType == typeof(T)) 
      .Select(x => (T)x.GetRawConstantValue()) 
      .ToList(); 
    } 
} 

Następnie dla klasy jak ten

static class MyFruitKeys 
{ 
    public const string Apple = "apple"; 
    public const string Plum = "plum"; 
    public const string Peach = "peach"; 
    public const int WillNotBeIncluded = -1; 
} 

można uzyskać string wartości stałych tak:

List<string> result = typeof(MyFruitKeys).GetAllPublicConstantValues<string>(); 
//result[0] == "apple" 
//result[1] == "plum" 
//result[2] == "peach"