Also es geht hier nicht um einen Hund...

Ich möchte einen Parameterstring ablegen und auf diese Parameter in der Form von Wertepaaren zugreifen (so ähnlich wie der ADO Verbindungsstring). Abgelegt wird der String in einer Stringliste, ich möchte jetzt allerdings gezielt nur die entsprechenden Propertys zur Verfügung stellen.

Dazu habe ich mir ein Objekt gebastelt, das diese Propertys enthält.

zusammenfalten · markieren

Delphi-Quellcode:

  TParameters = class(TObject)
  private
    FParameters: TStrings;
    function GetParamString: String;
    procedure SetParamString(Value: String);
    function GetValue(const Name: string): string;
    procedure SetValue(const Name, Value: string);
    function GetValueFromIndex(const Index: Integer): string;
    procedure SetValueFromIndex(const Index: Integer; Value: string);
    function GetName(const Index: Integer): String;
    function GetCount: Integer;
  public
    constructor Create;
    destructor Destroy;
    property ParamString: String read GetParamString write SetParamString;
    property Value[const Name: String]: String read GetValue write SetValue; default;
    property ValueFromIndex[const Index: Integer]: String read GetValueFromIndex write SetValueFromIndex;
    property Name[const Index: Integer]: String read GetName;
    property Count: Integer read GetCount;
  end;

Dieses Objekt verwende ich nun in einem weiteren Objekt.

zusammenfalten · markieren

Delphi-Quellcode:

  TUser = class(TCustomItem)
  private
    FUserID: String;
    FParameters: TParameters;
    procedure SetUserID(Value: String);
    procedure SetParameters(Value: TParameters);
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy;
    procedure Assign(Source: TPersistent); override;
    property UserID: String read FUserID write SetUserID;
    property Parameters: TParameters read FParameters write SetParameters;
  end;

Funktioniert auch im Prinzip ganz gut. Ich kann wie gewünscht auf Parameters zugreifen. Allerdings soll bei einem Schreibzugriff auf Parameters der von TCustomItem geerbte FState geändert werden, was ich so machen wollte:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TUser.SetParameters(Value: TParameters);
begin
  if FParameters.ParamString <> Value.ParamString then begin
    FParameters.ParamString := Value.ParamString;
    State := osModified;
  end;
end;

Blöderweise wird das allerdings nicht bearbeitet (ich hab einen Haltepunkt auf die if Abfrage), so dass ich nicht "bemerke" wenn ein Parameter geändert wird.

Wie kann ich das hinkriegen?

Hallo,

die Konstruktion selber ist das Problem:

Zitat von guidok:

Dieses Objekt verwende ich nun in einem weiteren Objekt.

markieren

Delphi-Quellcode:

  TUser = class(TCustomItem)
...
    procedure SetParameters(Value: TParameters);
  public
...
    property Parameters: TParameters read FParameters write SetParameters;
  end;

Hierbei wird die Settermethode immer nur dann aufgerufen, wenn du eine Zuweisung MyUser.Parameters := NewParameters; machst. Würde ich so nicht machen. Erzeugt auch ggf. Speicherlöcher

Was du willst, ist auf die Änderungen reagieren in TParameters. Dafür könntest du dir ein Ereignis OnChange deklarieren und dieses in TUser dann mit einer Ereignismethode verknüpfen. Du mußt dann aber auch in den entsprechenden Methoden von TParameter dafür sorgen das die Methode OnChange entsprechend ausgelößt wird.

if Assigned(FOnChange) then FOnChange(<all deine Parameter die Du zur Auswertung benötigst>) Gruß, Chris

Oh. Bedeutet das, dass bei so einer Konstruktion:

markieren

Delphi-Quellcode:

  TTest = class(TObject)
  private
    FParameters: TStrings;
    procedure SetParameters(Value: TStrings);
  public
    constructor Create;
    destructor Destroy;
    property Parameters: TStrings read FParameters write SetParameters;
  end;

die Setter-Methode nicht aufgerufen wird, wenn ich auf eine Eigenschaft, die von TStringList geerbt ist, zugreife sondern nur wenn ich der Property "Parameters" eine komplette StringList zuweise? Ist ja doof!

Zitat von guidok:

Oh. Bedeutet das, dass bei so einer Konstruktion [...] die Setter-Methode nicht aufgerufen wird, wenn ich auf eine Eigenschaft, die von TStringList geerbt ist, zugreife sondern nur wenn ich der Property "Parameters" eine komplette StringList zuweise? Ist ja doof!

Ganz genau. Daher muss man sich oftmals überlegen ob man jetzt vererbt oder ob man die Klasse "benutzt". Bei Vererbung kann man ja ggf. alle Setter oder Getter überschreiben, aber eben leider mit dem Nachteil, dass man vielleicht gar nicht vererben will. Dafür nutzte ich dann meist eben diese Ereignis-Konstrukte

zusammenfalten · markieren

Delphi-Quellcode:

type
TChangedProp = (cpWert1, cpWert2);

TOnChange = procedure(Sender: TObject; ChangedProp: TChangedProp) of object;

TMyClass = class
private
  FWert1: Integer;
  FWert2: string;
  FOnChange: TOnChange;
  procedure SetWert1(Value: Integer);
  procedure SetWert2(Value: string);
public
  property Wert1: Integer read FWert1 write SetWert1;
  property Wert2: string read FWert2 write SetWert2;
  property OnChange: TOnChange read FOnChange write FOnChange;
end;

implementation

procedure TMyClass.SetWert1(Value: Integer);
var
  WertChanged: Integer;
begin
  WertChanged := FWert1 <> Value;
  FWert1 := Value;
  if WertChanged and Assigned(FOnChange) then FOnChange(Self, cpWert1);
end;

procedure TMyClass.SetWert2(Value: string);
var
  WertChanged: Integer;
begin
  WertChanged := FWert2 <> Value;
  FWert2 := Value;
  if WertChanged and Assigned(FOnChange) then FOnChange(Self, cpWert2);
end;

Aber ohne Garantie auf Funktion. Nur reingehackt

Gruß, Chris

[edit] sollte ja auf of object sein [/edit]

Danke für die Information, ich habe verstanden und mache es jetzt so, dass ich beim Instantiieren von TParameters eine Referenz auf das Parent-Item übergebe und somit in den jeweiligen Setter-Routinen auf State zugreifen kann.

zusammenfalten · markieren

Delphi-Quellcode:

constructor TParameters.Create(Item: TCustomItem);
begin
  inherited Create;
  FItem := Item;
  FParameters := TStringList.Create;
end;

procedure TParameters.SetValue(const Name: string; const Value: string);
begin
  if FParameters.Values[Name] <> Value then begin
    FParameters.Values[Name] := Value;
    FItem.State := osModified;
  end;
end;

Sieht ganz gut aus jetzt...