Was den Setter anbelangt verstehe ich es nicht ganz, der Wert den ich überwachen will kommt von aussen, d.h es wird in meinem Programm gar nicht
verändert resp. gesetzt. Im meinem Programm wird das Wert nur gelesen.
Du schreibst den Wert, der überwacht werden soll, doch in eine Variable, nicht wahr? Und diese Variable deklarierst du nun als Property. Properties (Eigenschaften) liest und schreibt man über Getter und Setter. Dabei stellt der Name (Bezeichner) des Properties die "von außen" ansprechbare Variable dar. Die "eigentliche" Variable, die den Wert tatsächlich vorhält, wird nach den Regeln der Code-Formatierung mit einem vorangestellten f gekennzeichnet:
Delphi-Quellcode:
Private
fMeinWert : Integer;
Public
Property MeinWert : Integer read GetfMeinWert write SetfMeinWert;
Das ist die Art & Weise, wie man Properties erstellt. Drückst du nun in der Zeile, in der das Property deklariert wird, die Tastenkombination Shift-Control-C, werden automatisch die beiden Methoden Getter und Setter erstellt. Nun kannst du "von außen" die Variable fMeinWert nur noch auf dem Weg über das Property ändern:
Delphi-Quellcode:
// Wert setzen
MeinWert := 65; //oder
MeinWert := AusgelesenerWert;
// Wert auslesen
MeineVariable := MeinWert;
Beim Setzen und Auslesen von MeinWert werden jetzt immer Setter und Getter des Properties aufgerufen. Hier kannst du dann z.B. das reinschreiben, was passieren soll, wenn sich die Variable ändert, also im Setter nach der Zuweisung DoSomeThing.
Ich meinte Setter bedeutet setzen eines bestehenden Wertes und wenn es ungültig ist dann eine
Exception auslösen. Verstehe ich es falsch ??
Nein, Setter ist einfach die Methode, um den privaten Integer fMeinWert zu schreiben. Wenn du einer Variablen einen Wert zuweist, passiert ja sonst nichts. Wenn du einem Property einen Wert zuweist, kannst du im Setter zusätzliche Befehle unterbringen.
Beim zweitem Vorschlag was meinst Du mit DoSomething ?
DoSomething ist einfach das, was beim Setzen des Wertes passieren soll, eine Dummy-Procedure, da ich ja nicht wissen kann, was du da vorhast, wenn der Wert gesetzt wird.
Sollte da ein Vergleich zwischen AltWert und NeuWert statfinden ?
Das weiß ich doch nicht, was da stattfinden soll, das mußt du doch selber wissen. Du hattest doch oben geschrieben, du möchtest, daß etwas bestimmtes ausgeführt wird, wenn sich der eingelesene Wert ändert, nicht? Okay, dann schreibst du in den Setter das rein, was dann ausgeführt werden soll, am besten in einer eigenständigen Methode, die du dann im Setter aufrufst, was ich mit DoSomething quasi als Dummy bereits vorgeführt habe.
Aber wie soll daraus ein Event erzeugt werden ?
Ein Event – auf deutsch: ein Ereignis – mußt du nur dann erzeugen, wenn du
Unit-übergreifend arbeitest. Mit anderen Worten: Befindet sich das Property in derselben
Unit, in der sich auch die Methode, mit der auf die Änderung des Wertes reagiert werden soll, befindet, brauchst du kein Ereignis, dann kannst du das dort direkt erledigen. Befindet sich das Property jedoch in einer eigenständigen
Unit, muß die
Unit, die die Reaktions-Methode enthält, ja irgendwie mitbekommen, daß sich der Wert geändert hat. Zu diesem Zweck wurden die Events erfunden. Ein Event wird erst einmal als Typ deklariert, gewöhnlich vor der Typdeklaration der Klasse, wie ich dir anhand eines Beispiels zeigen möchte, in welchem das Ereignis in der Klasse TDatMod (UnitData) stattfindet:
Delphi-Quellcode:
TYPE
TUpdateStatusbarEvent = Procedure of Object; // Statusbar in Mainform
TYPE
TDatMod = CLASS(TDataModule)
...
PRIVATE { Private-Deklarationen }
Var
fUpdateStatusbar : TUpdateStatusbarEvent;
...
PUBLIC { Public-Deklarationen }
...
Property OnUpdateStatusbar : TUpdateStatusbarEvent read fUpdateStatusbar write fUpdateStatusbar;
...
END;
Ausgelöst wird das Ereignis dann durch diesen Befehl:
If Assigned(fUpdateStatusbar) Then fUpdateStatusbar;
Verbindest du nun in deiner
Unit, in der die Reaktions-Methode steht, das Ereignis mit der Methode, wird diese Methode jedesmal aufgerufen, wenn das Ereignis stattfindet – oder wie man hier gewöhnlich sagt: wenn das Event feuert:
Delphi-Quellcode:
Procedure TFormMain.FormActivate(Sender: TObject);
begin
...
DatMod.OnUpdateStatusbar := StatusBarAktuell;
...
end;
Ich setze dieses Event z.B. ein, um in der Mainform die Statusbar zu aktualisieren, wenn sich der Datensatzzeiger einer Tabelle geändert hat:
Delphi-Quellcode:
Procedure TDatMod.View_LogAccessAfterScroll(DataSet: TDataSet);
begin
If Assigned(fUpdateStatusbar) Then fUpdateStatusbar;
end;
Damit wird nun jedesmal beim Scrollen einer Datenmenge, die z.B. in FormMain durch das Scrollen in einem DBGrid ausgelöst wurde, die Anzeige in der Methode StatusBarAktuell aktualisiert:
Delphi-Quellcode:
Procedure TFormMain.StatusBarAktuell;
begin
StatBar.Panels[0].Text := GLD.IntToStrPunkte(DatMod.View_LogAccess.RecNo);
StatBar.Panels[1].Text := GLD.IntToStrPunkte(DatMod.View_LogAccess.FieldByName('ID').AsInteger);
StatBar.Panels[2].Text := DatMod.View_LogAccess.FieldByName('DATEI').AsString;
Application.ProcessMessages;
end;
Solltest du entgegen meiner Erwartung nur Bahnhof verstehen, empfiehlt sich die Lektüre des einen oder anderen Tutorials, z.B. das beim
Delph-Treff über Klassen und Objekte.