Mehrere Eigenschaften zusammenfassen - aber wie?

[Marco Steinebach]

Hallo zusammen,
Wenn mir ein schönerer Betreff eingefallen wäre, hätte ich vielleicht auch was suchen können...
Also: nehmen wir mal die berühmte Adresse, mit den Eigenschaften Name, Vorname, Strasse, usw. und das ganze als Klasse.
Die sollte man ja, denke ich, ungefähr so definieren:

Delphi-Quellcode:

type
  TAdresse = Class (TObject)
  private
    fName: string;
    fVorname: string;
    fStrasse: string;
    function leseName: string;
    procedure SetzeName (s: string);
    function leseVorname: string;
    procedure SetzeVorname (s: string);
    function leseStrasse: string;
    procedure SetzeStrasse(s: string);
  public
    property name read leseName write setzeName;
    property Vorname read leseVorname write SetzeVorname;
    property strasse read leseStrasse write setzeStrasse;
  end;

implementation

function TAdresse.LeseName: string;
begin
  result := fName;
end;

procedure TAdresse.SetzeName(s: string);
begin
  if s <> name then
  begin
    fName := s;
  end;
end;
//...
end.

Die Klasse, um die es mir geht, speichert alle Einstellungen meines programms. Das sind so rund 50 Stück. Muß ich jetzt echt für jede dieser Einstellungen eine lese, eine schreibe-prozedur, eine interne Variable und die Eigenschaft definieren? Oder geht das auch irgendwie kürzer, denn jede der lese- und schreib-Prozeduren sind alle gleich.
Ich steh da echt auf dem Schlauch!!!
Viele Grüße
Marco

[ele]

Du musst nur eine Prozedur bzw. Funktion angeben, wenn du etwas zusätzlich zum speichern oder laden des Wertes machen möchtest. Wenn du den Wert nur ins Feld schreiben bzw. vom Feld lesen möchtest kannst du nach read bzw. write direkt den Namen des Feldes angeben:

Delphi-Quellcode:

  TAdresse = Class (TObject)
  private
    fName: string;
    fVorname: string;
    fStrasse: string;
  public
    property name: string read fName write fName;
    property Vorname: string read fVorname write fVorname;
    property strasse: string read fStrasse write setzeStrasse;
  end;

[blauweiss]

Hallo Marco,

1. was hindert Dich daran, auf die Properties der Klasse einfach direkt zuzugreifen ?

Delphi-Quellcode:

type
  TAdresse = Class (TObject)
  public
    Nachname: string;
    Vorname: string;
    Strasse: string;
  end;

2. eine Property namens "name" würde ich prinzipiell nicht empfehlen !

Gruß,
blauweiss

[Lemmy]

Hi,

hast Du schon mal folgendes versucht:

Delphi-Quellcode:

 TAdresse=Class(TObject)
  
  public
    property NachName:String;
    property Vorname:String;
    property Strasse:string;
  end;

und dann STRG+C gedrückt?

und zu

Zitat:

1. was hindert Dich daran, auf die Properties der Klasse einfach direkt zuzugreifen ?

warum dann nicht gleich globale Variablen?

Grüße


[edit] Nachtrag

Delphi-Quellcode:

procedure TAdresse.SetzeName(s: string);
begin
  if s <> name then
  begin
    fName := s;
  end;
end;

die Überprüfung "s <> name" ist nur dann sinnvoll, wenn Du anschließend ein Event wie z.B. PropertyChanged aufrufen möchtest. Nur um bei Gleichheit die Zuweisung zu unterbinden ist das echt etwas übertrieben...

[Deep-Sea]

Zitat von Lemmy:

warum dann nicht gleich globale Variablen?

Oder gleich weg von Objekten und Hochsprachen. Back to the roots

@Marco Steinebach:
Du könntest auf einen Wert auch über einen Index oder einen String zugreifen ... hat wie immer Vor- und Nachteile ...

@Lemmy:
Zu deinem Nachtrag: Stimmt, aber falsch ist es auch nicht. So kann man es wenigstens nicht vergessen, falls doch mal ein Event o.ä. hinzukommt ...

[himitsu]

Nein, nicht diese Felder einfach nach Public verschieben ... wenn man diese über Property freigibt, dann kann man später einfacher die Zugriffe bearbeiten.
Also wenn, dann siehe den Code von ele ... wenn du in den Settern/Gettern nichts besonderes machst, dann diese einfach weglassen und das Property direkt umleiten.

Man könnte aber auch einen Index nutzen:

Delphi-Quellcode:

TAdresse = Class
private
  function StringGetter(Index: Integer): String;
  procedure StringSetter(Index: Integer; Value: String);
  ...
public
  property Name:       String  index 0 read StringGetter  write StringSetter;
  property Vorname:    String  index 1 read StringGetter  write StringSetter;
  property Strasse:    String  index 2 read StringGetter  write StringSetter;
  property Hausnummer: Integer index 3 read IntegerGetter write IntegerSetter;
end;

Jetzt kann man das entweder direkt behandeln oder z.B. auf entsprechende Arrays weiterleiten:

Delphi-Quellcode:

TAdresse = Class
private
  fStringValues: array[0..2] of String;
  fIntegerValues: array[0..0] of Integer;
  function StringGetter(Index: Integer): String;
  procedure StringSetter(Index: Integer; Value: String);
  function StringGetter(Index: Integer): String;
  procedure StringSetter(Index: Integer; Value: String);
public
  property Name:       String index 0 read StringGetter write StringSetter;
  property Vorname:    String index 1 read StringGetter write StringSetter;
  property Strasse:    String index 2 read StringGetter write StringSetter;
  property Hausnummer: String index 0 read IntegerGetter write IntegerSetter;
end;

[Marco Steinebach]

