Property via AsString;AsInteger;AsBoolean;.. laden

[-=ZGD=-]

Danke für dein Hilfe bepe.

Auf Grundlage deiner Informationen bin ich jetzt soweit vorangeschritten:

Delphi-Quellcode:

type
  RConfig2 = record
  private
    fKey: String;
    fValue: Variant;
    function GetAsString: String;
    function GetAsInteger: Integer;
  public
    property Key: String read fKey write fKey;
    property Value: Variant write fValue;
    property AsString: String read GetAsString;
    property AsInteger: Integer read GetAsInteger;
  end;

Die Implementierung der GET/SET

Delphi-Quellcode:

function RConfig2.GetAsString;
begin
  result := STRING(fValue);
end;

function RConfig2.GetAsInteger;
var
  val: Integer;
begin
  if TryStrToInt(fValue, val) then
  begin
    result := val
  end
  else
    raise Exception.Create('Konvertierungsfehler - Kein INTEGER');
end;

Daraus ergab sich eine neue Liste

Delphi-Quellcode:

type
  TConfigList2 = array of RConfig2;

Was im Objekt an sich zu folgenden Änderungen führt:

Delphi-Quellcode:

type
  TConfig = class(TObject)
  private
    ...
    fList: TConfigList;
    fList2: TConfigList2;

    ...
    function GetVariantValue(aID: String): RConfig2;
    procedure SetVariantValue(aID: string; aValue: Variant);

    ...
  public
    constructor create;

    ...
    property Item[aKey: String]: RConfig2 read GetVariantValue write SetVariantValue;
    ...
  end;

GetVariantValue sieht nun bei mir so aus (ja, noch keine Hashtable)

Delphi-Quellcode:

function TConfig.GetVariantValue(aID: string): RConfig2;
var
  i: Integer;
begin
  ReadConfig;
  for i := low(fList2) to high(fList2) do
  begin
    if uppercase(fList2[i].Key) = uppercase(aID) then
    begin
      Result := fList2[i];
      break;
    end;
  end;
end;

Ich dachte mir, ich nehme Variant als Typ für die Value, denn somit bin ich da flexibel...eher ungut?

Woran ich jetzt allerdings scheitere ist die Implementierung von SetVariantValue .

Der Compiler sagt

Code:

Inkompatible Typen

.

Delphi-Quellcode:

procedure Tconfig.SetVariantValue(aID: string; aValue: Variant);
begin

end;

Den Versuch, einfach ein

Code:

RConfig2

zu übergeben ist ebenfalls gescheitert.
Wo seh ich den Wald vor lauter Bäumen nicht? Ist die Implementierung in den Grundzügen so korrekt?

[bepe]

Zitat von -=ZGD=-:

Delphi-Quellcode:

type
  RConfig2 = record
  private
    fKey: String;
    fValue: Variant;
    function GetAsString: String;
    function GetAsInteger: Integer;
  public
    property Key: String read fKey write fKey;
    property Value: Variant write fValue;
    property AsString: String read GetAsString;
    property AsInteger: Integer read GetAsInteger;
  end;

Ich würde im Record die Setter Methoden einfügen, nicht in der Config Klasse. Dann kannst du einfach ...AsInteger := 4711 tippen, anstatt ein Record übergeben zu müssen.

Zitat von -=ZGD=-:

Delphi-Quellcode:

type
  TConfig = class(TObject)
  private
    ...
    fList: TConfigList;
    fList2: TConfigList2;

    ...
    function GetVariantValue(aID: String): RConfig2;
    procedure SetVariantValue(aID: string; aValue: Variant);

    ...
  public
    constructor create;

    ...
    property Item[aKey: String]: RConfig2 read GetVariantValue write SetVariantValue;
    ...
  end;

Hier ist der Getter ausreichend. Aber wenn schon ein Setter da ist, dann definitiv mit RConfig2 arbeiten nicht mit Variant. Auch wenn ich nichts gegen Variant habe (doch eigentlich schon ), es macht hier einfach keinen Sinn.

[-=ZGD=-]

Zitat von bepe:

Zitat von -=ZGD=-:

Delphi-Quellcode:

type
  RConfig2 = record
  private
    fKey: String;
    fValue: Variant;
    function GetAsString: String;
    function GetAsInteger: Integer;
  public
    property Key: String read fKey write fKey;
    property Value: Variant write fValue;
    property AsString: String read GetAsString;
    property AsInteger: Integer read GetAsInteger;
  end;

Ich würde im Record die Setter Methoden einfügen, nicht in der Config Klasse. Dann kannst du einfach ...AsInteger := 4711 tippen, anstatt ein Record übergeben zu müssen.

Zitat von -=ZGD=-:

Delphi-Quellcode:

type
  TConfig = class(TObject)
  private
    ...
    fList: TConfigList;
    fList2: TConfigList2;

    ...
    function GetVariantValue(aID: String): RConfig2;
    procedure SetVariantValue(aID: string; aValue: Variant);

    ...
  public
    constructor create;

    ...
    property Item[aKey: String]: RConfig2 read GetVariantValue write SetVariantValue;
    ...
  end;

