Home » Tutorials » VCL » Komponenten entwicklen

Komponenten entwicklen

Properties und Methoden

Ok, nun kommen wir zum Praxisteil. In diesem Kapitel programmieren wir eine kleine Beispielkomponente, die eigentlich keinen Sinn hat, aber es soll die Sache ja nur verdeutlichen.

Der Komponenten-Experte

Delphi nimmt auch hier wieder eine ganze Menge an Arbeit ab. Schließe zunächst ein evtl. geöffnetes Project. Nun klicke im Menü „Komponente“ auf den Eintrag „Neue Komponente“. Es sollte sich folgender Dialog öffnen:

Gebe unter Vorfahrtyp auch TComponent und unter Klassenname den Namen Deiner neuen Komponente an (TBeispielComp). Im Feld „Name der Unit“ musst Du den Ort angeben, wo die Unit der Komponente gespeichert werden soll. Klicke dann auf „OK“.
An dieser Stelle sollte gesagt werden, dass eine Komponente nicht aus einem vollständigen Projekt besteht sondern nur aus einer Unit und evtl. aus einer Ressourcen-Datei.
Der Experte sollte jetzt folgenden Code erzeugt haben:

unit BeispielComp;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type
  TBeispielComp = class(TComponent)
  private
  { Private-Deklarationen }
  protected
  { Protected-Deklarationen }
  public
  { Public-Deklarationen }
  published
  { Published-Deklarationen }
end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Extra', [TBeispielComp]);
end;

end.

Die ersten Zeilen sollten klar sein. Unter „type“ wird Deine neue Komponente deklariert, und sie wurde von der Klasse TComponent abgeleitet. Zu den verschiedenen Deklarations-Blöcken komme ich gleich noch.
Und es wurde schon die Procedure „Register“ hinzugefügt. Diese Procedure ist wichtig für die Installation der Komponente. In diesem Fall wird sie auf der Seite „Extra“ in der Komponentenpalette installiert.

Die erste Eigenschaft (Property)

Nun wollen wir unsere erste Eigenschaft programmieren. Deklariere in dem „Private-Abschntt“ die Variablen „FZahl1“ und „FZahl2“ vom Typ Integer.

private
  FZahl1: Integer;
  FZahl2: Integer;
  { Private-Deklarationen }

In diesen beiden Variablen werden die Eigenschaften zuerst gespeichert. Wenn wir also im Komponentenquelltext eigentlich auf die Eigenschaft „Zahl1“ zugreifen wollen, müssen wir „FZahl1“ schreiben.
Aber so wird die Eigenschaft noch nicht im OI angezeigt. Dazu müssen wir ein Property im „Published-Abschnitt“ deklarieren.

published
  property Zahl1: Integer read FZahl1 write FZahl1;
  property Zahl2: Integer read FZahl2 write FZahl2;
  { Published-Deklarationen }

Das war’s! Du hast soeben eine eigene Eigenschaft erstellt.
Das „Property“ gibt an, dass es sich um eine Eigenschaft handelt. Danach kommt der Name der Eigenschaft. Hinter dem Doppelpunkt muss die Art der Eigenschaft angegeben werden. Der restliche Teil bedeutet (vereinfacht ausgedrückt): Der Wert der Eigenschaft wird von FZahl1 ausgelesen und sollte die Eigenschaft verändert werden (Zahl1:=1;) wird der neue Wert in FZahl1 geschrieben.
Speicher jetzt mal die Unit und installiere sie damit Du die Komponente mal testen kannst (siehe Punkt „Installieren“). Also Du solltest jetzt insgesamt vier Eigenschaften im Objektinspektor sehen können: „Name“ und „Tag“ sind geerbte Eigenschaften vom Typ TComponent, aber Zahl1 und Zahl2 sind Deine eigenen Eigenschaften.
Lade jetzt wieder Deine Unit. Du hast bisher zwei Eigenschaften erstellt, die nur ganzzahlige Zahlen akzeptieren. Du kannst auch Eigenschaften vom Typ „Boolean“, „String“ oder „Char“ deklarieren, um nur einige zu nennen.

Eine eigene Methode

Nun wollen wir mal eine Methode, genauer gesagt eine Funktion der Komponente hinzufügen. Diese Funktion soll die Zahlen, die in „FZahl1“ und „FZahl2“ stehen addieren.
Nennen wir diese Funktion „Berechne“. Ergänze den Code, so dass im public-Abschnitt folgendes geschrieben steht:

public
  function Berechne: Integer;
  { Public-Deklarationen }

Nun musst Du die Funktion auch noch sagen, was sie tun soll. Schreibe nun hinter dem Wort „implemantion“ folgendes:

function TBeispielComp.Berechne: Integer;
begin
  result := FZahl1 + FZahl2;
end;

Diese Funktion gibt ja eine Zahl zurück, also ist ihr Rückgabewert ein „Integer“. Es werden die Eigenschaften „Zahl1“ und „Zahl2“ addiert. Da man den Inhalt nur über die Variabelennamen anspricht kommt da „FZahl1“ und „FZahl2“ hin. Alles klar?
Speicher jetzt noch mal Deine Unit und installiere sie erneut. Probier die Berechne-Funktion jetzt mal aus (z.B.: Label1.Caption:=IntToStr(BeispielComp1.Berechne);).
Also, fassen wir mal zusammen, was bisher alles besprochen wurde:

  • Eigenschaften deklariert man im „Published-Block“. Zuvor muss eine Variable im „Private-Block“ festgelegt werden.
  • Methoden sind einfach nur Functionen/Proceduren. Diese musst Du im „Public-Abschnitt“ festlegen und dann wie gewohnt implementieren.