Loop through constant members of a class

Question

I have a class with constant strings in it. I'd like to throw all of those strings into a drop down collection. What is the best way to do this? This is what I have now and in theory, I would think that it would be the best way to do this.

public class TestClass
{
    private const string _testA = "Test A";
    private const string _testB = "Test B";

    public string TestA
    {
        get { return _testA; }
    }

    public string TestB
    {
        get { return _testB; }
    }
}

public DropDownItemCollection TestCollection
{
    DropDownItemCollection collection = new DropDownItemCollection();
    TestClass class = new TestClass();

    foreach (string testString in class)
    {
        DropDownItem item = new DropDownItem();
        item.Description = testString;
        item.Value = testString;
        collection.Add(item);
    }

    return collection;
}

The problem is that this returns an error on the foreach: "...does not contain a public definition for GetEnumerator." I've tried to create a GetEnumerator but I've been unsuccessful and I haven't worked with GetEnumerator in the past.

Any help is greatly appreciated!

score 18 · Answer 1 · answered Mar 05 '13 at 16:06

A little late but wouldn't this be a better solution?

http://weblogs.asp.net/whaggard/archive/2003/02/20/2708.aspx

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));
}

If you need the names you can do

fi.GetValue(null)

inside the loop.

This is giving weird results for me. I declared a class containing a public const of every built-in type, and this method always ignores decimals, for some reason `public const decimal Decimal = 1.0m;` has IsInitOnly = true — MrLore, Aug 04 '16 at 11:31
It seems I'm not the first to notice this in fact: https://codeblog.jonskeet.uk/2014/08/22/when-is-a-constant-not-a-constant-when-its-a-decimal/ — MrLore, Aug 04 '16 at 12:50

score 10 · Answer 2 · answered Aug 26 '17 at 12:39

I just had the same challenge; to get all constants of my class (not properties!). Based on the most popular answer (for properties) and John's answer (for constants) I wrote this. I tested it and it works well.

private List<string> lstOfConstants= new List<string>();
    foreach (var constant in typeof(TestClass).GetFields())
    {
        if (constant.IsLiteral && !constant.IsInitOnly)
        {
            lstOfConstants.Add((string)constant.GetValue(null));
        }
    }

gjvdkamp · Answer 3 · 2019-04-03T17:37:16.477

9

You could implement a method that yields the strings:

public Ienumerable<string> GetStrings(){
   yield return TestA;
   yield return TestB;
}

Else you should look into reflection to return the properties that are static and string and then get the values by calling them.

Regards GJ

edited Apr 03 '19 at 17:37

answered Feb 14 '11 at 16:22

gjvdkamp

9,929
3
38
46

what is `_TestA`? OP only has `_testA`(lowerCase), which is the constant itself, not its name. – MakePeaceGreatAgain Mar 06 '19 at 11:40

score 6 · Accepted Answer · answered Feb 14 '11 at 16:22

6

You could use reflection to loop through all the properties:

public DropDownItemCollection TestCollection
{
    var collection = new DropDownItemCollection();
    var instance = new TestClass();
    foreach (var prop in typeof(TestClass).GetProperties())
    {
        if (prop.CanRead)
        {
            var value = prop.GetValue(instance, null) as string;
            var item = new DropDownItem();
            item.Description = value;
            item.Value = value;
            collection.Add(item);
        }
    }
    return collection;
}

answered Feb 14 '11 at 16:22

Darin Dimitrov

1,023,142
271
3,287
2,928

5

For me this returned nothing (it seems correct if returning properties but const values aren't properties) so I don't know how it got upvoted so much. @John's answer below works for const string members. – christutty Jan 25 '16 at 00:57
I have the same problem as @christutty, it seems this works on properties with `{ get; set; }`, but doesn't seem to work on properties which already have a predetermined value. – devklick Apr 28 '18 at 10:01

score 4 · Answer 5 · answered Feb 14 '11 at 16:23

4

You can use reflection to loop trought the class properties:

var instance = new TestClass();
foreach(PropertyInfo pi in typeof(TestClass))
{
      var val = pi.GetValue(instance,null);
}

answered Feb 14 '11 at 16:23

Felice Pollano

32,832
9
75
115

score 0 · Answer 6 · answered Feb 14 '11 at 16:27

0

You need to use reflection to get name of each String from your custom type, and then also/optionally get the value of each one of those Strings...

Something like this:

TestClass theClass = new TestClass();

foreach (PropertyInfo property in theClass.GetType().GetProperties())
{

    Console.WriteLine(property.Name);
    Console.WriteLine(property.GetValue(theClass, null));
}

answered Feb 14 '11 at 16:27

fdfrye

1,099
7
14

2

This gets the properties - not the constants (as the question asks for) – dalcam Jun 03 '16 at 00:30

Loop through constant members of a class

6 Answers6

Linked

Related