C#: viele Variablen in einer Klasse

[Gast (Gast)]

Ich habe eine Klasse geschrieben in der eine Datei ausgelesen wird und 
die gelesenen Werte in über 20 public string Variablen geschrieben 
werden. Jede Variable hat ihren eingenen Namen, ein Array ist nicht 
vorhanden. Diese Variablen stelle ich nun in einer Form in Textboxen 
dar.

Wie kann man sowas besser lösen? Weil alles public zu machen, entspricht 
ja nicht gerade der OOP.

Ich habe mir folgendes ausgedacht:

public string funktion(int nr)
{
   switch(nr)
   {
      case 0:
         return Variable_A;
         break;

      case 1:
         return Variable_B;
         break;

         // usw.
   }
}

[Mark B. (markbrandis)]

Du hast also Member-Variablen in einer Klasse, die als private 
deklariert sind. Dann hast Du Methoden der Klasse, die von außerhalb ein 
Lesen der Variablen erlauben (auch "getter" genannt).

Willkommen in der OOP :-)

[Karl H. (kbuchegg)]

Gast schrieb:

> Wie kann man sowas besser lösen? Weil alles public zu machen, entspricht
> ja nicht gerade der OOP.
>
> Ich habe mir folgendes ausgedacht:
>
> public string funktion(int nr)
> {
>    switch(nr)
>    {
>       case 0:
>          return Variable_A;
>          break;
>
>       case 1:
>          return Variable_B;
>          break;
>
>          // usw.
>    }
> }

Kann man natürlich machen.

Die Frage lautet allerdings:
  Was ist mit diesen 20 Strings? Was ist daran so speziell, dass du sie
  nicht in ein Array stellst und die einzelnen Variablen rauswirfst.

  Ist ein Array überhaupt zweckdienlich, oder kann man die 20 Strings
  wieder in anderer Form sonnvoll zusammenfassen. Zb Vorname + Nachname
  in eine Klasse Name packen. Oder Postleitzahl, Wohnort, Strasse,
  Hausnummer zu einer Klasse Adresse zusammenfassen.

  Wenn es allerdings überhaupt keinen Zusammenhang der 20 Strings gibt,
  warum muss dann alles über eine einzige Zugriffsfunktion abgehandelt
  werden. Da muss ich mir dann ja erst recht wieder merken, welcher
  String der String mit der Nummer 9 ist.

[Läubi .. (laeubi)]

Karl heinz Buchegger schrieb:
>   werden. Da muss ich mir dann ja erst recht wieder merken, welcher
>   String der String mit der Nummer 9 ist.

public string funktion(char var)
{
   switch(var)
   {
      case 'A':
         return Variable_A;
         break;

      case 'B':
         return Variable_B;
         break;

         // usw.
      case 'T':
         return Variable_T;
         break;

         // usw.
   }
}

Dan mußt du dir keine Nummern merken ;)
> Weil alles public zu machen, entspricht
> ja nicht gerade der OOP.
Aha... warum den nicht? Wenn du willst das jeder zu jederzeit 
uneingeschränkt die Variablen nutzen und verändern könne darf wieso 
nicht.
OO heißt doch nicht das es getter/setter gibt...

[Mark B. (markbrandis)]

An und Pfirsich sollte man so viel wie nötig public deklarieren, aber so 
wenig wie möglich. Wenn ich immer alles public mache, kann ich ja gleich 
eine struct nehmen anstatt einer Klasse ;-)

[Maik F. (sabuty)]

Wenn du alles anzeigen willst -> Reflection ist das Stichwort

[Gast (Gast)]

Hier noch Beispielcode für eine dynamische Variante. Die Werte und 
Bezeichner der Variablen werden in einem Dictionary abgelegt. Der 
Zugriff erfolgt über eine indexed property.

        private readonly Dictionary<string, string> VarDict = new Dictionary<string, string>();

        private void LeseDatei()
        {
            ...

            InitVar("NameVariableA", Variable_A);
            InitVar("NameVariableB", Variable_B);
            InitVar("NameVariableC", Variable_C);

            ...

        }

        private void InitVar(string varName, string varValue)
        {
           VarDict.Add(varName, varValue);
        }

        public string this[string varName]
        {
            get
            {
                string varVal;
                if( VarDict.TryGetValue(varName, out varVal) )
                {
                    return varVal;
                }

                return string.Empty;
            }
        }

[Markus (Gast)]

In C# sind für den Zugriff auf die internen Felder Properties 
vorgesehen:

public class Abc {
    ...
    private string _myData;
    public string MyData
    {
        set { _myData = value; }
        get { return _myData; }
    }
    ...
}

public class Xyz {
    ...
    void DoSomething()
    {
        MyData dObj = new MyData();
        string data = dObj.MyData;
        ...
        dObj.MyData = "foo";
    }
    ...
}

Der oben erwähnte Ansatz mit einer Zugriffs-Methode mit 
"Property-Identifikation" (funktion(int nr)) würde man unter C# (.NET) 
üblicherweise nicht über switch-case, sondern mit Hilfe eines 
generischen Dictionary<keyTyp,valueTyp> erledigen. Das Verfahren hat 
allerdings einen einen gewaltigen Nachteil (unabhängig von der 
Implementierung über switch-case oder Dictionary): Der Compiler kann 
nicht bestimmen, ob ein Property existiert oder nicht. Diese Fehler 
treten erst zur Laufzeit (also beim Kunden) auf.

Aus diesem Grund implementiert man eben 20 String-Properties, wenn diese 
tatsächlich voneinander unabhängig sind. Irgendwelche Zuriffe auf nicht 
existierende Properties findet dann bereits der Compiler. Oder man 
überlegt sich ein besser passenderes Modell.

Markus