Mit Funktion Wert zurückgeben und zuweisen?

[Legolas]

Hallo alle zusammen,

ich habe das Problem das ich mit einer Procedure/Function beides machen möchte, also einen Wert zurückgeben und auch zuweisen.

Etwa so:

Code:

Label1.Caption:=Irgenwas('Test').Methode;
Irgenswas('Test').Mothode:=Label1.Caption;

Ich habe es schon so probiert:

Code:

....
public
  function Irgendwas(test: String): String; overload;
  procedure Irgendwas(test: String); overload;
...

Wenn ich es so schreibe bekomme ich aber eine Fehlermeldung.

Ich hoffe es ist verständlich was ich machen möchte.

Ich komme da nicht so recht weiter, vielleicht hat jemand eine Idee?

[Luckie]

Schreibe eine Klasse mit einer Property und einem Setter und Getter. Ein Klassen Tutorial, was dies demonstriert, findets du hier: http://tutorials.luckie-online.de

Delphi-Quellcode:

type
  TFoo = class
  private
    FLbl: TLabel;
    function GetText: string;
    procedure SetText(s: String);
  public
    constructor Create(lbl: TLabel);
    property MyText: string read GetText write SetText;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

constructor TFoo.Create(Lbl: TLabel);
begin
  inherited Create;
  FLbl := Lbl;
end;

procedure TFoo.SetText(s: String);
begin
  FLbl.Caption := s;
end;

function TFoo.GetText: String;
begin
  result := FLbl.Caption;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Foo: TFoo;
begin
  Foo := TFoo.Create(Label1);
  try
    ShowMessage(Foo.MyText);
  finally
    FreeAndNIl(Foo);
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  Foo: TFoo;
begin
  Foo := TFoo.Create(Label1);
  try
    Foo.MyText := 'Hello';
  finally
    FreeAndNil(Foo);
  end;
end;

[Legolas]

Hallo Luckie,

das habe ich mir fast gedacht, das es in diese Richtung gehen würde.

Da man ja gleiche Prozeduren mit verschiedenen Parametern definieren kann (mittels overload) dachte ich es wäre bei meinem Problem genauso.

Ich werde dein Tutorial mal duchschauen.

Danke

[shmia]

Du brauchst ein Array-Property:

Delphi-Quellcode:

public 
  property Irgendwas[const Index:String]: string read GetIrgendwas write SetIrgendwas;
end;

Du brauchst nur obigen Code zu einer Klasse hinzufügen und Strg+Umschalt+C drücken.
Die Klassenvervollständigung von Delphi erzeugt dir dann die Deklarationen für die Get- und Set-Methode.

[Rackergen2]

Wäre es mit einem einfachen record oder object in dem Fall getan?

[Luckie]

Zitat:

Die Klassenvervollständigung von Delphi erzeugt dir dann die Deklarationen für die Get- und Set-Methode.

Nun ja. Aber nicht bei Personal Versionen - leider. :roll:

[Luckie]

Nachtrag:
Mit shmias Methode sähe das dann so aus:

Delphi-Quellcode:

type
  TFoo = class
  private
    FLbl: TLabel;
    function GetSetText(const Index: String): string;
  public
    constructor Create(lbl: TLabel);
    property MyText[const Index: String]: string read GetSetText;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

constructor TFoo.Create(Lbl: TLabel);
begin
  inherited Create;
  FLbl := Lbl;
end;


function TFoo.GetSetText(const Index: String): String;
begin
  result := FLbl.Caption;
  if Index <> '' then
    FLbl.Caption := Index;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Foo: TFoo;
begin
  Foo := TFoo.Create(Label1);
  try
    ShowMessage(Foo.MyText['']);
  finally
    FreeAndNIl(Foo);
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  Foo: TFoo;
begin
  Foo := TFoo.Create(Label1);
  try
    Foo.MyText['Hello'];
  finally
    FreeAndNil(Foo);
  end;
end;

Ich finde das macht das Ganze aber etwas unübersichtlich. Mit einem getrennten Getter und Setter finde ich das persönlich besser. Oder gibt es da noch einen Vorteil, den ich jetzt übersehen habe?

[Legolas]

Hi Luckie,

also dein Tutorial ist super, Danke nochmals.

Ich bin auch bei deinem ursprünglichen Vorschlag geblieben und mein Problem ist damit gelöst.

[shmia]

Zitat:

Zitat von Luckie

Ich finde das macht das Ganze aber etwas unübersichtlich. Mit einem getrennten Getter und Setter finde ich das persönlich besser. Oder gibt es da noch einen Vorteil, den ich jetzt übersehen habe?

Ähhemm... die sind doch getrennt:

Delphi-Quellcode:

  private
    { Private-Deklarationen }
    function GetIrgendwas(const Index: String): string;
    procedure SetIrgendwas(const Index, Value: string);
  public
    { Public-Deklarationen }
     property Irgendwas[const Index:String]: string read GetIrgendwas write SetIrgendwas;
  end;

Bei Array-Properties kann man als Index nicht nur Zahlen, sondern auch andere Datentypen verwenden.
Ein Beispiel aus der VCL wäre TDataset.FieldValues mit folgender Deklararion:

Delphi-Quellcode:

property FieldValues[const FieldName: string]: Variant;

Man kann Array-Properties sogar mehrdimensional machen:

Delphi-Quellcode:

property Spielfeld[const Feldindex:integer; gegner:Boolean]: string read GetSpielfeld write SetSpielfeld;