Select constants from a list by propertyname

Question

public class Constants
{
    public const string test1 = "This is testvalue1;"
    public const string test2 = "This is testvalue1;"
    public const string test3 = "This is testvalue1;"
    public const string test4 = "This is testvalue1;"
    public const string test5 = "This is testvalue1;"
}

is it in some way possible to get a constants string by usage of var propertyString = Constants.Where(<Propertyname> == test1).ToString() ?

You'd have to use reflection, but if you need to do such things, it's probably a better idea to use a static array or dictionary instead of individual constants. — Meta-Knight, Jan 24 '12 at 14:22
See vc 74's answer ;-) Reflection is slower and is kind of a needless hack in your case, I think. — Meta-Knight, Jan 25 '12 at 12:42

score 4 · Accepted Answer · answered Jan 24 '12 at 14:21

4

You will have to do this through reflection.

string fieldName = "test1";
object fieldValue = typeof(Constants).GetField(fieldName, BindingFlags.Static).GetValue(null);

answered Jan 24 '12 at 14:21

Daniel A. White

187,200
47
362
445

Is there also a way to reverse this? So I can find the propertyname by it's value? – Theun Arbeider Jan 25 '12 at 10:41
Already found the answer to the question above: typeof.GetFields().Where(m=> (string)m.GetValue(null) == "test1").First(); – Theun Arbeider Jan 25 '12 at 11:12

score 2 · Answer 2 · answered Jan 24 '12 at 14:29

Alternatively to the other reflection oriented answers, you could use a dictionary:

public string GetConstantValue(string key)
{
  return _constants[key];
}

private Dictionary<string, string> Constants = new Dictionary<string, string>()
{
  { "test1", "This is testvalue1;" },
  { "test2", "This is testvalue2;" },
  { "test3", "This is testvalue3;" },
  { "test4", "This is testvalue4;" },
  { "test5", "This is testvalue5;" },
};

And then use MyClass.GetConstantValue("test1") to get the constants value.

dg90 · Answer 3 · 2012-01-25T11:41:24.323

2

This also could work:

    foreach (var prop in typeof(Constants).GetFields())
    {
        string test = prop.GetRawConstantValue().ToString();

        if (test == "test1")
            MessageBox.Show("You got me!");
    }

edited Jan 25 '12 at 11:41

answered Jan 24 '12 at 14:30

dg90

1,243
3
17
30

1

Can't really see the use for the first line. But yes, it works :) – Theun Arbeider Jan 25 '12 at 10:45

score 1 · Answer 4 · answered Jan 24 '12 at 14:31

1

You can use Reflection.

List<string> messages = new List<string>();
foreach (FieldInfo field in typeof(Constants).GetFields().Where(f =>         f.Name.StartsWith("test")))
{
   messages.Add(field.GetRawConstantValue().ToString());

}

answered Jan 24 '12 at 14:31

Raj Ranjhan

3,869
2
19
29

score 1 · Answer 5 · answered Jan 24 '12 at 14:52

In order to get this,

var p = Constants.Get("test1");//gives 'This is testvalue1'

You can do this -

public class Constants
{
    public const string test1 = "This is testvalue1";
    public const string test2 = "This is testvalue1";
    public const string test3 = "This is testvalue1";
    public const string test4 = "This is testvalue1";
    public const string test5 = "This is testvalue1";

    public static string Get(string propertyName)
    {
      var value = (string)(typeof(Constants).GetField(propertyName,BindingFlags.Static | BindingFlags.Public).GetValue(null));
      return value;
    }
}

score 0 · Answer 6 · answered Jan 24 '12 at 14:25

Sure it's possible. Following piece of code uses reflection to loop through all constants of a class.

internal class Program
{
    public const string ConstExample = "constant value";

    private static void Main(string[] args)
    {
        FieldInfo[] fieldInfos = typeof(Program).GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);

        var constants = fieldInfos.Where(z => z.IsLiteral && !z.IsInitOnly).ToList();
        foreach (var constant in constants)
        {
            string constantName = constant.Name;
            object constantValue = constant.GetValue(null);
            Console.WriteLine(string.Format("Constante name: {0}, constant value: {1}", constantName, constantValue));
        }

        Console.ReadKey();
    }
}

score 0 · Answer 7 · answered Jan 24 '12 at 14:43

For good performance and readability I would recommend an array and an enumeration.

class App
{
    private enum ConstantsEnum: int
    {
      DefaultName = 0,
      DefaultMode = 1,
      DefaultStatus = 2
    }
    private readonly string[] Constants = new string[]{
        "MyProgram",
        "Test",
        "Enabled" };

    private void DoWork()
    {
        Console.WriteLine(Constants[ConstantsEnum.DefaultName]);
    }
}

Note that all variables have to be of type string. If you want to mix and match datatypes then you could possibly use object[] instead of string[], but this would be more expensive and not type-safe.

If you are just looking for a way to group some properties, then this is much better than reflection.

Select constants from a list by propertyname

7 Answers7