Schleife durch konstante Mitglieder einer Klasse

Question

Ich habe eine Klasse mit konstanten Strings darin. Ich möchte alle diese Zeichenketten in eine Dropdown-Sammlung werfen. Wie kann ich das am besten machen? Dies ist, was ich jetzt habe und in der Theorie, würde ich denken, dass es der beste Weg, dies zu tun wäre.

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

Das Problem ist, dass bei foreach ein Fehler auftritt: "...enthält keine öffentliche Definition für GetEnumerator." Ich habe versucht, einen GetEnumerator zu erstellen, aber ich war nicht erfolgreich und habe in der Vergangenheit nicht mit GetEnumerator gearbeitet.

Jede Hilfe ist sehr willkommen!

Answer 1

Etwas spät, aber wäre das nicht die bessere Lösung?

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

Wenn Sie die Namen benötigen, können Sie Folgendes tun

fi.GetValue(null)

innerhalb der Schleife.

Answer 2

Ich hatte gerade die gleiche Herausforderung; alle Konstanten meiner Klasse zu erhalten (nicht Eigenschaften!). Auf der Grundlage der beliebtesten Antwort (für Eigenschaften) und Johns Antwort (für Konstanten) habe ich das hier geschrieben. Ich habe es getestet und es funktioniert gut.

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

Answer 3

Sie könnten eine Methode implementieren, die die Zeichenketten ausgibt:

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

Andernfalls sollten Sie in Reflexion, um die Eigenschaften, die statische und String und dann erhalten die Werte durch den Aufruf von ihnen sind zurückzukehren.

Mit freundlichen Grüßen GJ

Answer 4

Sie können die Reflexion verwenden, um eine Schleife durch alle Eigenschaften zu ziehen:

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

Answer 5

Sie können Reflexion verwenden, um die Klasseneigenschaften in einer Schleife zu überprüfen:

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