Property via AsString;AsInteger;AsBoolean;.. laden

[-=ZGD=-]

Zitat von Iwo Asnet:

Wir arbeiten hier seit Jahren mit dem Vorschlag von Thom (Variants).

Unsere Lösung ist so banal, das wir auf Typensicherheit, OOP, CleanCode usw. an der Stelle verzichten. Die Unit ist 186 Zeilen lang und implementiert einen bösen Singleton namens 'Setup'. Fertig.

Wir verwenden die Eigenschaften 'AsInteger', 'AsString', 'AsBoolean', um komfortabler auf Daten zugreifen zu können (nötig ist das nicht):

Delphi-Quellcode:

ValueAsVariant := Setup['MySetting'];
ValueAsInteger := Setup.AsInteger['MyIntegerSetting'];
ValueAsBoolean := Setup.AsBoolean['MyBooleanSetting'];
...

Wir hatten bisher nie die Muße, über den Sinn zu diskutieren. Die Unit wurde in 30 min zusammengebaut und funktioniert.

Nein, und unsere Anwendungen haben keine 1000 Einstellungen. Höchstens 20.

Wer mit Metadaten arbeitet (und hier haben wir welche), sollte sich mit den Variants vertraut machen.

Meine Worte
Bei mir werden es auch nicht mehr als 50 Werte werden.

Ich finde diese Lösung eben einfach und alltagstauglich. Man muss nicht alles auf die Spitze treiben.

@Shark: Ich habe doch einen Setter im Record..wo finde ich meinen Fehler?

[s.h.a.r.k]

Zitat von -=ZGD=-:

@Shark: Ich habe doch einen Setter im Record..wo finde ich meinen Fehler?

Jo, habe übersehen, dass es sich um eine reine write-Property bei Value handelt. Sowas gibts bei mir nie, daher ging von einem read aus

Zitat von -=ZGD=-:

So, die Doku muss der Entwickler sowieso bei sich haben, damit er weiß, welche Konfigurationfelder er eigentlich hat, da ist´s egal, dass er noch schaut und liest: Typ.INTEGER.

Guter Code benötigt (fast) keine Doku. Ich persönlich finde es praktischer, wenn mir IntelliSense sagt, welche Optionen ich denn zur Auswahl habe, anstatt in der Doku nachschauen zu müssen. Dann kann ich alles an Ort und Stelle auswählen nud sehe auch beim Compilieren, ob es knallt, wenn Änderungen an der Configuration-Klasse vorgenommen werden.

Folgendes Beispiel:

Delphi-Quellcode:

Port := Config.GetValue('port').AsInteger;
Port := Config.GetValue('Port').AsInteger;
// Was von den beiden ist richtig? Klar, man könnte in der GetValue()
// Methode noch auf Lower- oder UpperCase umwandeln, aber es kann
// hier leicht knallen.

// Wenn ich aber nun folgendes habe, erscheint in meinem Code eine
// Auflistung aller optionen, die die Klasse Config anbietet. Grob
// mal mit IntelliSense skizziert :)
Port := Config.+----------------+
               | MySQL          |
               | Printer        |
               | UserSpecific   |
               +----------------+

// Klar, muss die Configuration-Klasse entsprechend angepasst werden,
// sodass die Auswahl kommt. Aber so kann der Programmierer sich sehr
// leicht "durchhangeln", bis er das hat, was er sucht:
Port := Config.MySQL.Port;

Davon losgelöst kann man eben auch bzgl. den Variants argumentieren, was ich schon habe. Wer aber die Variants-Lösung bevorzugt, dem sei gesagt, dass ich nichts dagegen habe. Ich beschreibe hier nur den Weg, den ich bevorzugen würde -- aus besagten Gründen

Zitat:

Das alles sein Für und Wider hat, dagegen ist nichts einzuwenden. Letztlich entscheidet das Gutdünken des Entwicklers darüber, wie er es lösen möchte.

Was anderes habe ich nie behauptet Viele Wege führen ans Ziel...

[Iwo Asnet]

Zitat von s.h.a.r.k:

Guter Code benötigt (fast) keine Doku.

Korrekt, aber das ist mit dem hier vorliegenden Problem (Zugriff über Metainformation, hier: Eigenschaftsnamen) nicht zu lösen.

Wir können das ganz einfach durch einen applikationsspezifischen Wrapper hinbekommen:

Delphi-Quellcode:

Type
  TSpecificConfig = Class 
  Public
    Property MyInteger : Integer Read GetMyInteger   Write SetMyInteger;
  End;

...
Function TSpecificConfig.GetMyInteger : Integer;
Begin
  Result := VarToInt (Item['MyInteger']);
End;

Dies lässt sich noch vereinfachen, indem die Konfigurationsnamen in einem konstanten Array vorgehalten werden und es pro Datentyp einen IndexGetter und -setter gibt, also z.B. so:

Delphi-Quellcode:

Type
  TSpecificConfig = Class 
    Const Values : Array [0..xx] of String = ('MyInt', 'MyString'...);
  Public
    Property MyInt : Integer index 0 Read GetInteger Write SetInteger;
    Property MyString : String index 1 Read GetString Write SetString;
  End;

...
Function TSpecificConfig.GeInteger (Index : Integer) : Integer;
Begin
  Result := VarToInt (Item[Values[Index]]);
End;

Der Zugriff erfolgt dann über eine Instanz der 'TSpecific'-Klasse.

Wie gesagt: Wer's toll findet, kann sich die Mühe machen.

Mir reicht:
Setup['MyInt'] := 4711;