Wie speichere ich eine Auswahl von Elementvariablen in C#?

Question

Ich bin eine Klasse mit den folgenden Membervariablen

class SomeClass 
{ 
    int idx0_value; 
    int idx1_value; 
    int idx2_value; 

    //... 
} 

mit bin ich nicht in der Lage, die Struktur dieser Klasse zu ändern.

ich eine Instanz dieser Klasse bin mit gegen einen vorher ausgewählten Index zu überprüfen und einen entsprechenden Wert einer Variablen zugewiesen einige if-else-Anweisungen:

if(indexIFoundEarlier == 0) 
    valueIWant = aSomeClass.idx0_value; 
else if(indexIFoundEarlier == 1) 
    valueIWant = aSomeClass.idx1_value; 
else 
    valueIWant = aSomeClass.idx2_value; 

Diese ziemlich ineffizient scheint.

In C++ konnte ich effektiv einen Verweis auf das relevante Mitglied speichern, aber in C# ist das nicht möglich, ich habe die verschiedenen Threads zu diesem Thema gelesen.

Gibt es eine bessere (effizienter zu lesen) Art der Zwischenspeicherung der Wahl, die ich getroffen habe, ohne die Struktur von "SomeClass" zu ändern?

Answer 1

Sie einen Delegaten verwenden könnte ...

class SomeClass { 

    int idx0_value; 
    int idx1_value; 
    int idx2_value; 

    private Func<int> selection; 

    private void SetSelection(int choice) { 
     switch(choice) { 
     case 0: 
     selection =() => idx0_value; 
     break; 
     case 1: 
     selection =() => idx1_value; 
     break; 
     case 2: 
     selection =() => idx2_value; 
     break; 
     } 
    } 

    private int GetSelectionAgain() { 
     return selection?.Invoke() ?? -1; 
    } 
} 

Answer 2

Allerdings scheint dies ziemlich ineffizient. In C++ konnte ich effektiv einen Verweis auf das relevante Mitglied speichern, aber in C# ist das nicht möglich, ich habe die verschiedenen Threads dazu gelesen.

Es ist nicht ineffizient, mit einer Switch-Anweisung wäre Ihre einzige andere vernünftige Wahl für diesen Fall meiner Meinung nach. Der Aufwand für die Verwendung von Reflexion oder jede Art von Delegation wäre viel höher als nur if-else Aussagen oder eine switch Aussage.

//same concept as what you posted but as a switch statement 
switch(indexIFoundEarlier) 
{ 
    case 0: 
    valueIWant = idx0_value; 
    break; 
    case 1: 
    valueIWant = idx1_value; 
    break; 
    default: 
    valueIWant = idx2_value; 
    break; 
} 

Answer 3

Ich würde eine Erweiterung verwenden. Ist es effizient? Das ist subjektiv, bis es mit etwas verglichen wird. Aber es ist lesbar, und das ist wichtig. Wenn Ihre Logik so einfach ist, und jemand kommt vorbei und findet es auf verschlungene Weise, werden sie es zuerst mehrmals lesen, vorausgesetzt, dass sie etwas verpassen müssen. Wenn sie dann merken, dass es etwas Einfaches macht, fragen sie sich vielleicht, warum es nicht einfach gemacht wurde.

Das passiert die ganze Zeit beim Refactoring-Code. Wir stoßen auf etwas Komplexes (vielleicht sogar etwas, das wir geschrieben und vergessen haben) und wenn wir es verstehen, sagen wir uns selbst: "Ist das alles, was es tut?" und dann ersetzen Sie es durch etwas einfacheres.

public static class SomeClassExtensions 
{ 
    public static int GetValueFromIndex(this SomeClass someClass, int index) 
    { 
     if(index == 0) return someClass.idx0_value; 
     if(index == 1) return someClass.idx1_value; 
     return someClass.idx2_value; 
    } 
} 

var value = aSomeClass.GetValueFromIndex(indexIFoundEarlier);