In den letzten Wochen drangen immer wieder verschiedene Information u.a. von den Blog-Seiten der CodeGear-Mitarbeiter an die Öffentlichkeit: Delphi 2009 und C++-Builder 2009 erstellen nativen Code für Windows 32. Das RAD Studio 2009 wird wahrscheinlich im Q4 veröffentlicht.

Wichtigste Neuerung dürfte für viele Entwickler die Unicode-Unterstützung sein. Damit wird jedoch eine Lauffähigkeit der Applikationen unter Windows 9x bzw. NT4 der Vergangenheit angehören. Die Delphi-Language wurde um Generics und Anonyme Methoden für Delphi/Win32 erweitert. Im Datenbankbereich wurde DataSnap überarbeitet bzw. neu entwickelt. Diese vier neuen Kernfeatures stellen wir Ihnen im Folgenden vor.

Anonyme Methoden

von Olaf Monien

Mit einer "Anonymen Methode" ist nicht etwa eine Organisation gemeint, in der sich Methoden treffen, um über Probleme zu sprechen, die sie mit ihren Programmierern haben, sondern es geht hier natürlich um eine Erweiterung der Delphi Language (also Pascal). Dieses Sprach-Feature stammt ursprünglich aus dem Bereich der funktionalen Programmiersprachen. Das Konzept der Anonymen Methoden wurde letztlich bereits in LISP beschrieben und ist also alles andere als „neu“. In der letzten Zeit, speziell seit der Verbreitung von C# 2.0, hat dieses Sprachelement jedoch deutlich mehr Aufmerksamkeit erlangt.

Eine Anonyme Methode ist schlicht eine Methode (Prozedur oder Funktion), die keinen Namen besitzt. Im Sprachgebrauch der funktionalen Programmiersprachen wird ein solches Konstrukt auch Lambda-Ausdruck genannt.

Zunächst kann man einen Typ deklarieren, der wie ein Pointer auf eine Funktion aussieht – denn im Grunde kann man anonyme Methoden eben nicht über ihren Namen referenzieren, sondern nur über einen „Pointer“ – eine anonyme Referenz.

1. type
2. TFooComparer = reference to function(a, b: TFoo):boolean;

In diesem Beispiel soll also ein Mechanismus entworfen werden, der es auf einfache Art erlaubt, eine konfigurierbare Vergleichsoperation für einen speziellen Typ (hier TFoo) bereit zu stellen.

Die Klasse TFoo sei wie folgt deklariert:

1. type
2. TFoo = class(TObject)
3. public
4. FAge:Integer;
5. FName:String;
6. end;

Nun lassen sich recht einfach quasi ad-hoc „Comparer“ implementieren, die hier entweder anhand des Alters oder des Namens von TFoo-Objekten die Größer-Kleiner Beziehung entscheiden:

1. var
2. LNameComparer:TFooComparer;
3. LAgeComparer:TFooComparer;
4. begin
5. …
6. LNameComparer :=
7. function(a, b: TFoo):boolean;
8. begin
9. result := a.FName > b.FName;
10. end;
11. LAgeComparer :=
12. function(a, b: TFoo):boolean;
13. begin
14. result := a.FAge > b.FAge;
15. end;
16. …

Sie lesen hier richtig: ...können nun einer Variablen Pascal-Code zuweisen! Folgerichtig kann diese Variable „LComparer“ auch als Parameter weitergegeben werden. Als Beispiel führen wir nun eine TFooList ein: