Property via AsString;AsInteger;AsBoolean;.. laden

[-=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?!

[s.h.a.r.k]

Folgender Vorschlag. Wirf diese Record-Geschichte über den Haufen und mach daraus eine Klasse. Dann klappt auch das mit dem Getter und du brauchst keinen Setter, da du ja nur Referenzen erhälst, wenn du via Item[Key] auf ein Config-Eintrag zugreifst. Für das Hinzufügen bzw. Löschen würde ich entsprechende Methoden in der TConfig-Klasse implementieren. Hier mal das, wie ich es mir gerade vorstelle:

Delphi-Quellcode:

type
  TConfigItem = class;
 
  TConfig = class(TObject)
  private
    FItems : TDictionary<string, TConfigItem>;
    function GetConfigItem(aID: String): TConfigValue;
  public
    constructor Create;
    procedure AddItem(AItem: TConfigItem);
    procedure RemoveItem(AItem: TConfigItem); overloads;
    procedure RemoveItem(const Key: string); overloads;
    function ItemExists(const Key: string): Boolean;
    property Item[aKey: String]: TConfigItem read GetConfigItem; 
  end; 


  TConfigItem = class
  private
    fKey: String;
    fValue: Variant;
    function GetAsString: String;
    function GetAsInteger: Integer;
  public
    constructor Create(const AKey: string; Vaule: Variant);
    property Key: String read fKey;
    property Value: Variant write fValue;
    property AsString: String read GetAsString;
    property AsInteger: Integer read GetAsInteger;
  end;

PS: Natürlich musst du im Destruktor von TConfig die Items wieder freigeben. Oder du nimmst ein TObjectDictionary. Dann kümmert sich das Wörterbuch entsprechend darum, wenn beim OnCreate angibst, dass deine Werte Objekte sind.

Ich weiß nicht, ob du dich mit Interfaces auskennst, aber wenn du darauf setzen würdest, bräuchtest diese Freigabe-Geschichte nicht weiter zu beachten,.

[-=ZGD=-]

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

Folgender Vorschlag. Wirf diese Record-Geschichte über den Haufen und mach daraus eine Klasse. Dann klappt auch das mit dem Getter und du brauchst keinen Setter, da du ja nur Referenzen erhälst, wenn du via Item[Key] auf ein Config-Eintrag zugreifst. Für das Hinzufügen bzw. Löschen würde ich entsprechende Methoden in der TConfig-Klasse implementieren. Hier mal das, wie ich es mir gerade vorstelle:

Delphi-Quellcode:

type
  TConfigItem = class;
 
  TConfig = class(TObject)
  private
    FItems : TDictionary<string, TConfigItem>;
    function GetConfigItem(aID: String): TConfigValue;
  public
    constructor Create;
    procedure AddItem(AItem: TConfigItem);
    procedure RemoveItem(AItem: TConfigItem); overloads;
    procedure RemoveItem(const Key: string); overloads;
    function ItemExists(const Key: string): Boolean;
    property Item[aKey: String]: TConfigItem read GetConfigItem; 
  end; 


  TConfigItem = class
  private
    fKey: String;
    fValue: Variant;
    function GetAsString: String;
    function GetAsInteger: Integer;
  public
    constructor Create(const AKey: string; Vaule: Variant);
    property Key: String read fKey;
    property Value: Variant write fValue;
    property AsString: String read GetAsString;
    property AsInteger: Integer read GetAsInteger;
  end;

PS: Natürlich musst du im Destruktor von TConfig die Items wieder freigeben. Oder du nimmst ein TObjectDictionary. Dann kümmert sich das Wörterbuch entsprechend darum, wenn beim OnCreate angibst, dass deine Werte Objekte sind.

Ich weiß nicht, ob du dich mit Interfaces auskennst, aber wenn du darauf setzen würdest, bräuchtest diese Freigabe-Geschichte nicht weiter zu beachten,.

´

Ich werde mal versuchen, das bei Gelegenheit umzusetzen.
Ich hätte nur gedacht, dass diese "Idee" recht trivial ist.

Interfaces, Generics, Dictionaries sind Neuheiten für mich, für die ich (leider!) noch keine Zeit hatte...

Danke, dass ihr euch die Zeit nehmt/genommen habt.

[bepe]

1. Habe ich ein wenig den Überblick darüber verloren, wo du gerade was ausprobiert hast und wo der Fehler steckt.
2. Aus Zeitmangel, Überhitzung oder einfach weil ich mittlerweile doch Ü30 bin, habe ich dich mit dem Record auf eine falsche Spur geschickt. Hab es gerade erfolglos ausprobiert und habe selber gerade keine Ahnung was ich falsch mache.
3. Mach aus dem Record eine Klasse und alles funktioniert, wenn dein bisheriger Versuch ungefähr wie meiner aussieht:

Delphi-Quellcode:

  TConfigItem = class
  strict private
    FWert: String;

    function GetAsInteger: Integer;
    function GetAsVariant: Variant;

    procedure SetAsInteger(Value: Integer);
    procedure SetAsVariant(Value: Variant);

  public
    property AsInteger: Integer read GetAsInteger write SetAsInteger;
    property Value: Variant read GetAsVariant write SetAsVariant;

  end;

  TConfigItemDic = class(TDictionary<String, TConfigItem>);

  TConfigKlasse = class
  strict private
    FItems: TConfigItemDic;

  strict protected
    function GetConfigItem(Index: String): TConfigItem;

  public
    constructor Create;
    destructor Destroy; override;

    property Item[Index: String]: TConfigItem read GetConfigItem;

  end;


{ TConfigItem }

function TConfigItem.GetAsInteger: Integer;
begin
  Result := StrToInt(FWert);
end;

function TConfigItem.GetAsVariant: Variant;
begin
  Result := FWert;
end;

procedure TConfigItem.SetAsInteger(Value: Integer);
begin
  FWert := IntToStr(Value);
end;

procedure TConfigItem.SetAsVariant(Value: Variant);
begin
  FWert := Value;
end;

{ TConfigKlasse }

constructor TConfigKlasse.Create;
var
  tmpTest: TConfigItem;
begin
  FItems := TConfigItemDic.Create;

// Nur zum testen...
  tmpTest := TConfigItem.Create;
  tmpTest.AsInteger := 4711;
  FItems.Add('Test', tmpTest);
end;

destructor TConfigKlasse.Destroy;
begin
  FItems.Free;
  inherited;
end;

function TConfigKlasse.GetConfigItem(Index: String): TConfigItem;
begin
  Result := FItems[Index];
end;


//Der Test
procedure TForm1.FormCreate(Sender: TObject);
var
  tmpConfig: TConfigKlasse;
begin
  tmpConfig := TConfigKlasse.Create;
  try
    tmpConfig.Item['Test'].AsInteger := 42;
    Caption := tmpConfig.Item['Test'].Value;
  finally
    tmpConfig.Free;
  end;
end;

[-=ZGD=-]

Hi bepe,

absolut kein Problem.
Ich bin und war für jede Hilfe dankbar.

Ich find´s sehr toll, dass du eine Beispielklasse implementiert hast.
Die hab ich mir gleich ausgedruckt und werde mich am Wochenende damit beschäftigen - dann kann ich Dictionarys abhaken

Ich danke euch.