Hallo zusammen,
ganz herzlichen Dank für die vielen, und, vor allem, sehr hilfreichen Antworten.
Da ich vor habe, die Einstellungen nur zu speichern, wenn sich an mindestens einer Einstellung etwas geänderthat, wird es wohl bei den, etwas umfangreicheren Settern und Gettern bleiben. Mal sehen, ob mir die Indizierung was nützt, und ob's weniger Zeilen gibt.
Ganz herzlichen Dank nochmal und viele Grüße
Marco

[himitsu]

Zumindestens könntest'e die Getter weglassen (wenn du es ohne Index machst)

[Stevie]

Zitat von Marco Steinebach:

Hallo zusammen,
ganz herzlichen Dank für die vielen, und, vor allem, sehr hilfreichen Antworten.
Da ich vor habe, die Einstellungen nur zu speichern, wenn sich an mindestens einer Einstellung etwas geänderthat, wird es wohl bei den, etwas umfangreicheren Settern und Gettern bleiben. Mal sehen, ob mir die Indizierung was nützt, und ob's weniger Zeilen gibt.
Ganz herzlichen Dank nochmal und viele Grüße
Marco

Erzeuge dir doch 2 Instanzen (eine für die geladenen Einstellungen und eine die bearbeitet wird). Dann kannst du einfach überprüfen ob die Werte gleich sind und bei Ungleichheit speichern.

[Sir Rufo]

Es gibt da allerdings auch noch etwas ganz perverses

Einen eigenen VariantDatatype (hier als Beispiel für ein TDataSet)

Wird dann so benutzt:

Delphi-Quellcode:

// tblAdtressen ist irgendein geöffnetes DataSet (Tabelle, Query, whatever)
// Enthalten sind dort die Felder Vorname, Nachname, Ort
var
  VarData : Variant;
begin
  VarData := VarDataSetCreate( tblAdressen );
  
  ShowMessage( VarData.Vorname + ' ' + VarData.Nachname + #13#10 + VarData.Ort );
  // Da es bei NULL-Werten knallt auch eher so
  ShowMessage( VarToStr( VarData.Vorname ) + ' ' + VarToStr( VarData.Nachname ) + #13#10 + VarToStr( VarData.Ort ) );

  // Schreiben geht so
  tblAdressen.Edit;
  VarData.Vorname := 'Peter';
  tblAdressen.Post;
end;

Das könnte man auch genauso auf TCustomIniFile ummünzen und schon braucht man nichts mehr vorher deklarieren, sondern einfach nur benutzen.

Aber auch hier liegen natürlich Fluch und Segen dicht beieinander

Delphi-Quellcode:

unit DatasetData;

interface

uses
  DB, Variants, TypInfo;

function VarDatasetCreate( ds : TDataset ) : Variant;

implementation

uses
  SysUtils;

type
  TDatasetData = packed record
    VType : TVarType;
    Reserved1, Reserved2, Reserved3 : Word;
    VDataset : TDataset;
    Reserved4 : LongWord;
  end;

type
  TDatasetVariant = class( TPublishableVariantType )
  protected
    function GetInstance( const V : TVarData ) : TObject; override;
  public
    procedure Clear( var V : TVarData ); override;
    procedure Copy( var Dest : TVarData; const Source : TVarData;
      const Indirect : Boolean ); override;
    function GetProperty( var Dest : TVarData; const V : TVarData;
      const Name : string ) : Boolean; override;
    function SetProperty( const V : TVarData; const Name : string;
      const Value : TVarData ) : Boolean; override;
  end;

var
  DatasetVariant : TDatasetVariant;

procedure TDatasetVariant.Clear( var V : TVarData );
  begin
    SimplisticClear( V );
  end;

// procedure TDatasetVariant.Clear( var V : TVarData );
// begin
// TDatasetData( V ).VType := varEmpty;
// TDatasetData( V ).VDataset := 0;
// end;

procedure TDatasetVariant.Copy( var Dest : TVarData; const Source : TVarData;
  const Indirect : Boolean );
  begin
    SimplisticCopy( Dest, Source, Indirect );
  end;

function TDatasetVariant.GetProperty( var Dest : TVarData; const V : TVarData;
  const Name : string ) : Boolean;
  var
    ds : TDataset;
    fld : TField;
  begin
    ds := TDatasetData( V ).VDataset;
    fld := ds.FindField( Name );
    if ( Assigned( fld ) ) then
      begin
        // If the property name is a field name from the dataset, return a
        // reference to the field.
        Result := True;
        Variant( Dest ) := fld.Value;
      end
    else
      // If the name of the property is not a field name, return the value
      // of one of the published properties.
      Result := inherited GetProperty( Dest, V, Name );
  end;

function TDatasetVariant.SetProperty( const V : TVarData; const Name : string;
  const Value : TVarData ) : Boolean;
  var
    ds : TDataset;
    fld : TField;
  begin
    ds := TDatasetData( V ).VDataset;
    fld := ds.FindField( Name );
    if ( Assigned( fld ) ) then
      begin
        fld.Value := Variant( Value );
        Result := True;
      end
    else
      // If the name of the property is not a field name, set the value
      // of one of the published properties.
      Result := inherited SetProperty( V, Name, Value );
  end;

function TDatasetVariant.GetInstance( const V : TVarData ) : TObject;
  begin
    Result := TDatasetData( V ).VDataset;
  end;

function VarDatasetCreate( ds : TDataset ) : Variant;
  begin
    VarClear( Result );
    TDatasetData( Result ).VType := DatasetVariant.VarType;
    TDatasetData( Result ).VDataset := ds;
  end;

initialization

DatasetVariant := TDatasetVariant.Create;

finalization

FreeAndNil( DatasetVariant );

end.

EDIT upps, ich gläube unter Delphi 5 wird das nix