C # Itera attraverso le proprietà della classe

Attualmente sto impostando tutti i valori del mio oggetto di classe Record.

Questo è il codice che sto usando per popolare il record al momento, proprietà per proprietà.

// Loop through each field in the result set
for (int i = 0; i <= resultItems.Length; i++)
{

    Record newRecord = new Record()
    {
            itemtype =   resultItems[i - (fieldCount - 0)],
            itemdesc =   resultItems[i - (fieldCount - 1)],
            prodcode =   resultItems[i - (fieldCount - 2)],
            proddesc =   resultItems[i - (fieldCount - 3)],
            curstat =    resultItems[i - (fieldCount -4)],
            totfree =    resultItems[i - (fieldCount -5)],
            totphys =    resultItems[i - (fieldCount -6)],
            pcolgroup =  resultItems[i - (fieldCount -7)],
            scolgroup =  resultItems[i - (fieldCount -8)],
            totpo =      resultItems[i - (fieldCount - 9)],
            totso =      resultItems[i - (fieldCount - 10)],
            quality =    resultItems[i - (fieldCount - 11)],
            statusdesc = resultItems[i - (fieldCount - 12)],
            groupcode =  resultItems[i - (fieldCount - 13)],
            qualitydes = resultItems[i - (fieldCount - 14)],
            pcoldesc =   resultItems[i - (fieldCount - 15)],
            scoldesc =   resultItems[i - (fieldCount - 16)],
            pgroupdesc = resultItems[i - (fieldCount - 17)],
    };
}

Posso iterare dinamicamente attraverso ciascuna delle proprietà senza codificare tutti i nomi delle proprietà?

Qualcosa del genere:

// Create new Record instance
Record newRecord = new Record();

for (int e = 0; e < propertyCount.Length - 1; e++)
{
    newRecord[fieldname] = resultItems[i - (fieldCount - e)];
}

Potresti usare Reflection per farlo. Per quanto ne so, potresti enumerare le proprietà della tua classe e impostare i valori. Dovresti provarlo e assicurarti di aver compreso l'ordine delle proprietà. Fare riferimento a questa documentazione MSDN per ulteriori informazioni su questo approccio.

Per un suggerimento, potresti fare qualcosa del tipo:

Record record = new Record();

PropertyInfo[] properties = typeof(Record).GetProperties();
foreach (PropertyInfo property in properties)
{
    property.SetValue(record, value);
}

Dov'è valueil valore in cui vuoi scrivere (quindi dal tuo resultItemsarray).

// the index of each item in fieldNames must correspond to 
// the correct index in resultItems
var fieldnames = new []{"itemtype", "etc etc "};

for (int e = 0; e < fieldNames.Length - 1; e++)
{
    newRecord
       .GetType()
       .GetProperty(fieldNames[e])
       .SetValue(newRecord, resultItems[e]);
}

Sì, potresti creare un indicizzatore sulla tua classe Record che mappa dal nome della proprietà alla proprietà corretta. Ciò manterrebbe tutto il legame dal nome della proprietà alla proprietà in un unico posto, ad esempio:

public class Record
{
    public string ItemType { get; set; }

    public string this[string propertyName]
    {
        set
        {
            switch (propertyName)
            {
                case "itemType":
                    ItemType = value;
                    break;
                    // etc
            }   
        }
    }
}

In alternativa, come altri hanno già detto, usa la riflessione.

Ho provato quello che ha suggerito Samuel Slade . Non ha funzionato per me. La PropertyInfo lista stava diventando vuota. Quindi, ho provato quanto segue e ha funzionato per me.

    Type type = typeof(Record);
    FieldInfo[] properties = type.GetFields();
    foreach (FieldInfo property in properties) {
       Debug.LogError(property.Name);
    }