Hier ist der Getter ausreichend. Aber wenn schon ein Setter da ist, dann definitiv mit RConfig2 arbeiten nicht mit Variant. Auch wenn ich nichts gegen Variant habe (doch eigentlich schon ), es macht hier einfach keinen Sinn.

Ich würde mich jetzt für die Variante mit Setter im Record entscheiden.
Die ist drin und sollte auch funktionieren...sollte.

Ich debugge.

Was passiert bei der jetzigen Konstellation:

Delphi-Quellcode:

type
  RConfig2 = record
  private
    fKey: String;
    fValue: Variant;
    function GetAsString: String;
    function GetAsInteger: Integer;
    procedure SetAValue(aValue: Variant);
  public
    property Key: String read fKey write fKey;
    property Value: Variant read fValue write fValue;
    property AsString: String read GetAsString;
    property AsInteger: Integer read GetAsInteger;
  end;

und property Item[aKey: String]: RConfig2 read GetVariantValue; Ich strebe an, über

Code:

.Value:= ?

die Wertzuweisung zu machen.

Jedoch läuft er beim Aufruf von myConfig.Item['dbconfig'].Value:= 2312 immer in GetVariantValue was mir auch logisch erscheint.
Nur wie bringe ich diesen Zugriff so hin, dass es nach meinem Wunsch funktioniert?

[s.h.a.r.k]

Du willst doch, dass es einfach funktioniert. Warum nimmst du dann nicht einfach das was ich geschrieben habe? Das was ich geschrieben habe, funktioniert nicht mal, da dann die Variable Key nicht mit übernommen wird. Shit...

[-=ZGD=-]

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

Du willst doch, dass es einfach funktioniert. Warum nimmst du dann nicht einfach das was ich geschrieben habe?

Dann muss ich wieder so viel umbauen...

Und ich muss so ehrlich sein und sagen, dass mir die Einarbeitungszeit in Implicit für diese Miniklasse als zu hoch erscheint.

Es sieht so aus, als ist meine Vorstellung in dieser Art auf meiner Codebasis doch nicht so ohne Weiteres umzusetzen...

Ich bekomme einfach diese

Code:

Inkompatible Typen

Warnung nicht weg.

Vor allem frage ich mich, wie es funktionieren soll, wenn der Setter rein im Record deklariert ist..

[s.h.a.r.k]

Zitat von -=ZGD=-:

Dann muss ich wieder so viel umbauen...

Viel wäre es ja nicht gewesen, sondern nur ein paar Zeilen. Nur leider hatte die Idee das gleiche Problem, wie du es im Moment hast.

Quick and Dirty könntest es so umbauen, dass du den folgenden Aufruf hast:
myConfig.Item['dbconfig'] := myConfig.Item['dbconfig'].SetValue(2312); Schön ist aber was anders...

Würde dann eher vorschlagen, dass du der TConfig eine SetItemValue(Name: string; Value: Variant) Methode spendierst.

Oder eine ganz andere Alternative wäre es einen Zeiger auf den Record zurückzugeben, also bei GetVariantValue eien PRConfig2. Aber ob das so toll wäre...

[-=ZGD=-]

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

Zitat von -=ZGD=-:

Dann muss ich wieder so viel umbauen...

Viel wäre es ja nicht gewesen, sondern nur ein paar Zeilen. Nur leider hatte die Idee das gleiche Problem, wie du es im Moment hast.

Quick and Dirty könntest es so umbauen, dass du den folgenden Aufruf hast:
myConfig.Item['dbconfig'] := myConfig.Item['dbconfig'].SetValue(2312); Schön ist aber was anders...

Würde dann eher vorschlagen, dass du der TConfig eine SetItemValue(Name: string; Value: Variant) Methode spendierst.

Oder eine ganz andere Alternative wäre es einen Zeiger auf den Record zurückzugeben, also bei GetVariantValue eien PRConfig2. Aber ob das so toll wäre...

Die Methode hatte ich drin, bzw. habe ich noch da nur leider lässt der Compiler es nicht durch.

Delphi-Quellcode:

procedure SetVariantValue(aID: String; aValue: Variant);
    ...
    procedure SetAValue(aValue: Variant);
  public
    ...
    property Item[aKey: String]: RConfig2 read GetVariantValue write SetVariantValue;

Der Record

Delphi-Quellcode:

type
  RConfig2 = record
  private
    fKey: String;
    fValue: Variant;
    function GetAsString: String;
    function GetAsInteger: Integer;
    procedure SetAValue(aValue: Variant);
  public
    property Key: String read fKey write fKey;
    property Value: Variant read fValue write SetAValue;
    property AsString: String read GetAsString;
    property AsInteger: Integer read GetAsInteger;
  end;

Wo ist der Fehler? Ich bin nur noch am systematischen Probieren, aber ich komme auf keine Lösung - das nervt mich..

Hier scheint meiner Meinung nach das Problem zu sein, das Item vom Typ RConfig2 ist?!