delphi 5 - entwicklerhandbuch

Entwicklerhandbuch
Inprise GmbH, Robert-Bosch-Straße 11, D-63225 Langen
Borland
®
Delphi
™
5
für Windows 95, Windows 98 & Windows NT
Copyright © 1998, 1999 Inprise, Inc. Alle Rechte vorbehalten. Alle Produktnamen von Inprise sind eingetragene
Warenzeichen der Inprise, Inc.
Deutsche Ausgabe © 1999 Inprise GmbH, Robert-Bosch-Straße 11, D-63225 Langen, Telefon 06103/979-0,
Fax 06103/979-290
Update/Übertragung ins Deutsche: Krieger, Zander & Partner GmbH, München
Satz: Krieger, Zander & Partner GmbH, München
Hauptsitz: 100 Enterprise Way, P.O. Box 660001, Scotts Valley, CA 95067-0001, +1-(408)431-1000
Niederlassungen in: Australien, Deutschland, Frankreich, Großbritannien, Hong Kong, Japan, Kanada,
Lateinamerika, Mexiko, den Niederlanden und Taiwan
HDA1350GE21001
i
Kapitel 1
Einführung 1-1
Inhalt dieses Handbuchs . . . . . . . . . . . . . 1-1
Typographische Konventionen . . . . . . . . . . 1-3
Inprise Developer Support Services . . . . . . . 1-3
Gedruckte Dokumentation . . . . . . . . . . . . 1-3
Teil I
Programmieren mit Delphi
Kapitel 2
Object Pascal mit der VCL verwenden
2-1
Object Pascal und die VCL . . . . . . . . . . . . 2-1

Das Objektmodell . . . . . . . . . . . . . . . . . 2-2
Was ist ein Objekt? . . . . . . . . . . . . . . . 2-2
Ein Delphi-Objekt untersuchen . . . . . . 2-3
Daten und Quelltext von einem Objekt erben 2-5
Objekte, Komponenten und Steuer-
elemente . . . . . . . . . . . . . . . . . . 2-6
Gültigkeitsbereich und Qualifizierer. . . . . 2-6
private-, protected-, public- und
published-Deklarationen. . . . . . . . . 2-7
Objektvariablen verwenden. . . . . . . . . . 2-8
Objekte erstellen, instantiieren und
freigeben. . . . . . . . . . . . . . . . . . . . 2-9
Komponenten und Eigentümer . . . . . .2-10
Komponenten verwenden . . . . . . . . . . . .2-10
Die Delphi-Standardkomponenten. . . . . .2-10
Eigenschaften aller visuellen
Komponenten . . . . . . . . . . . . . . .2-11
Textkomponenten. . . . . . . . . . . . . .2-13
Spezialisierte Eingabekomponenten . . . 2-15
Schaltflächen und ähnliche
Steuerelemente . . . . . . . . . . . . . .2-17
Mit Listen arbeiten . . . . . . . . . . . . .2-19
Komponenten gruppieren . . . . . . . . .2-21
Visuelle Rückmeldungen . . . . . . . . .2-23
Gitterkomponenten. . . . . . . . . . . . .2-24
Grafikkomponenten . . . . . . . . . . . .2-25
Windows-Standarddialogfelder. . . . . .2-26
Eigenschaften von Komponenten festlegen .2-26
Den Objektinspektor verwenden . . . . .2-27
Eigenschaften zur Laufzeit festlegen . . .2-27

Methoden aufrufen. . . . . . . . . . . . . . .2-28
Mit Ereignissen und
Ereignisbehandlungsroutinen arbeiten . . 2-28
Eine neue Ereignisbehandlungsroutine
erstellen . . . . . . . . . . . . . . . . . . 2-28
Eine Behandlungsroutine für das
Standardereignis einer Komponente
erstellen . . . . . . . . . . . . . . . . . . 2-29
Ereignisbehandlungsroutinen suchen . . 2-29
Ereignissen eine vorhandene
Behandlungsroutine zuordnen . . . . . 2-29
Menüereignissen eine Behandlungsroutine
zuordnen . . . . . . . . . . . . . . . . . 2-30
Ereignisbehandlungsroutinen löschen . 2-31
Hilfsobjekte verwenden . . . . . . . . . . . . . 2-31
Mit Listen arbeiten . . . . . . . . . . . . . . 2-32
Mit Stringlisten arbeiten . . . . . . . . . . . 2-32
Stringlisten laden und speichern. . . . . 2-33
Eine neue Stringliste erstellen . . . . . . 2-33
Mit den Strings in einer Liste arbeiten. . 2-35
Einer Stringliste Objekte zuordnen . . . 2-37
Mit Registrierung und INI-Dateien arbeiten 2-38
Streams verwenden . . . . . . . . . . . . . . 2-38
Datenmodule und Remote-Datenmodule
verwenden . . . . . . . . . . . . . . . . . . . . 2-38
Datenmodule erstellen und bearbeiten . . . 2-39
Business Rules in einem Datenmodul
erstellen . . . . . . . . . . . . . . . . . . 2-39
In einem Formular auf ein Datenmodul
zugreifen . . . . . . . . . . . . . . . . . . . 2-40

Ein Remote-Datenmodul einem
Anwendungsserver hinzufügen . . . . . . 2-40
Die Objektablage verwenden . . . . . . . . . . 2-40
Elemente in einem Projekt gemeinsam
verwenden . . . . . . . . . . . . . . . . . . 2-41
Elemente in die Objektablage aufnehmen . 2-41
Objekte in einer Team-Umgebung gemeinsam
verwenden . . . . . . . . . . . . . . . . . . 2-41
Ein Element der Objektablage in einem
Projekt verwenden . . . . . . . . . . . . . 2-42
Ein Objekt kopieren . . . . . . . . . . . . 2-42
Ein Objekt vererben . . . . . . . . . . . . 2-42
Ein Objekt verwenden. . . . . . . . . . . 2-42
Projektvorlagen verwenden . . . . . . . . . 2-42
Freigegebene Objekte ändern . . . . . . . . 2-43
Ein Standardelement für neue Projekte,
Formulare und Hauptformulare angeben 2-43
Inhalt
ii
Benutzerdefinierte Komponenten der IDE
hinzufügen . . . . . . . . . . . . . . . . . . . . 2-44
Kapitel 3
Typische Programmieraufgaben 3-1
Exception-Behandlung . . . . . . . . . . . . . . 3-1
Quelltextblöcke schützen . . . . . . . . . . . 3-2
Auf Exceptions reagieren . . . . . . . . . 3-2
Exceptions und die Ablaufsteuerung. . . 3-3
Exception-Reaktionen verschachteln . . . 3-3
Ressourcenzuweisungen schützen . . . . . . 3-4
Zu schützende Ressourcen. . . . . . . . . 3-4

Ressourcen-Schutzblöcke erstellen . . . . 3-5
RTL-Exceptions behandeln . . . . . . . . . . 3-6
RTL-Exceptions . . . . . . . . . . . . . . . 3-6
Exception-Behandlungsroutine erstellen. 3-7
Exception-Behandlungsanweisungen . . 3-8
Exception-Instanz verwenden. . . . . . . 3-9
Gültigkeitsbereich von Exception-
Behandlungsroutinen. . . . . . . . . . .3-10
Standard-Exception-Behandlungsroutinen
bereitstellen . . . . . . . . . . . . . . . .3-10
Exception-Klassen verarbeiten . . . . . . 3-11
Exception erneut auslösen . . . . . . . . . 3-11
Komponenten-Exceptions behandeln . . . .3-12
TApplication.HandleException verwenden .3-13
Stille Exceptions . . . . . . . . . . . . . . . .3-13
Exceptions definieren . . . . . . . . . . . . .3-14
Exception-Objekttyp deklarieren . . . . .3-14
Exception auslösen . . . . . . . . . . . . .3-15
Schnittstellen verwenden . . . . . . . . . . . . .3-15
Schnittstellen als Sprachmerkmal . . . . . .3-16
Schnittstellen in mehreren Klassen
nutzen . . . . . . . . . . . . . . . . . . .3-16
Schnittstellen mit Prozeduren
verwenden . . . . . . . . . . . . . . . . .3-18
IUnknown implementieren . . . . . . . . . .3-18
TInterfacedObject . . . . . . . . . . . . . . .3-19
Operator as verwenden . . . . . . . . . . . .3-19
Wiederverwendung von Quelltext und
Delegation . . . . . . . . . . . . . . . . . . .3-20
implements für die Delegation

verwenden . . . . . . . . . . . . . . . . .3-20
Aggregation . . . . . . . . . . . . . . . . .3-22
Speicherverwaltung für Schnittstellen-
objekte . . . . . . . . . . . . . . . . . . . . .3-22
Referenzzählung einsetzen . . . . . . . .3-23
Keine Referenzzählung einsetzen. . . . .3-24
Schnittstellen in verteilten Anwendungen
einsetzen . . . . . . . . . . . . . . . . . . . 3-24
Mit Strings arbeiten. . . . . . . . . . . . . . . . 3-25
Zeichentypen . . . . . . . . . . . . . . . . . 3-25
String-Typen . . . . . . . . . . . . . . . . . . 3-26
Kurze Strings . . . . . . . . . . . . . . . . 3-26
Lange Strings. . . . . . . . . . . . . . . . 3-27
WideString . . . . . . . . . . . . . . . . . 3-28
PChar-Typen . . . . . . . . . . . . . . . . 3-28
OpenString . . . . . . . . . . . . . . . . . 3-28
Routinen der Laufzeitbibliothek zur String-
Verarbeitung . . . . . . . . . . . . . . . . . 3-29
Wide-Zeichenroutinen. . . . . . . . . . . 3-29
Gebräuchliche Routinen für lange
Strings . . . . . . . . . . . . . . . . . . . 3-30
Strings deklarieren und initialisieren . . . . 3-32
String-Typen mischen und konvertieren . . 3-33
Konvertierungen von String in PChar . . . 3-33
String-Abhängigkeiten . . . . . . . . . . 3-34
Lokale PChar-Variable zurückgeben. . . 3-34
Lokale Variable als PChar übergeben . . 3-34
Compiler-Direktiven für Strings. . . . . . . 3-35
Strings und Zeichen: Verwandte Themen . 3-36
Mit Dateien arbeiten . . . . . . . . . . . . . . . 3-36

Dateien bearbeiten . . . . . . . . . . . . . . 3-37
Datei löschen . . . . . . . . . . . . . . . . 3-37
Datei suchen . . . . . . . . . . . . . . . . 3-37
Dateiattribute ändern . . . . . . . . . . . 3-39
Datei umbenennen. . . . . . . . . . . . . 3-39
Datums-/Zeit-Routinen. . . . . . . . . . 3-40
Datei kopieren . . . . . . . . . . . . . . . 3-40
Dateitypen mit Datei-E/A . . . . . . . . . . 3-40
Datei-Streams verwenden . . . . . . . . . . 3-41
Dateien erstellen und öffnen . . . . . . . 3-42
Datei-Handle verwenden . . . . . . . . . 3-42
Dateien lesen und schreiben . . . . . . . 3-43
Strings lesen und schreiben. . . . . . . . 3-43
Datei durchsuchen. . . . . . . . . . . . . 3-44
Dateiposition und -größe . . . . . . . . . 3-44
Kopieren . . . . . . . . . . . . . . . . . . 3-45
Neue Datentypen definieren. . . . . . . . . . . 3-45
Kapitel 4
Anwendungen, Komponenten und
Bibliotheken erstellen 4-1
Anwendungen erstellen . . . . . . . . . . . . . . 4-1
Windows-Anwendungen. . . . . . . . . . . . 4-1
Benutzeroberflächen. . . . . . . . . . . . . 4-2
iii
IDE-, Projekt- und Compiler-Optionen
festlegen . . . . . . . . . . . . . . . . . . 4-3
Quelltextvorlagen . . . . . . . . . . . . . . . 4-3
Konsolenanwendungen . . . . . . . . . . . . 4-3
Service-Anwendungen . . . . . . . . . . . . 4-4
Service-Threads . . . . . . . . . . . . . . . 4-6

Service-Namenseigenschaften. . . . . . . 4-8
Services testen. . . . . . . . . . . . . . . . 4-8
Packages und DLLs erstellen . . . . . . . . . . . 4-9
Unterschiede zwischen Packages und DLLs 4-9
Datenbankanwendungen erstellen. . . . . . . . 4-9
Verteilte Anwendungen erstellen . . . . . . . .4-10
Verteilte TCP/IP-Anwendungen erstellen. .4-10
Sockets in Anwendungen verwenden . . 4-11
Web-Server-Anwendungen erstellen . . . 4-11
Verteilte Anwendungen mit COM und
DCOM erstellen. . . . . . . . . . . . . . . .4-12
COM und DCOM. . . . . . . . . . . . . .4-12
MTS . . . . . . . . . . . . . . . . . . . . .4-12
Verteilte CORBA-Anwendungen erstellen .4-12
Verteilte Datenbankanwendungen erstellen.4-13
Kapitel 5
Die Benutzeroberfläche erstellen 5-1
Die Klassen TApplication, TScreen und TForm 5-1
Das Hauptformular . . . . . . . . . . . . . . 5-1
Weitere Formulare hinzufügen . . . . . . . . 5-2
Formulare verknüpfen . . . . . . . . . . . 5-2
Auf Anwendungsebene arbeiten . . . . . . . 5-3
Mit dem Bildschirm arbeiten . . . . . . . . . 5-3
Das Layout festlegen. . . . . . . . . . . . . . 5-3
Mit Botschaften arbeiten . . . . . . . . . . . . . 5-5
Weitere Informationen zu Formularen . . . . . 5-5
Die Formularerstellung im Speicher steuern 5-5
Automatisch erstellte Formulare anzeigen5-6
Formulare dynamisch erstellen . . . . . . 5-6
Nichtmodale Formulare erstellen. . . . . 5-7

Formularinstanzen mit lokalen Variablen
erstellen . . . . . . . . . . . . . . . . . . 5-7
Zusätzliche Argumente an Formulare
übergeben . . . . . . . . . . . . . . . . . . . 5-8
Daten aus Formularen abrufen . . . . . . . . 5-9
Daten aus nichtmodalen Formularen
abrufen . . . . . . . . . . . . . . . . . . . 5-9
Daten aus modalen Formularen abrufen.5-10
Komponenten und Komponentengruppen wieder
verwenden . . . . . . . . . . . . . . . . . . . .5-12
Komponentenvorlagen . . . . . . . . . . . . . .5-12
Frames. . . . . . . . . . . . . . . . . . . . . . . .5-13
Frames erstellen . . . . . . . . . . . . . . . . 5-14
Frames in die Komponentenpalette
einfügen. . . . . . . . . . . . . . . . . . 5-14
Frames verwenden und ändern . . . . . . . 5-14
Frames freigeben . . . . . . . . . . . . . . . 5-16
Menüs erstellen und verwalten . . . . . . . . . 5-16
Den Menü-Designer öffnen . . . . . . . . . 5-17
Menüs entwerfen . . . . . . . . . . . . . . . 5-18
Menüs benennen. . . . . . . . . . . . . . 5-19
Menüeinträge benennen . . . . . . . . . 5-19
Menüeinträge hinzufügen, einfügen und
entfernen . . . . . . . . . . . . . . . . . 5-20
Untermenüs erstellen . . . . . . . . . . . 5-21
Das Menü anzeigen . . . . . . . . . . . . 5-23
Menüeinträge im Objektinspektor
bearbeiten . . . . . . . . . . . . . . . . . . 5-24
Das lokale Menü des Menü-Designers
verwenden . . . . . . . . . . . . . . . . . . 5-24

Die Befehle des lokalen Menüs. . . . . . 5-25
Zur Entwurfszeit zwischen Menüs
wechseln . . . . . . . . . . . . . . . . . 5-25
Menüvorlagen verwenden . . . . . . . . . . 5-26
Ein Menü als Vorlage speichern . . . . . . . 5-27
Namenskonventionen für Menüeinträge
und Ereignisbehandlungsroutinen in
Vorlagen. . . . . . . . . . . . . . . . . . 5-28
Menüeinträge zur Laufzeit bearbeiten . . . 5-29
Menüs kombinieren. . . . . . . . . . . . . . 5-29
Das aktive Menü festlegen: die Eigenschaft
Menu . . . . . . . . . . . . . . . . . . . 5-29
Die Reihenfolge der kombinierten
Menüeinträge festlegen: die Eigenschaft
GroupIndex. . . . . . . . . . . . . . . . 5-29
Ressourcen-Dateien importieren. . . . . . . 5-30
ToolBar- und CoolBar-Komponenten erstellen 5-31
Eine Panel-Komponente als Symbolleiste
hinzufügen . . . . . . . . . . . . . . . . . . 5-32
Einer Symbolleiste (TPanel) eine
SpeedButton-Komponente hinzufügen 5-32
Einer SpeedButton-Komponente eine Grafik
zuweisen . . . . . . . . . . . . . . . . . 5-33
Die Anfangseinstellungen einer
SpeedButton-Komponente festlegen. . 5-33
Eine Gruppe von SpeedButton-
Komponenten erstellen . . . . . . . . . 5-33
Eine SpeedButton-Komponente als Ein-/
Ausschalter verwenden . . . . . . . . . 5-34
Eine ToolBar-Komponente als Symbolleiste

hinzufügen . . . . . . . . . . . . . . . . . . 5-34
iv
Einer Symbolleiste (TToolBar) eine
ToolButton-Komponente hinzufügen. .5-35
Einer ToolButton-Komponente eine Grafik
zuweisen . . . . . . . . . . . . . . . . . .5-35
Die Anfangseinstellungen einer ToolButton-
Komponente festlegen . . . . . . . . . .5-35
Eine Gruppe von ToolButton-Komponenten
erstellen . . . . . . . . . . . . . . . . . .5-36
Eine ToolButton-Komponente als Ein-/
Ausschalter verwenden . . . . . . . . .5-36
Eine CoolBar-Komponente hinzufügen . . .5-36
Die Anfangseinstellungen einer CoolBar-
Komponente festlegen . . . . . . . . . .5-37
Auf Mausklicks reagieren . . . . . . . . . . .5-37
Einer ToolButton-Komponente ein Menü
zuweisen . . . . . . . . . . . . . . . . . .5-38
Verborgene Symbolleisten hinzufügen. . . .5-38
Symbolleisten ein- und ausblenden . . . . .5-38
Aktionslisten verwenden . . . . . . . . . . . . .5-39
Aktionsobjekte . . . . . . . . . . . . . . . . .5-39
Aktionen verwenden. . . . . . . . . . . . . .5-40
Quelltext zentral verwalten . . . . . . . .5-41
Eigenschaften verknüpfen . . . . . . . . .5-41
Aktionen ausführen . . . . . . . . . . . .5-41
Aktionen aktualisieren . . . . . . . . . . . 5-43
Vordefinierte Aktionsklassen . . . . . . . . .5-43
Standard-Bearbeitungsaktionen. . . . . .5-44
Windows-Standardaktionen. . . . . . . .5-44

Datenmengenaktionen . . . . . . . . . . .5-44
Aktionskomponenten erstellen . . . . . . . .5-45
Wie Aktionen ihre Zielobjekte
lokalisieren. . . . . . . . . . . . . . . . .5-45
Aktionen registrieren. . . . . . . . . . . .5-47
Einen Aktionslisten-Editor erstellen . . .5-47
Beispielprogramme . . . . . . . . . . . . . .5-47
Kapitel 6
Mit Steuerelementen arbeiten 6-1
Drag&Drop-Operationen in Steuerelementen
implementieren. . . . . . . . . . . . . . . . . . 6-1
Eine Drag-Operation beginnen . . . . . . . . 6-1
Gezogene Elemente akzeptieren . . . . . . . 6-2
Elemente ablegen. . . . . . . . . . . . . . . . 6-3
Eine Drag-Operation beenden . . . . . . . . 6-3
Drag&Drop-Operationen durch ein Drag-
Objekt anpassen . . . . . . . . . . . . . . . 6-3
Den Drag-Mauszeiger ändern . . . . . . . . 6-4
Drag&Dock in Steuerelementen implementieren6-4
Ein fensterorientiertes Steuerelement als Ziel
einer Andock-Operation definieren . . . . . 6-5
Ein Steuerelement als andockbares
Steuerelement definieren . . . . . . . . . . . 6-5
Andock-Operationen von Steuerelementen
steuern . . . . . . . . . . . . . . . . . . . . . 6-6
Steuerelemente vom Ziel einer Andock-
Operation trennen . . . . . . . . . . . . . . . 6-6
Die Behandlung von Drag&Dock-Operationen
durch Steuerelemente festlegen . . . . . . . 6-7
Text in Steuerelementen bearbeiten . . . . . . . . 6-7

Die Textausrichtung festlegen . . . . . . . . . 6-8
Bildlaufleisten zur Laufzeit hinzufügen . . . 6-8
Das Clipboard-Objekt hinzufügen . . . . . . 6-9
Text markieren . . . . . . . . . . . . . . . . . . 6-9
Den gesamten Text markieren . . . . . . . . 6-10
Text ausschneiden, kopieren und einfügen. 6-10
Markierten Text löschen . . . . . . . . . . . 6-11
Menüeinträge deaktivieren. . . . . . . . . . 6-11
Ein Popup-Menü bereitstellen . . . . . . . . 6-12
Das Ereignis OnPopup . . . . . . . . . . . . 6-12
Grafiken zu Steuerelementen hinzufügen . . . 6-13
Den Owner-Draw-Stil festlegen . . . . . . . 6-13
Grafikobjekte zu einer Stringliste
hinzufügen . . . . . . . . . . . . . . . . . . 6-14
Grafiken zu einer Anwendung
hinzufügen . . . . . . . . . . . . . . . . 6-14
Grafiken zu einer Stringliste hinzufügen 6-14
Owner-Draw-Elemente anzeigen . . . . 6-15
Größe von Owner-Draw-Elementen
festlegen . . . . . . . . . . . . . . . . . . . 6-15
Alle Owner-Draw-Elemente anzeigen . . . 6-16
Kapitel 7
Mit Grafiken und Multimedia arbeiten 7-1
Grafikprogrammierung im Überblick . . . . . . 7-1
Den Bildschirm aktualisieren . . . . . . . . . 7-2
Grafikobjekt-Typen . . . . . . . . . . . . . . . 7-3
Häufig verwendete Eigenschaften und
Methoden des Objekts Canvas . . . . . . . . 7-4
Eigenschaften des Objekts Canvas
verwenden . . . . . . . . . . . . . . . . . . . 7-5

Stifte verwenden . . . . . . . . . . . . . . . 7-5
Pinsel verwenden . . . . . . . . . . . . . . 7-8
Pixel lesen und setzen . . . . . . . . . . . 7-10
Grafikobjekte zeichnen . . . . . . . . . . . . 7-10
Linien und Linienzüge zeichnen . . . . . 7-10
Formen zeichnen. . . . . . . . . . . . . . 7-11
v
Behandlung mehrerer Zeichenobjekte in einer
Anwendung. . . . . . . . . . . . . . . . . .7-13
Benötigte Zeichenwerkzeuge ermitteln . 7-13
Werkzeuge mit Hilfe von
Mauspalettenschaltern wechseln . . . .7-14
Zeichenwerkzeuge verwenden . . . . . .7-15
In einer Grafik zeichnen . . . . . . . . . . . .7-18
Bildlauffähige Grafiken . . . . . . . . . .7-18
Bild-Steuerelemente hinzufügen . . . . .7-18
Grafikdateien laden und speichern. . . . . .7-20
Bilder aus Dateien laden . . . . . . . . . .7-21
Bilder in Dateien speichern . . . . . . . .7-21
Bilder ersetzen . . . . . . . . . . . . . . .7-22
Die Zwischenablage und Grafiken . . . . . .7-23
Grafiken in die Zwischenablage
kopieren . . . . . . . . . . . . . . . . . .7-23
Grafiken in die Zwischenablage
ausschneiden . . . . . . . . . . . . . . .7-23
Grafiken aus der Zwischenablage
einfügen . . . . . . . . . . . . . . . . . .7-24
Der Gummiband-Effekt: Beispiel . . . . . . .7-24
Auf Mausaktionen reagieren . . . . . . .7-25
Felder einem Formularobjekt

hinzufügen. . . . . . . . . . . . . . . . .7-28
Verbesserte Liniendarstellung . . . . . . . 7-29
Mit Multimedia arbeiten . . . . . . . . . . . . .7-31
Einer Anwendung Videoclips ohne Ton
hinzufügen . . . . . . . . . . . . . . . . . .7-31
Beispiel für das Hinzufügen von Videoclips
ohne Ton . . . . . . . . . . . . . . . . . .7-32
Einer Anwendung Audio- und/oder Videoclips
hinzufügen . . . . . . . . . . . . . . . . . .7-33
Beispiel für das Hinzufügen von Audio-
und/oder Videoclips . . . . . . . . . . .7-35
Kapitel 8
Multithread-Anwendungen entwickeln
8-1
Thread-Objekte definieren . . . . . . . . . . . . 8-2
Den Thread initialisieren . . . . . . . . . . . 8-3
Eine Standard-Priorität zuweisen. . . . . 8-3
Den Freigabezeitpunkt von Threads
festlegen . . . . . . . . . . . . . . . . . . 8-3
Die Thread-Funktion schreiben. . . . . . . . 8-4
Der VCL-Haupt-Thread . . . . . . . . . . 8-4
Lokale Thread-Variablen verwenden . . . 8-5
Die Beendigung mit anderen Threads
prüfen . . . . . . . . . . . . . . . . . . . 8-6
Clean-up-Quelltext schreiben . . . . . . . . . 8-6
Threads koordinieren. . . . . . . . . . . . . . . . 8-7
Gleichzeitigen Zugriff vermeiden . . . . . . . 8-7
Objekte sperren . . . . . . . . . . . . . . . 8-7
Kritische Abschnitte . . . . . . . . . . . . . 8-7
TMultiReadExclusiveWriteSynchronizer-

Objekte . . . . . . . . . . . . . . . . . . . 8-8
Weitere Techniken für die gemeinsame
Nutzung von Speicher. . . . . . . . . . . 8-9
Die Ausführung anderer Threads abwarten . 8-9
Warten, bis ein Thread vollständig
ausgeführt ist . . . . . . . . . . . . . . . . 8-9
Warten, bis eine Aufgabe ausgeführt ist. 8-10
Thread-Objekte ausführen . . . . . . . . . . . . 8-11
Die Standard-Priorität überschreiben . . . . 8-11
Threads starten und stoppen. . . . . . . . . 8-12
Threads in verteilten Anwendungen . . . . . . 8-12
Threads und botschaftsbasierte Server . . . 8-13
Threads und verteilte Objekte . . . . . . . . 8-13
Anwendungen (EXE-Dateien) schreiben 8-13
Bibliotheken schreiben . . . . . . . . . . 8-14
Fehlersuche in Multithread-Anwendungen . . 8-15
Kapitel 9
Packages und Komponenten 9-1
Packages sinnvoll einsetzen . . . . . . . . . . . . 9-2
Packages und Standard-DLLs . . . . . . . . . 9-2
Laufzeit-Packages. . . . . . . . . . . . . . . . . . 9-3
Laufzeit-Packages in Anwendungen . . . . . 9-3
Packages dynamisch laden. . . . . . . . . . . 9-4
Benötigte Laufzeit-Packages auswählen . . . 9-4
Benutzerdefinierte Packages . . . . . . . . . . 9-5
Entwurfszeit-Packages . . . . . . . . . . . . . . . 9-6
Komponenten-Packages installieren . . . . . 9-6
Packages erstellen und bearbeiten . . . . . . . . 9-8
Ein Package erstellen . . . . . . . . . . . . . . 9-8
Ein bestehendes Package bearbeiten . . . . . 9-9

Quelldateien von Packages manuell
bearbeiten . . . . . . . . . . . . . . . . . . . 9-9
Die Struktur eines Package. . . . . . . . . . 9-10
Packages benennen . . . . . . . . . . . . 9-10
Die requires-Klausel . . . . . . . . . . . . 9-10
Die contains-Klausel. . . . . . . . . . . . 9-11
Packages compilieren . . . . . . . . . . . . . 9-11
Spezielle Compiler-Direktiven für
Packages . . . . . . . . . . . . . . . . . 9-12
Der Befehlszeilen-Compiler und -Linker 9-14
Package-Dateien nach erfolgreicher
Compilierung. . . . . . . . . . . . . . . 9-14
Packages weitergeben . . . . . . . . . . . . . . 9-15
vi
Anwendungen mit Packages weitergeben .9-15
Packages anderen Entwicklern zur Verfügung
stellen . . . . . . . . . . . . . . . . . . . . .9-15
Package-Sammlungen . . . . . . . . . . . . .9-15
Kapitel 10
Anwendungen für den internationalen Markt
10-1
Internationalisierung und Lokalisierung . . . .10-1
Internationalisierung. . . . . . . . . . . . . .10-1
Lokalisierung . . . . . . . . . . . . . . . . . .10-2
Internationalisieren von Anwendungen . . . .10-2
Quelltext anpassen . . . . . . . . . . . . . . .10-2
Zeichensätze. . . . . . . . . . . . . . . . .10-2
OEM- und ANSI- Zeichensatz. . . . . . .10-2
Doppelbyte-Zeichensätze . . . . . . . . .10-2
16-Bit-Zeichen . . . . . . . . . . . . . . . .10-3

Bidirektionale Sprachen . . . . . . . . . . 10-4
Die Eigenschaft BiDiMode. . . . . . . . .10-6
Funktionen für bestimmte
Gebietsschemas . . . . . . . . . . . . . .10-8
Die Benutzeroberfläche gestalten. . . . . . .10-9
Text . . . . . . . . . . . . . . . . . . . . . .10-9
Grafiken . . . . . . . . . . . . . . . . . . . 10-9
Formate und Sortierreihenfolge. . . . . 10-10
Tastenzuordnungen . . . . . . . . . . . 10-10
Ressourcen auslagern . . . . . . . . . . . . 10-10
Ressourcen-DLLs erstellen . . . . . . . . . 10-10
Ressourcen-DLLs verwenden. . . . . . . . 10-12
Ressourcen-DLLs dynamisch wechseln . . 10-13
Anwendungen lokalisieren . . . . . . . . . . . 10-13
Ressourcen lokalisieren . . . . . . . . . . . 10-13
Kapitel 11
Anwendungen weitergeben 11-1
Allgemeine Anwendungen weitergeben . . . . 11-1
Installationsprogramme verwenden . . . . . 11-2
Anwendungsdateien identifizieren. . . . 11-2
Anwendungsdateien nach Namens-
erweiterung . . . . . . . . . . . . . . . . 11-3
Package-Dateien . . . . . . . . . . . . . . 11-3
ActiveX-Steuerelemente . . . . . . . . . . 11-3
Hilfsanwendungen . . . . . . . . . . . . . 11-4
Position von DLL-Dateien . . . . . . . . . 11-4
Datenbankanwendungen weitergeben . . . . . 11-4
Die Datenbank-Engine bereitstellen . . . . . 11-5
Borland Database Engine . . . . . . . . . 11-5
Datenbank-Engines von Fremd-

herstellern . . . . . . . . . . . . . . . . . 11-6
SQL Links. . . . . . . . . . . . . . . . . . 11-6
MIDAS (Multi-tiered Distributed Application
Services) . . . . . . . . . . . . . . . . . . . 11-7
Web-Anwendungen weitergeben . . . . . . . . 11-8
Unterschiedliche Host-Umgebungen
berücksichtigen . . . . . . . . . . . . . . . . . 11-8
Bildschirmauflösung und Farbtiefe . . . . . 11-9
Anwendungen ohne dynamische
Größenanpassung . . . . . . . . . . . . 11-9
Anwendungen mit dynamischer
Größenanpassung der Formulare und
Steuerelemente . . . . . . . . . . . . . . 11-9
Unterschiedliche Farbtiefen . . . . . . .11-11
Schriften . . . . . . . . . . . . . . . . . . . .11-11
Windows-Version . . . . . . . . . . . . . . .11-12
Software-Lizenzvereinbarungen . . . . . . . .11-12
DEPLOY.TXT . . . . . . . . . . . . . . . . .11-13
README.TXT . . . . . . . . . . . . . . . . .11-13
Lizenzvereinbarungen . . . . . . . . . . . .11-13
Dokumentation zu Produkten von
Fremdherstellern . . . . . . . . . . . . . .11-13
Teil II
Datenbankanwendungen entwickeln
Kapitel 12
Datenbankanwendungen entwerfen 12-1
Datenbanken . . . . . . . . . . . . . . . . . . . 12-1
Datenbanktypen. . . . . . . . . . . . . . . . 12-2
Lokale Datenbanken. . . . . . . . . . . . 12-2
Remote-Datenbankserver . . . . . . . . . 12-3

Datenbanksicherheit . . . . . . . . . . . . . 12-3
Transaktionen . . . . . . . . . . . . . . . . . 12-4
Das Daten-Dictionary. . . . . . . . . . . . . 12-5
Referentielle Integrität, Stored Procedures und
Trigger . . . . . . . . . . . . . . . . . . . . 12-6
Datenbankarchitektur . . . . . . . . . . . . . . 12-6
Skalierbarkeit planen . . . . . . . . . . . . . 12-7
Einschichtige Datenbankanwendungen . . 12-9
Zweischichtige Datenbankanwendungen . 12-9
Mehrschichtige Datenbankanwendungen 12-10
Benutzeroberflächen entwickeln . . . . . . . 12-12
Einzelne Datensätze anzeigen . . . . . . . 12-12
Mehrere Datensätze anzeigen . . . . . . . 12-13
Daten analysieren . . . . . . . . . . . . . . 12-14
Anzeige der Daten festlegen . . . . . . . . 12-14
Berichte erstellen . . . . . . . . . . . . . . 12-17
vii
Kapitel 13
Ein- und zweischichtige Anwendunen
erstellen 13-1
BDE-Anwendungen . . . . . . . . . . . . . . . .13-2
BDE-Architektur . . . . . . . . . . . . . . . .13-2
Grundlagen von Datenbanken und
Datenmengen . . . . . . . . . . . . . . .13-3
Sitzungen verwenden . . . . . . . . . . .13-4
Verbindung mit Datenbanken. . . . . . . . .13-5
Transaktionen. . . . . . . . . . . . . . . . . . 13-5
Transaktionen explizit steuern . . . . . .13-6
Datenbank-Komponenten für Transaktionen
verwenden . . . . . . . . . . . . . . . . .13-6

Die Eigenschaft TransIsolation . . . . . .13-7
Passthrough-SQL . . . . . . . . . . . . . .13-9
Lokale Transaktionen. . . . . . . . . . . .13-9
Aktualisierungen zwischenspeichern . . . 13-10
Datenbanktabellen erstellen und
umstrukturieren . . . . . . . . . . . . . . 13-11
ADO-basierte Anwendungen . . . . . . . . . 13-11
ADO-basierte Architektur. . . . . . . . . . 13-12
Grundlagen zu ADO-Datenbanken und -
Datenmengen . . . . . . . . . . . . . . 13-12
Verbindung zu ADO-Datenbanken
herstellen . . . . . . . . . . . . . . . . . . 13-13
Daten abrufen. . . . . . . . . . . . . . . . . 13-13
ADO-Datenbanktabellen erstellen und
umstrukturieren . . . . . . . . . . . . . . 13-14
Datenbankanwendungen mit unstrukturierten
Daten . . . . . . . . . . . . . . . . . . . . . . 13-15
Datenmengen erstellen . . . . . . . . . . . 13-15
Neue Datenmengen mit persistenten
Feldern erstellen. . . . . . . . . . . . . 13-16
Datenmengen mit Feld- und
Indexdefinitionen erstellen . . . . . . 13-16
Datenmengen auf Grundlage bestehender
Tabellen erstellen . . . . . . . . . . . . 13-17
Daten laden und speichern . . . . . . . . . 13-18
Das Aktenkoffer-Modell. . . . . . . . . . . 13-19
Skalierung auf eine dreischichtige
Anwendung . . . . . . . . . . . . . . . . . . 13-20
Kapitel 14
Mehrschichtige Anwendungen erstellen

14-1
Vorteile des mehrschichtigen Datenbank-
modells . . . . . . . . . . . . . . . . . . . . . .14-2
Grundlagen der MIDAS-Technologie . . . . . .14-3
Struktur einer mehrschichtigen MIDAS-
Anwendung . . . . . . . . . . . . . . . . . 14-3
Die Struktur der Client-Anwendung . . . . 14-4
Die Struktur des Anwendungsservers . . . 14-5
MTS verwenden . . . . . . . . . . . . . . 14-6
Remote-Datenmodule verwalten . . . . 14-8
Schnittstelle IAppServer verwenden . . 14-8
Verbindungsprotokoll wählen . . . . . . . . 14-9
DCOM-Verbindungen einsetzen . . . . . 14-9
Socket-Verbindungen einsetzen . . . . 14-10
Web-Verbindungen einsetzen. . . . . . .14-11
OLEnterprise verwenden . . . . . . . . .14-11
CORBA-Verbindungen einsetzen . . . 14-12
Mehrschichtige Anwendungen erstellen. . . 14-12
Anwendungsserver erstellen . . . . . . . . . 14-13
Remote-Datenmodul einrichten . . . . . . 14-15
TRemoteDataModule konfigurieren. . 14-15
TMTSDataModule konfigurieren . . . 14-16
TCorbaDataModule konfigurieren . . 14-17
Daten-Provider für Anwendungsserver
erstellen. . . . . . . . . . . . . . . . . . . 14-18
Schnittstelle des Anwendungsservers
erweitern . . . . . . . . . . . . . . . . . . 14-19
Callbacks der Schnittstelle des
Anwendungsservers hinzufügen . . 14-20
Schnittstelle des Anwendungsservers

unter MTS erweitern. . . . . . . . . . 14-20
Client-Anwendung erstellen. . . . . . . . . . 14-20
Verbindung zum Anwendungsserver
einrichten . . . . . . . . . . . . . . . . . . 14-21
Verbindung über DCOM angeben . . . 14-22
Verbindung über Sockets angeben . . . 14-23
Verbindung über HTTP angeben. . . . 14-24
Verbindung über OLEnterprise
angeben . . . . . . . . . . . . . . . . . 14-24
Verbindung über CORBA angeben . . 14-25
Broker-Verbindungen . . . . . . . . . . 14-25
Server-Verbindungen verwalten. . . . . . 14-26
Verbindung zum Server einrichten . . 14-26
Server-Verbindung schließen oder
ändern. . . . . . . . . . . . . . . . . . 14-27
Serverschnittstellen aufrufen. . . . . . . . 14-27
Transaktionen in mehrschichtigen Anwendungen
verwalten. . . . . . . . . . . . . . . . . . . . 14-28
Haupt/Detail-Beziehungen unterstützen . . 14-29
Statusinformationen in Remote-Datenmodulen
unterstützen . . . . . . . . . . . . . . . . . . 14-30
Web-basierte MIDAS-Anwendungen erstellen14-32
viii
Client-Anwendung als ActiveX-Steuerelement
weitergeben . . . . . . . . . . . . . . . . . 14-33
ActiveX-Formular für die Client-
Anwendung erstellen. . . . . . . . . . 14-33
Web-Anwendungen mit InternetExpress
erstellen . . . . . . . . . . . . . . . . . . . 14-34
InternetExpress-Anwendung erstellen . 14-35

Javascript-Bibliotheken verwenden. . . 14-36
Zugriffs- und Startberechtigung für den
Anwendungsserver gewähren. . . . . 14-37
XML-Broker verwenden. . . . . . . . . . . 14-37
XML-Datenpakete abrufen . . . . . . . 14-38
Aktualisierung aus XML-
Datenpaketen eintragen . . . 14-39
Web-Seiten mit einem MIDAS-Seitengenerator
erstellen . . . . . . . . . . . . . . . . . . . 14-40
Web-Seiteneditor verwenden . . . . . . 14-41
Eigenschaften von Web-Elementen
festlegen . . . . . . . . . . . . . . . . . 14-42
Vorlage des MIDAS-Seitengenerators
anpassen . . . . . . . . . . . . . . . . . 14-43
Kapitel 15
Provider-Komponenten 15-1
Die Datenquelle festlegen. . . . . . . . . . . . .15-1
Aktualisierungen eintragen. . . . . . . . . . . .15-2
Datenpakete zusammenstellen . . . . . . . . . .15-2
Felder für Datenpakete festlegen . . . . . . .15-3
Optionen für Datenpakete einstellen. . . . . 15-3
Datenpaketen benutzerdefinierte Daten
hinzufügen . . . . . . . . . . . . . . . . . .15-4
Auf Datenanforderungen des Client reagieren .15-5
Auf Aktualisierungsanforderungen des Client
reagieren . . . . . . . . . . . . . . . . . . . . .15-6
Delta-Pakete vor dem Aktualisieren der
Datenbank bearbeiten . . . . . . . . . . . .15-7
Die Art der Aktualisierung steuern . . . . .15-8
Bestimmte Aktualisierungen überwachen. .15-9

Aktualisierungsfehler beheben . . . . . . . 15-10
Aktualisierungen in Datenmengen mit
mehreren Tabellen . . . . . . . . . . . . . 15-10
Auf Client-Ereignisse reagieren . . . . . . . . 15-11
Server-Beschränkungen . . . . . . . . . . . . . 15-11
Kapitel 16
Datenbanksitzungen 16-1
Mit einer Sitzungskomponente arbeiten . . . .16-2
Die Standardsitzung . . . . . . . . . . . . . .16-2
Zusätzliche Sitzungen erzeugen . . . . . . .16-3
Sitzungsnamen zuweisen. . . . . . . . . . . 16-4
Eine Sitzung aktivieren . . . . . . . . . . . . 16-5
Den Start der Sitzung anpassen . . . . . . . 16-6
Das Standardverhalten von
Datenbankverbindungen festlegen . . . . 16-6
Datenbankverbindungen erzeugen, öffnen und
schließen . . . . . . . . . . . . . . . . . . . 16-7
Eine einzelne Datenbankverbindung
schließen . . . . . . . . . . . . . . . . . 16-7
Alle Datenbankverbindungen schließen 16-8
Temporäre Datenbankverbindungen
trennen . . . . . . . . . . . . . . . . . . . . 16-8
Nach einer Datenbankverbindung suchen . 16-9
Informationen über eine Sitzung abrufen . 16-9
BDE-Aliase . . . . . . . . . . . . . . . . . . 16-10
Die Sichtbarkeit von Aliasen festlegen .16-11
Sitzungs-Aliase für andere Sitzungen und
Anwendungen sichtbar machen . . . .16-11
Bekannte Aliase, Treiber und Parameter
festlegen. . . . . . . . . . . . . . . . . .16-11

Aliase erzeugen, ändern und löschen . 16-12
Durch die Datenbank-Komponenten einer
Sitzung iterieren . . . . . . . . . . . . . . 16-13
Paradox-Verzeichnisse angeben . . . . . . 16-14
Das Verzeichnis der Steuerdatei
festlegen. . . . . . . . . . . . . . . . . 16-14
Ein Verzeichnis für temporäre Dateien
festlegen. . . . . . . . . . . . . . . . . 16-14
Kennwortgeschützte Paradox- und dBase-
Tabellen . . . . . . . . . . . . . . . . . . . 16-15
Die Methode AddPassword verwenden16-15
Die Methoden RemovePassword und
RemoveAllPasswords verwenden . . 16-16
Die Methode GetPassword und das
Ereignis OnPassword verwenden . . 16-16
Mehrere Sitzungen verwalten . . . . . . . . . 16-17
Sitzungskomponenten in Datenmodulen
verwenden . . . . . . . . . . . . . . . . . . . 16-19
Kapitel 17
Datenbankverbindungen 17-1
Persistente und temporäre Datenbank-
Komponenten . . . . . . . . . . . . . . . . . . 17-1
Temporäre Datenbank-Komponenten. . . . 17-2
Datenbank-Komponenten zur Entwurfszeit
erstellen. . . . . . . . . . . . . . . . . . . . 17-2
Datenbank-Komponenten zur Laufzeit
erstellen. . . . . . . . . . . . . . . . . . . . 17-3
Verbindungen steuern . . . . . . . . . . . . . . 17-4
ix
Eine Datenbank-Komponente mit einer Sitzung

verbinden . . . . . . . . . . . . . . . . . . .17-4
Einen BDE-Alias angeben . . . . . . . . . . .17-4
BDE-Aliasparameter festlegen . . . . . . . .17-5
Server-Login steuern. . . . . . . . . . . . . .17-6
Mit einem Datenbankserver verbinden . . .17-7
Besonderheiten beim Verbinden mit einem
Remote-Server . . . . . . . . . . . . . . . .17-8
Mit Netzwerkprotokollen arbeiten . . . .17-8
ODBC . . . . . . . . . . . . . . . . . . . .17-8
Eine Verbindung zu einem Datenbankserver
trennen. . . . . . . . . . . . . . . . . . . . . 17-9
Datenmengen ohne Trennen der Server-
Verbindung schließen . . . . . . . . . . . .17-9
Durch die Datenmengen einer Datenbank-
Komponente iterieren . . . . . . . . . . . .17-9
Interaktionen zwischen Datenbank- und Sitzungs-
komponenten . . . . . . . . . . . . . . . . . . 17-10
Datenbank-Komponenten in Datenmodulen . 17-10
SQL-Anweisungen mit einer TDatabase-
Komponente ausführen . . . . . . . . . . . . 17-10
SQL-Anweisungen ohne Ergebnismengen
ausführen . . . . . . . . . . . . . . . . . . 17-11
SQL-Anweisungen mit Ergebnismengen
ausführen . . . . . . . . . . . . . . . . . . 17-12
SQL-Anweisungen mit Parametern
ausführen . . . . . . . . . . . . . . . . . . 17-13
Kapitel 18
Datenmengen 18-1
Die Komponente TDataSet . . . . . . . . . . . .18-2
Arten von Datenmengen . . . . . . . . . . . . .18-3

Datenmengen öffnen und schließen . . . . . . .18-3
Den Status von Datenmengen bestimmen und
einstellen . . . . . . . . . . . . . . . . . . . . .18-4
Eine Datenmenge deaktivieren . . . . . . . .18-6
Datenmengen durchsuchen . . . . . . . . . .18-7
Die Bearbeitung von Datenmengen
ermöglichen . . . . . . . . . . . . . . . . . .18-8
Das Einfügen neuer Datensätze
ermöglichen . . . . . . . . . . . . . . . . . .18-9
Auf Indizes basierende Suchvorgänge und
Bereiche in Tabellen . . . . . . . . . . . . 18-10
Felder berechnen . . . . . . . . . . . . . . . 18-10
Datensätze filtern. . . . . . . . . . . . . . . 18-11
Datensätze aktualisieren. . . . . . . . . . . 18-11
Durch Datenmengen navigieren . . . . . . . . 18-11
Die Methoden First und Last . . . . . . . . 18-12
Die Methoden Next und Prior . . . . . . . 18-12
Die Methode MoveBy. . . . . . . . . . . . 18-13
Die Eigenschaften EOF und BOF . . . . . 18-13
EOF . . . . . . . . . . . . . . . . . . . . 18-14
BOF . . . . . . . . . . . . . . . . . . . . 18-15
Datensätze markieren und dorthin
zurückkehren . . . . . . . . . . . . . . . 18-15
Datenmengen durchsuchen . . . . . . . . . . 18-17
Die Methode Locate. . . . . . . . . . . . . 18-17
Die Methode Lookup . . . . . . . . . . . . 18-18
Teilmengen von Daten mit Hilfe von Filtern
anzeigen und bearbeiten . . . . . . . . . . . 18-19
Filter aktivieren und deaktivieren . . . . . 18-19
Filter erzeugen. . . . . . . . . . . . . . . . 18-20

Die Eigenschaft Filter festlegen . . . . . . 18-20
Eine Behandlungsroutine für das Ereignis
OnFilterRecord schreiben. . . . . . . . . 18-21
Filterbehandlungsroutinen zur Laufzeit
wechseln . . . . . . . . . . . . . . . . 18-22
Filteroptionen festlegen. . . . . . . . . . . 18-22
Durch Datensätze einer gefilterten Datenmenge
navigieren . . . . . . . . . . . . . . . . . 18-23
Daten bearbeiten . . . . . . . . . . . . . . . . 18-24
Datensätze bearbeiten. . . . . . . . . . . . 18-24
Neue Datensätze hinzufügen . . . . . . . 18-25
Datensätze einfügen . . . . . . . . . . . 18-26
Datensätze anhängen . . . . . . . . . . 18-26
Datensätze löschen . . . . . . . . . . . . . 18-27
Daten in die Datenbank eintragen. . . . . 18-27
Änderungen rückgängig machen . . . . . 18-28
Komplette Datensätze bearbeiten . . . . . 18-28
Ereignisse für Datenmengen behandeln . . . 18-30
Eine Methode abbrechen . . . . . . . . . . 18-30
Das Ereignis OnCalcFields . . . . . . . . . 18-30
BDE-Datenmengen . . . . . . . . . . . . . . . 18-31
BDE-Datenmengen im Überblick . . . . . 18-32
Datenbank- und Sitzungsverbindungen
verwalten . . . . . . . . . . . . . . . . . . 18-32
Die Eigenschaften DatabaseName und
SessionName . . . . . . . . . . . . . . 18-33
BDE-Handle-Eigenschaften. . . . . . . 18-34
Zwischengespeicherte Aktualisierungen . 18-34
BLOBs zwischenspeichern . . . . . . . . . 18-35
Kapitel 19

Felder 19-1
Was sind Feldkomponenten? . . . . . . . . . . 19-2
Dynamische Feldkomponenten . . . . . . . 19-3
Persistente Feldkomponenten . . . . . . . . 19-4
Persistente Felder erstellen. . . . . . . . . . . . 19-6
x
Persistente Felder anordnen . . . . . . . . . . .19-7
Neue persistente Felder erstellen . . . . . . . .19-7
Datenfelder definieren. . . . . . . . . . . . .19-8
Berechnete Felder definieren . . . . . . . . .19-9
Berechnete Felder programmieren . . . . . 19-10
Lookup-Felder definieren . . . . . . . . . . 19-11
Aggregatfelder definieren . . . . . . . . . . 19-13
Persistente Feldkomponenten löschen . . . 19-13
Eigenschaften und Ereignisse persistenter
Felder . . . . . . . . . . . . . . . . . . . . . . 19-14
Anzeige- und Bearbeitungseigenschaften zur
Entwurfszeit festlegen . . . . . . . . . . . 19-14
Die Eigenschaften von Feldkomponenten zur
Laufzeit festlegen . . . . . . . . . . . . . . 19-16
Attributsätze für Feldkomponenten
erstellen . . . . . . . . . . . . . . . . . . . 19-16
Attributsätze mit Feldkomponenten
verbinden . . . . . . . . . . . . . . . . . . 19-17
Attributsatz-Zuordnungen löschen . . . . 19-17
Benutzereingaben steuern. . . . . . . . . . 19-18
Standardformate für numerische, Datums- und
Zeitfelder . . . . . . . . . . . . . . . . . . 19-18
Ereignisse verarbeiten . . . . . . . . . . . . 19-19
Zur Laufzeit mit Feldkomponentenmethoden

arbeiten . . . . . . . . . . . . . . . . . . . . . 19-20
Feldwerte anzeigen, konvertieren und
abrufen . . . . . . . . . . . . . . . . . . . . . 19-20
Werte in Standard-Steuerelementen
anzeigen . . . . . . . . . . . . . . . . . . . 19-21
Feldwerte konvertieren . . . . . . . . . . . 19-21
Mit der Standard-Datenmengeneigenschaft
auf Werte zugreifen. . . . . . . . . . . . . 19-22
Mit der Datenmengeneigenschaft Fields auf
Werte zugreifen . . . . . . . . . . . . . . . 19-23
Mit der Datenmengenmethode FieldByName
auf Werte zugreifen. . . . . . . . . . . . . 19-23
Den aktuellen Wert eines Feldes überprüfen . 19-24
Einen Standardwert für ein Feld festlegen . . 19-24
Datenbeschränkungen. . . . . . . . . . . . . . 19-24
Selbstdefinierte Beschränkungen . . . . . . 19-24
Server-Beschränkungen . . . . . . . . . . . 19-25
Objektfelder . . . . . . . . . . . . . . . . . . . 19-26
ADT- und Array-Felder anzeigen . . . . . 19-27
ADT-Felder . . . . . . . . . . . . . . . . . . 19-27
Auf Werte von ADT-Feldern zugreifen. 19-27
Array-Felder . . . . . . . . . . . . . . . . . 19-29
Auf Werte von Array-Feldern zugreifen 19-29
Datenmengenfelder . . . . . . . . . . . . . 19-30
Datenmengenfelder anzeigen . . . . . . 19-30
Auf Daten in einer verschachtelten
Datenmenge zugreifen . . . . . . . . 19-30
Referenzfelder . . . . . . . . . . . . . . . . 19-31
Referenzfelder anzeigen. . . . . . . . . 19-31
Auf Daten in einem Referenzfeld

zugreifen . . . . . . . . . . . . . . . . 19-31
Kapitel 20
Tabellen 20-1
Tabellenkomponenten . . . . . . . . . . . . . . 20-1
Tabellenkomponenten erstellen . . . . . . . . . 20-2
Datenbankposition angeben . . . . . . . . . 20-2
Tabellennamen festlegen . . . . . . . . . . . 20-3
Tabellentypen für lokale Tabellen festlegen 20-4
Tabellen öffnen und schließen . . . . . . . . 20-4
Zugriff auf Tabellen steuern . . . . . . . . . . . 20-5
Datensätze suchen . . . . . . . . . . . . . . . . 20-6
Datensätze über indizierte Felder suchen . 20-6
Datensätze mit Goto-Methoden suchen. 20-7
Datensätze mit Find-Methoden suchen . 20-8
Aktuellen Datensatz nach einer erfolgreichen
Suche bestimmen . . . . . . . . . . . . . . 20-8
Datensätze über Teilschlüssel suchen . . . . 20-9
Datensätze über Sekundärindizes suchen . 20-9
Suchoperationen wiederholen oder
erweitern . . . . . . . . . . . . . . . . . . . 20-9
Datensätze sortieren . . . . . . . . . . . . . . 20-10
Verfügbare Indizes mit GetIndexNames
abrufen . . . . . . . . . . . . . . . . . . . 20-10
Sekundärindizes in IndexName festlegen 20-10
dBASE-Indexdateien angeben . . . . . .20-11
Sortierreihenfolge für SQL-Tabellen. . . . .20-11
Felder in IndexFieldNames angeben . .20-11
Feldlisten nach einem Index durchsuchen 20-12
Mit Teilmengen der Daten arbeiten . . . . . . 20-12
Unterschiede zwischen Bereichen und

Filtern . . . . . . . . . . . . . . . . . . . . 20-12
Bereiche erstellen und zuweisen. . . . . . 20-13
Bereichsanfang festlegen . . . . . . . . 20-13
Bereichsende festlegen . . . . . . . . . 20-14
Bereichsanfang und -ende festlegen . . 20-15
Bereiche mit Teilschlüsseln festlegen . 20-15
Datensätze ein- oder ausschließen, die mit
Bereichsgrenzen übereinstimmen . . 20-16
Bereiche zuweisen . . . . . . . . . . . . 20-16
Bereiche entfernen . . . . . . . . . . . . 20-16
Bereiche ändern . . . . . . . . . . . . . . . 20-17
Bereichsanfang ändern . . . . . . . . . 20-17
Bereichsende ändern . . . . . . . . . . 20-17
xi
Alle Datensätze einer Tabelle löschen . . . . . 20-18
Tabellen löschen . . . . . . . . . . . . . . . . . 20-18
Tabellen umbenennen . . . . . . . . . . . . . . 20-18
Tabellen erstellen. . . . . . . . . . . . . . . . . 20-19
Daten aus einer anderen Tabelle importieren. 20-21
TBatchMove verwenden . . . . . . . . . . . . 20-22
Batch-Move-Komponenten erzeugen . . . 20-22
Batch-Move-Modi . . . . . . . . . . . . . . 20-23
Anhängen . . . . . . . . . . . . . . . . . 20-24
Aktualisieren . . . . . . . . . . . . . . . 20-24
Anhängen und Aktualisieren . . . . . . 20-24
Kopieren . . . . . . . . . . . . . . . . . . 20-24
Löschen . . . . . . . . . . . . . . . . . . 20-24
Datentypen zuordnen . . . . . . . . . . . . 20-25
Batch-Move-Operationen ausführen . . . . 20-26
Batch-Move-Fehler . . . . . . . . . . . . . . 20-26

Mit einer Datenbanktabelle verknüpfte
Tabellenkomponenten synchronisieren . . . 20-27
Haupt/Detail-Formulare erstellen. . . . . . . 20-28
Beispiel für ein Haupt/Detail-Formular. . 20-28
Verschachtelte Tabellen . . . . . . . . . . . . . 20-29
Verschachtelte Tabellenkomponenten
einrichten . . . . . . . . . . . . . . . . . . 20-30
Kapitel 21
Abfragen 21-1
Abfragen effektiv einsetzen. . . . . . . . . . . . 21-1
Abfragen für Desktop-Entwickler . . . . . .21-2
Abfragen für Server-Entwickler . . . . . . . 21-3
Datenbanken, auf die mit einer
Abfragekomponente zugegriffen werden
kann . . . . . . . . . . . . . . . . . . . . . . . .21-4
Abfragekomponenten im Überblick . . . . . . .21-4
Die Eigenschaft SQL setzen. . . . . . . . . . . .21-6
Die Eigenschaft SQL zur Entwurfszeit setzen. .
21-7
Die Eigenschaft SQL zur Laufzeit setzen . .21-7
Die Eigenschaft SQL direkt setzen . . . .21-8
Die Eigenschaft SQL aus einer Datei
laden . . . . . . . . . . . . . . . . . . . .21-8
Die Eigenschaft SQL aus einem Stringlisten-
Objekt laden . . . . . . . . . . . . . . . .21-9
Parameter setzen. . . . . . . . . . . . . . . . . . 21-9
Parameter zur Entwurfszeit setzen. . . . . 21-10
Parameter zur Laufzeit setzen . . . . . . . 21-11
Datenquellen für die Parameterbindung . 21-11
Abfragen ausführen . . . . . . . . . . . . . . . 21-13

Abfragen zur Entwurfszeit ausführen . . . 21-13
Abfragen zur Laufzeit ausführen. . . . . . 21-14
Abfragen ausführen, die Ergebnismengen
liefern . . . . . . . . . . . . . . . . . . 21-14
Abfragen ausführen, die keine
Ergebnismengen liefern . . . . . . . . 21-15
Abfragen vorbereiten. . . . . . . . . . . . . . 21-15
Abfragen zur Freigabe von Ressourcen
zurücksetzen. . . . . . . . . . . . . . . . . . 21-15
Heterogene Abfragen erstellen . . . . . . . . 21-16
Die Ausführungsgeschwindigkeit von Abfragen
erhöhen. . . . . . . . . . . . . . . . . . . . . 21-17
Bidirektionale Cursor deaktivieren . . . . 21-17
Mit Ergebnismengen arbeiten . . . . . . . . . 21-18
Die Bearbeitung einer Ergebnismenge
ermöglichen . . . . . . . . . . . . . . . . 21-18
Local SQL-Syntax für aktualisierbare
Ergebnismengen . . . . . . . . . . . . . . 21-18
Einschränkungen für Abfragen mit
aktualisierbaren Ergebnismengen . . 21-18
Remote-Server-SQL für aktualisierbare
Ergebnismengen . . . . . . . . . . . . . . 21-19
Einschränkungen bei der Bearbeitung von
aktualisierbaren Ergebnismengen . . . . 21-19
Nur-Lesen-Ergebnismengen aktualisieren 21-19
Kapitel 22
Stored Procedures 22-1
Stored Procedures verwenden. . . . . . . . . . 22-2
Mit Stored Procedures arbeiten . . . . . . . . . 22-3
Stored-Procedure-Komponenten erstellen . 22-3

Stored Procedures erstellen . . . . . . . . . 22-4
Stored Procedures vorbereiten und
ausführen. . . . . . . . . . . . . . . . . . . 22-5
Stored Procedures, die Ergebnismengen
zurückgeben . . . . . . . . . . . . . . . . . 22-6
Ergebnismengen mit einer TQuery-
Komponente abrufen . . . . . . . . . . 22-6
Ergebnismengen mit einer TStoredProc-
Komponente abrufen . . . . . . . . . . 22-7
Stored Procedures, die Daten mit Hilfe von
Parametern zurückliefern. . . . . . . . . . 22-7
Einzelne Werte mit einer TQuery-
Komponente abrufen . . . . . . . . . . 22-7
Einzelne Werte mit einer TStoredProc-
Komponente abrufen . . . . . . . . . . 22-8
Stored Procedures, die Aktionen an Daten
vornehmen . . . . . . . . . . . . . . . . . . 22-9
Stored Procedures, die Aktionen ausführen,
mit einer TQuery-Komponente
aufrufen . . . . . . . . . . . . . . . . . . 22-9
xii
Stored Procedures, die Aktionen ausführen,
mit einer TStoredProc-Komponente
aufrufen . . . . . . . . . . . . . . . . . 22-10
Parameter für Stored Procedures. . . . . . . . 22-11
Eingabeparameter verwenden . . . . . . . 22-12
Ausgabeparameter verwenden . . . . . . . 22-12
Eingabe-/Ausgabeparameter verwenden . 22-13
Ergebnisparameter verwenden . . . . . . . 22-14
Zur Entwurfszeit auf Parameter zugreifen 22-14

Parameter während des Entwurfs
einstellen. . . . . . . . . . . . . . . . . . . 22-14
Parameter zur Laufzeit erstellen . . . . . . 22-16
Parameterbindung . . . . . . . . . . . . . . 22-17
Parameterinformationen während des Entwurfs
anzeigen. . . . . . . . . . . . . . . . . . . . . 22-17
Überladene Stored Procedures in Oracle . . . 22-18
Kapitel 23
Mit ADO-Komponenten arbeiten 23-1
ADO-Komponenten im Überblick . . . . . . . .23-2
Verbindungen zu ADO-Datenspeichern
einrichten . . . . . . . . . . . . . . . . . . . . .23-3
Mit TADOConnection eine Verbindung zu
einem Datenspeicher einrichten . . . . . .23-3
TADOConnection im Vergleich mit der
Eigenschaft ConnectionString einer
Datenmenge . . . . . . . . . . . . . . . .23-4
Verbindungen festlegen . . . . . . . . . .23-4
Auf das Verbindungsobjekt zugreifen . .23-5
Verbindungen aktivieren und
deaktivieren . . . . . . . . . . . . . . . .23-5
Den Status einer Verbindungskomponente
abrufen . . . . . . . . . . . . . . . . . . .23-6
Verbindungen optimieren . . . . . . . . . . .23-6
Verbindungsattribute angeben . . . . . .23-7
Timeouts steuern . . . . . . . . . . . . . .23-8
Die Anmeldung für eine Verbindung
steuern. . . . . . . . . . . . . . . . . . .23-8
Tabellen und Stored Procedures abrufen . .23-9
Auf die Datenmengen einer Verbindung

zugreifen . . . . . . . . . . . . . . . . . .23-9
Auf die Befehle einer Verbindung
zugreifen . . . . . . . . . . . . . . . . . 23-10
Verfügbare Tabellen abrufen. . . . . . . 23-11
Verfügbare Stored Procedures abrufen . 23-12
Mit Verbindungstransaktionen arbeiten . . 23-12
Transaktionsmethoden verwenden . . . 23-12
Transaktionsereignisse verwenden . . . 23-13
ADO-Datenmengen verwenden . . . . . . . . 23-13
Gemeinsame Merkmale aller ADO-
Datenmengenkomponenten . . . . . . . 23-14
Daten ändern . . . . . . . . . . . . . . . 23-14
In Datenmengen navigieren . . . . . . 23-14
Visuelle datensensitive Steuerelemente
verwenden . . . . . . . . . . . . . . . 23-15
Mit ADO-Datenmengenkomponenten
Verbindungen zu Datenspeichern
herstellen . . . . . . . . . . . . . . . . 23-15
Mit Datensatzmengen arbeiten. . . . . 23-16
Batch-Aktualisierungen verwenden . . 23-17
Daten aus Dateien laden und in Dateien
speichern . . . . . . . . . . . . . . . . 23-19
Parameter in Befehlen verwenden . . . 23-20
TADODataSet verwenden . . . . . . . . . 23-21
Mit Befehlen auf Datenmengen
zugreifen . . . . . . . . . . . . . . . . 23-22
TADOTable verwenden. . . . . . . . . . . 23-22
Zu verwendende Tabellen festlegen . . 23-23
TADOQuery verwenden . . . . . . . . . . 23-24
SQL-Anweisungen festlegen . . . . . . 23-24

SQL-Anweisungen ausführen . . . . . 23-25
TADOStoredProc verwenden . . . . . . . 23-25
Stored Procedures festlegen . . . . . . 23-26
Stored Procedures ausführen . . . . . . 23-27
Parameter mit Stored Procedures
verwenden . . . . . . . . . . . . . . . 23-27
Befehle ausführen. . . . . . . . . . . . . . . . 23-30
Befehle festlegen. . . . . . . . . . . . . . . 23-30
Die Methode Execute verwenden . . . . . 23-31
Befehle abbrechen . . . . . . . . . . . . . . 23-31
Mit Befehlen auf Ergebnismengen
zugreifen . . . . . . . . . . . . . . . . . . 23-32
Befehlsparameter verarbeiten . . . . . . . 23-32
Kapitel 24
Client-Datenmengen 24-1
Client-Datenmengen . . . . . . . . . . . . . . . 24-2
Durch die Daten einer Client-Datenmenge
navigieren . . . . . . . . . . . . . . . . . . 24-2
Datensätze einschränken . . . . . . . . . . . 24-2
Haupt/Detail-Beziehungen . . . . . . . . . 24-3
Datenwerte beschränken . . . . . . . . . . . 24-4
Daten das Attribut Nur-Lesen zuweisen . . 24-4
Daten bearbeiten . . . . . . . . . . . . . . . 24-5
Änderungen rückgängig machen . . . . 24-5
Änderungen speichern . . . . . . . . . . 24-6
Sortieren und Indizieren . . . . . . . . . . . 24-6
Einen neuen Index hinzufügen. . . . . . 24-7
xiii
Indizes entfernen und wechseln . . . . .24-8
Daten mit Indizes gruppieren . . . . . . .24-8

Bei Bedarf indizieren . . . . . . . . . . . .24-9
Berechnete Felder hinzufügen . . . . . . . .24-9
Intern berechnete Felder in Client-
Datenmengen verwenden . . . . . . . 24-10
Gewartete Aggregate verwenden . . . . . 24-10
Aggregate angeben . . . . . . . . . . . . 24-10
Datensatzgruppen zusammenfassen . . 24-12
Aggregatwerte abrufen. . . . . . . . . . 24-13
Anwendungsspezifische Informationen zu
den Daten hinzufügen . . . . . . . . . . . 24-13
Daten aus einer anderen Datenmenge kopieren . .
24-13
Daten direkt zuweisen . . . . . . . . . . . . 24-14
Datenmengen replizieren . . . . . . . . . . 24-15
Eine Client-Datenmenge mit einem Daten-Provider
verwenden . . . . . . . . . . . . . . . . . . . 24-15
Einen Daten-Provider festlegen. . . . . . . 24-16
Parameter vom Anwendungsserver
abrufen. . . . . . . . . . . . . . . . . . . . 24-16
Parameter an den Anwendungsserver übergeben
24-17
Parameter für Abfragen oder Stored
Procedures senden . . . . . . . . . . . 24-18
Datensätze durch Parameter
einschränken. . . . . . . . . . . . . . . 24-18
Die Datenmenge auf dem Anwendungsserver
überschreiben . . . . . . . . . . . . . . . . 24-18
Daten von einem Anwendungsserver
anfordern . . . . . . . . . . . . . . . . . . 24-19
Beschränkungen verarbeiten . . . . . . . . 24-21

Server-Beschränkungen verarbeiten . . 24-21
Benutzerdefinierte Beschränkungen
hinzufügen. . . . . . . . . . . . . . . . 24-22
Datensätze aktualisieren. . . . . . . . . . . 24-22
Aktualisierungen eintragen . . . . . . . . . 24-23
Aktualisierungsfehler bereinigen . . . . 24-24
Daten aktualisieren. . . . . . . . . . . . . . 24-25
Mit Provider-Komponenten
kommunizieren . . . . . . . . . . . . . . . 24-25
Eine Client-Datenmenge mit unstrukturierten
Daten verwenden . . . . . . . . . . . . . . . 24-26
Eine neue Datenmenge erstellen . . . . . . 24-27
Daten aus einer Datei oder einem Stream
laden . . . . . . . . . . . . . . . . . . . . . 24-27
Änderungen in die Daten schreiben . . . . 24-27
Daten in einer Datei oder einem Stream
speichern . . . . . . . . . . . . . . . . . . 24-28
Kapitel 25
Zwischengespeicherte Aktualisierungen
25-1
Wann werden zwischengespeicherte
Aktualisierungen eingesetzt? . . . . . . . . . 25-1
Die Realisierung im Überblick. . . . . . . . . . 25-2
Die Zwischenspeicherung aktivieren und
deaktivieren . . . . . . . . . . . . . . . . . 25-3
Datensätze abrufen . . . . . . . . . . . . . . 25-4
Zwischengespeicherte Aktualisierungen
zurückschreiben . . . . . . . . . . . . . . . 25-4
Aktualisierungen mit Datenbank-
Komponenten eintragen. . . . . . . . . 25-5

Zurückschreiben bei Datenmengen-
komponenten. . . . . . . . . . . . . . . 25-6
Haupt/Detailtabellen aktualisieren . . . 25-7
Anstehende Aktualisierungen verwerfen . 25-8
Anstehende Aktualisierungen verwerfen
und die Zwischenspeicherung
deaktivieren. . . . . . . . . . . . . . . . 25-8
Nur anstehende Aktualisierungen
verwerfen . . . . . . . . . . . . . . . . . 25-8
Aktualisierungen am aktuellen Datensatz
verwerfen . . . . . . . . . . . . . . . . 25-9
Gelöschte Datensätze wiederherstellen . . . 25-9
Die Datensatztypen für die Datenmenge
festlegen . . . . . . . . . . . . . . . . . . 25-10
Aktualisierungsstatus prüfen . . . . . . . .25-11
Update-Objekte . . . . . . . . . . . . . . . . . 25-12
Die Eigenschaft UpdateObject einer
Datenmenge . . . . . . . . . . . . . . . . 25-12
Ein einzelnes Update-Objekt verwenden . . .
25-13
Mehrere Update-Objekte verwenden . 25-13
SQL-Anweisungen für Update-Komponenten
erstellen. . . . . . . . . . . . . . . . . . . 25-14
SQL-Anweisungen zur Entwurfszeit
erstellen . . . . . . . . . . . . . . . . . 25-15
Parameterersetzung in SQL-
Anweisungen. . . . . . . . . . . . . . 25-16
SQL-Anweisungen schreiben. . . . . . 25-17
Die Eigenschaft Query einer Update-
Komponente . . . . . . . . . . . . . . 25-18

Die Eigenschaften DeleteSQL, InsertSQL und
ModifySQL . . . . . . . . . . . . . . . 25-19
Update-Anweisungen ausführen . . . . . 25-20
Die Methode Apply . . . . . . . . . . . 25-20
Die Methode SetParams. . . . . . . . . 25-21
Die Methode ExecSQL . . . . . . . . . 25-21
xiv
Eine Datenmenge mit
Datenmengenkomponenten aktualisieren25-22
Schreibgeschützte Ergebnismengen
aktualisieren . . . . . . . . . . . . . . . . . . 25-23
Den Aktualisierungsvorgang steuern . . . . . 25-24
Wann muß der Aktualisierungsprozeß
überwacht werden? . . . . . . . . . . . . 25-24
Eine Ereignisbehandlungsroutine für
OnUpdateRecord erzeugen . . . . . . . . 25-25
Fehlerbehandlung . . . . . . . . . . . . . . . . 25-26
Referenz auf die betroffene Datenmenge . 25-27
Feststellen, wie der aktuelle Datensatz
geändert wurde. . . . . . . . . . . . . . . 25-27
Die durchzuführende Aktion festlegen . . 25-28
Eine Fehlermeldung definieren. . . . . . . 25-29
Die Feldeigenschaften OldValue, NewValue
und CurValue . . . . . . . . . . . . . . . . 25-29
Kapitel 26
Datensensitive Steuerelemente 26-1
Datensensitive Steuerelemente im Überblick . .26-1
Datensensitive Steuerelemente einer
Datenmenge zuordnen. . . . . . . . . . . .26-3
Daten bearbeiten und aktualisieren . . . . .26-3

Den Bearbeitungsmodus aktivieren . . .26-3
Daten in einem Steuerelement bearbeiten26-4
Die Datenanzeige aktivieren und
deaktivieren . . . . . . . . . . . . . . . . . .26-5
Datenanzeige aktualisieren . . . . . . . . . . 26-6
Maus-, Tastatur- und Timer-Ereignisse. . . .26-6
Datenquellen verwenden . . . . . . . . . . . . .26-6
TDataSource-Eigenschaften verwenden . . .26-7
Eigenschaft DataSet einstellen. . . . . . .26-7
Eigenschaft Name einstellen. . . . . . . .26-7
Eigenschaft Enabled einstellen . . . . . .26-8
Eigenschaft AutoEdit einstellen. . . . . .26-8
TDataSource-Ereignisse verwenden . . . . .26-8
Ereignis OnDataChange verwenden . . .26-8
Ereignis OnUpdateData verwenden . . . 26-9
Ereignis OnStateChange verwenden . . .26-9
Steuerelemente zur Darstellung eines einzelnen
Feldes . . . . . . . . . . . . . . . . . . . . . . 26-10
Felder als Beschriftung anzeigen . . . . . . 26-10
Feldinhalte in Eingabefeldern anzeigen und
bearbeiten . . . . . . . . . . . . . . . . . . 26-10
Textfelder in einem Memo-Steuerelement
anzeigen und bearbeiten. . . . . . . . . . 26-11
Text in einem RTF-Eingabefeld anzeigen und
bearbeiten . . . . . . . . . . . . . . . . . . 26-12
Grafikfelder in einem Bild-Steuerelement
anzeigen und bearbeiten . . . . . . . . . 26-12
Daten in Listen- und Kombinationsfeldern
anzeigen und bearbeiten . . . . . . . . . 26-13
Daten in Listenfeldern anzeigen und

bearbeiten . . . . . . . . . . . . . . . . 26-13
Daten in Kombinationsfeldern anzeigen und
bearbeiten . . . . . . . . . . . . . . . . 26-14
Daten in Lookup-Listen und -
Kombinationsfeldern anzeigen und
bearbeiten . . . . . . . . . . . . . . . . . 26-15
Listen, die auf Lookup-Feldern basieren26-15
Listen, die auf einer sekundären Datenquelle
basieren . . . . . . . . . . . . . . . . . 26-16
Eigenschaften von Lookup-Listen und
Lookup-Kombinationsfeldern . . . . 26-17
Inkrementelle Suche in Listen . . . . . 26-17
Boolesche Feldwerte und Kontrollfelder . 26-18
Feldwerte mit Optionsfeldern
einschränken . . . . . . . . . . . . . . . . 26-19
Daten mit TDBGrid anzeigen und bearbeiten 26-20
Gitter im Standardstatus verwenden . . . 26-21
Angepaßte Gitter erstellen . . . . . . . . . 26-21
Persistente Spalten – Grundlagen . . . 26-22
Quelle einer Spalteneigenschaft zur Laufzeit
festlegen. . . . . . . . . . . . . . . . . 26-23
Persistente Spalten erstellen . . . . . . 26-23
Persistente Spalten löschen . . . . . . . 26-24
Reihenfolge persistenter Spalten ändern26-24
Lookup-Spalte definieren . . . . . . . . 26-25
Auswahllistenspalte definieren . . . . 26-25
Schaltfläche in Spalte einfügen . . . . . 26-25
Spalteneigenschaften beim Entwurf
einstellen . . . . . . . . . . . . . . . . 26-26
Standardwerte einer Spalte

wiederherstellen . . . . . . . . . . . . 26-27
ADT- und Array-Felder anzeigen . . . . . 26-27
Gitteroptionen einstellen . . . . . . . . . . 26-29
Daten im Gitter bearbeiten . . . . . . . . . 26-30
Spaltenreihenfolge beim Entwurf ändern 26-31
Spaltenreihenfolge zur Laufzeit ändern . 26-31
Gitterdarstellung steuern . . . . . . . . 26-31
Zur Laufzeit auf Benutzeraktionen
reagieren . . . . . . . . . . . . . . . . . . 26-32
Gitter mit anderen datensensitiven
Steuerelementen erstellen . . . . . . . . . . 26-33
Navigation und Bearbeitung von
Datenmengen . . . . . . . . . . . . . . . . . 26-34
xv
Navigator-Schaltflächen ein- und
ausblenden . . . . . . . . . . . . . . . . . 26-35
Navigator-Schaltflächen zur Entwurfszeit
ein- und ausblenden . . . . . . . . . . 26-35
Navigator-Schaltflächen zur Laufzeit ein-
und ausblenden . . . . . . . . . . . . . 26-36
Hilfehinweise anzeigen . . . . . . . . . . . 26-37
Ein Navigator für mehrere Datenmengen . 26-37
Kapitel 27
Entscheidungskomponenten 27-1
Überblick . . . . . . . . . . . . . . . . . . . . . .27-1
Kreuztabellen. . . . . . . . . . . . . . . . . . . .27-2
Eindimensionale Kreuztabellen. . . . . . . .27-3
Mehrdimensionale Kreuztabellen . . . . . .27-3
Entscheidungskomponenten verwenden . . . . 27-3
Datenmengen und Entscheidungs-

komponenten . . . . . . . . . . . . . . . . . . .27-5
Entscheidungsdatenmengen mit TQuery
oder TTable erzeugen . . . . . . . . . . . . .27-6
Entscheidungsdatenmengen mit dem
Entscheidungsabfragen-Editor erzeugen . 27-6
Der Editor für Entscheidungsabfragen . .27-6
Eigenschaften von TDecisionQuery . . . . .27-7
Mit Entscheidungswürfeln arbeiten . . . . . . .27-8
Eigenschaften und Ereignisse. . . . . . . . . 27-8
Der Editor für den Entscheidungswürfel . .27-8
Dimensionseinstellungen anzeigen und
ändern . . . . . . . . . . . . . . . . . . .27-9
Grenzwerte für Dimensionen und
Zusammenfassungen . . . . . . . . . . .27-9
Gestaltungsoptionen anzeigen und
ändern . . . . . . . . . . . . . . . . . . . 27-10
Mit Entscheidungsquellen arbeiten . . . . . . 27-10
Eigenschaften und Ereignisse. . . . . . . . 27-10
Mit Entscheidungspivots arbeiten . . . . . . . 27-11
Eigenschaften von Entscheidungspivots. . 27-11
Entscheidungsgitter erstellen und verwenden 27-12
Entscheidungsgitter erstellen . . . . . . . . 27-12
Mit Entscheidungsgittern arbeiten . . . . . 27-12
Felder im Entscheidungsgitter öffnen und
schließen . . . . . . . . . . . . . . . . . . 27-13
Entscheidungsgitter reorganisieren. . . 27-13
Detaildaten in Entscheidungsgittern
anzeigen . . . . . . . . . . . . . . . . . . 27-13
Die Dimensionszahl in Entscheidungsgittern
begrenzen . . . . . . . . . . . . . . . . 27-13

Eigenschaften von Entscheidungsgittern . 27-14
Entscheidungsgraphen erstellen und
verwenden . . . . . . . . . . . . . . . . . . . 27-15
Entscheidungsgraphen erstellen. . . . . . 27-15
Mit Entscheidungsgraphen arbeiten . . . 27-15
Der Informationsgehalt von Entscheidungs-
graphen . . . . . . . . . . . . . . . . . . . 27-17
Entscheidungsgraphen gestalten . . . . . 27-17
Standardwerte für Entscheidungsgraphen
als Schablonen . . . . . . . . . . . . . 27-18
Reihen in Entscheidungsgraphen
gestalten. . . . . . . . . . . . . . . . . 27-19
Entscheidungskomponenten zur Laufzeit . . 27-20
Entscheidungspivots zur Laufzeit. . . . . 27-20
Entscheidungsgitter zur Laufzeit . . . . . 27-21
Entscheidungsgraphen zur Laufzeit . . . 27-21
Entscheidungskomponenten und Speicher-
verwaltung. . . . . . . . . . . . . . . . . . . 27-22
Maximalwerte für Dimensionen,
Zusammenfassungen und Zellen . . . . 27-22
Den Status der Dimensionen einstellen. . 27-22
Permanent ausgelagerte Dimensionen . . 27-23
Teil III
Verteilte Anwendungen entwickeln
Kapitel 28
CORBA-Anwendungen 28-1
CORBA-Anwendungen im Überblick . . . . . 28-2
Stubs und Skeletons. . . . . . . . . . . . . . 28-3
Smart Agents. . . . . . . . . . . . . . . . . . 28-3
Server-Anwendungen aktivieren . . . . . . 28-4

Dynamisches Binden von Schnittstellen
aufrufen. . . . . . . . . . . . . . . . . . . . 28-4
CORBA-Server schreiben . . . . . . . . . . . . 28-5
CORBA-Experten . . . . . . . . . . . . . . . 28-5
Objektschnittstellen definieren. . . . . . . . 28-6
Automatisch generierter Code. . . . . . . . 28-8
Server-Schnittstellen registrieren . . . . . . 28-9
Schnittstellen bei der Schnittstellenablage
registrieren . . . . . . . . . . . . . . . . 28-9
Schnittstellen beim Object Activation
Daemon registrieren . . . . . . . . . . .28-11
CORBA-Clients schreiben . . . . . . . . . . . 28-13
Stubs verwenden . . . . . . . . . . . . . . 28-13
Die dynamische Aufrufschnittstelle
verwenden . . . . . . . . . . . . . . . . . 28-14
Schnittstelle abrufen. . . . . . . . . . . 28-15
Schnittstellen mit der DII aufrufen. . . 28-15
CORBA-Anwendungen anpassen . . . . . . 28-17
xvi
Objekte in der Benutzeroberfläche
anzeigen . . . . . . . . . . . . . . . . . . . 28-17
CORBA-Objekte bereitstellen und
deaktivieren . . . . . . . . . . . . . . . . . 28-18
Client-Informationen an Server-Objekte
übergeben . . . . . . . . . . . . . . . . . . 28-18
CORBA-Anwendungen weitergeben . . . . . 28-18
Smart Agents konfigurieren. . . . . . . . . 28-19
Einen Smart Agent starten . . . . . . . . 28-20
ORB-Domänen konfigurieren . . . . . . 28-20
Smart Agents in verschiedenen lokalen

Netzwerken verbinden . . . . . . . . . 28-21
Kapitel 29
Internet-Server-Anwendungen 29-1
Terminologie und Standards . . . . . . . . . . .29-1
Bestandteile einer URL . . . . . . . . . . . .29-2
URI und URL . . . . . . . . . . . . . . . .29-3
Informationen in den Headern von HTTP-
Anforderungen . . . . . . . . . . . . . . . .29-3
HTTP-Server-Aktivitäten . . . . . . . . . . . . .29-3
Client-Anforderungen zusammenstellen . .29-4
Client-Anforderungen bedienen . . . . . . .29-4
Auf Client-Anforderungen antworten . . . .29-5
Web-Server-Anwendungen . . . . . . . . . . . .29-5
Arten von Web-Server-Anwendungen. . . . 29-6
ISAPI und NSAPI. . . . . . . . . . . . . .29-6
CGI-Programme . . . . . . . . . . . . . .29-6
Win-CGI-Programme. . . . . . . . . . . .29-6
Web-Server-Anwendungen erstellen. . . . .29-7
Das Web-Modul . . . . . . . . . . . . . . . . 29-7
Das Web-Anwendungsobjekt . . . . . . . . .29-8
Die Struktur einer Web-Server-Anwendung . .29-8
Der Web-Dispatcher . . . . . . . . . . . . . . . 29-10
Aktionen zum Dispatcher hinzufügen. . . 29-10
Anforderungsbotschaften verteilen . . . . 29-10
Aktionselemente . . . . . . . . . . . . . . . . . 29-11
Das Auslösen von Aktionselementen
festlegen . . . . . . . . . . . . . . . . . . . 29-11
Die Ziel-URL . . . . . . . . . . . . . . . 29-11
Der Anforderungsmethodentyp . . . . 29-12
Aktionselemente aktivieren und

deaktivieren . . . . . . . . . . . . . . . 29-12
Ein Standard-Aktionselement festlegen 29-13
Mit Aktionselementen auf
Anforderungsbotschaften antworten. . . 29-13
Die Antwort senden . . . . . . . . . . . 29-14
Mehrere Aktionselemente verwenden . 29-14
Auf Client-Anforderungsinformationen
zugreifen . . . . . . . . . . . . . . . . . . . . 29-14
Eigenschaften, die Header-Informationen zur
Anforderung enthalten . . . . . . . . . . 29-15
Eigenschaften, die das Ziel bezeichnen 29-15
Eigenschaften, die den Web-Client
beschreiben . . . . . . . . . . . . . . . 29-15
Eigenschaften, die auf den Zweck der
Anforderung hinweisen . . . . . . . . 29-16
Eigenschaften, die die erwartete Antwort
beschreiben . . . . . . . . . . . . . . . 29-16
Eigenschaften, die den Inhalt
beschreiben . . . . . . . . . . . . . . . 29-16
Der Inhalt von HTTP-Anforderungs-
botschaften . . . . . . . . . . . . . . . . . 29-17
HTTP-Anwortbotschaften erzeugen . . . . . 29-17
Den Antwort-Header füllen . . . . . . . . 29-17
Den Antwortstatus anzeigen . . . . . . 29-18
Auf eine erforderliche Client-Aktion
hinweisen . . . . . . . . . . . . . . . . 29-18
Die Server-Anwendung beschreiben . 29-18
Den Inhalt beschreiben . . . . . . . . . 29-19
Den Antwortinhalt festlegen . . . . . . . . 29-19
Die Antwort senden. . . . . . . . . . . . . 29-19

Den Inhalt von Antwortbotschaften
generieren . . . . . . . . . . . . . . . . . . . 29-20
Seitengeneratoren einsetzen . . . . . . . . 29-20
HTML-Vorlagen . . . . . . . . . . . . . 29-20
Vordefinierte HTML-transparente Tag-
Namen verwenden. . . . . . . . . . . 29-21
Die HTML-Vorlage definieren . . . . . 29-22
HTML-transparente Tags konvertieren 29-22
Seitengeneratoren und Aktions-
elemente. . . . . . . . . . . . . . . . . 29-22
Seitengeneratoren verketten . . . . . . 29-23
Datenbankinformationen in Antworten
integrieren . . . . . . . . . . . . . . . . . . . 29-24
Eine Sitzung zum Web-Modul hinzufügen 29-25
Datenbankinformationen in HTML
darstellen . . . . . . . . . . . . . . . . . . 29-25
Datenmengen-Seitengeneratoren
verwenden . . . . . . . . . . . . . . . 29-25
Tabellengeneratoren verwenden . . . . 29-26
Die Tabellenattribute festlegen . . . . . 29-26
Die Zeilenattribute festlegen . . . . . . 29-27
Die Spalten festlegen . . . . . . . . . . 29-27
Tabellen in HTML-Dokumente
einbetten . . . . . . . . . . . . . . . . . 29-27
xvii
Einen Datenmengen-Tabellengenerator
einrichten . . . . . . . . . . . . . . . . 29-28
Einen Abfrage-Tabellengenerator
einrichten . . . . . . . . . . . . . . . . 29-28
Server-Anwendungen testen . . . . . . . . . . 29-28

ISAPI- und NSAPI-Anwendungen testen . 29-29
Unter Windows NT testen . . . . . . . . 29-29
Mit einem Microsoft IIS-Server testen . 29-29
Unter MTS testen . . . . . . . . . . . . . 29-30
Mit einem Windows 95 Personal-Web-Server
testen . . . . . . . . . . . . . . . . . . . . 29-31
Mit Netscape Server 2.0 testen . . . . . 29-32
CGI- und Win-CGI-Anwendungen testen . 29-33
Den Server simulieren . . . . . . . . . . 29-33
Als DLL testen . . . . . . . . . . . . . . 29-33
Kapitel 30
Arbeiten mit Sockets 30-1
Dienste implementieren. . . . . . . . . . . . . .30-1
Was sind Dienstprotokolle? . . . . . . . . . .30-2
Mit Anwendungen kommunizieren . . .30-2
Dienste und Schnittstellen. . . . . . . . . . . 30-2
Typen von Socket-Verbindungen. . . . . . . . .30-3
Client-Verbindungen. . . . . . . . . . . . . .30-3
Empfangende Verbindungen . . . . . . . . .30-3
Server-Verbindungen . . . . . . . . . . . . .30-3
Die Sockets beschreiben. . . . . . . . . . . . . .30-4
Den Host beschreiben . . . . . . . . . . . . .30-4
Zwischen einem Host-Namen und einer IP-
Adresse wählen . . . . . . . . . . . . . .30-5
Schnittstellen verwenden . . . . . . . . . . .30-5
Socket-Komponenten . . . . . . . . . . . . . . .30-6
Client-Sockets. . . . . . . . . . . . . . . . . .30-6
Den gewünschten Server angeben . . . .30-6
Die Verbindung aufbauen . . . . . . . . .30-7
Informationen über die Verbindung

ermitteln . . . . . . . . . . . . . . . . . . .30-7
Die Verbindung beenden. . . . . . . . . .30-7
Server-Sockets . . . . . . . . . . . . . . . . .30-7
Die Schnittstelle angeben . . . . . . . . .30-8
Client-Anforderungen empfangen . . . .30-8
Verbindungen zu Clients aufbauen . . . .30-8
Informationen über Verbindungen
ermitteln . . . . . . . . . . . . . . . . . .30-8
Die Server-Verbindung beenden . . . . .30-9
Auf Socket-Ereignisse antworten . . . . . . . .30-9
Fehlerereignisse. . . . . . . . . . . . . . . . .30-9
Client-Ereignisse . . . . . . . . . . . . . . . 30-10
Server-Ereignisse . . . . . . . . . . . . . . . 30-10
Ereignisse bei empfangenden
Verbindungen . . . . . . . . . . . . . .30-11
Ereignisse bei Client-Verbindungen . . .30-11
Informationen über Socket-Verbindungen lesen
und schreiben . . . . . . . . . . . . . . . . . 30-12
Nicht-blockierende Verbindungen . . . . 30-12
Lese- und Schreib-Ereignisse . . . . . . 30-12
Blockierende Verbindungen . . . . . . . . 30-13
Verwenden von Threads bei blockierenden
Verbindungen . . . . . . . . . . . . . 30-13
Verwenden von TWinSocketStream . . 30-14
Client-Threads schreiben . . . . . . . . 30-14
Server-Threads schreiben . . . . . . . . 30-15
Teil IV
Benutzerdefinierte Komponenten
erzeugen
Kapitel 31

Die Komponentenentwicklung
im Überblick 31-1
Die Bibliothek visueller Komponenten . . . . . 31-1
Komponenten und Klassen . . . . . . . . . . . 31-2
Wie werden Komponenten erzeugt? . . . . . . 31-3
Vorhandene Steuerelemente modifizieren . 31-3
Fensterorientierte Steuerelemente erzeugen 31-4
Grafische Steuerelemente erzeugen . . . . . 31-4
Unterklassen von Windows-Steuerelementen
erzeugen . . . . . . . . . . . . . . . . . . . 31-5
Nichtvisuelle Komponenten erzeugen . . . 31-5
Was zeichnet Komponenten aus? . . . . . . . . 31-5
Abhängigkeiten vermeiden . . . . . . . . . 31-6
Eigenschaften, Ereignisse und Methoden . 31-6
Eigenschaften. . . . . . . . . . . . . . . . 31-6
Ereignisse . . . . . . . . . . . . . . . . . . 31-7
Methoden . . . . . . . . . . . . . . . . . . 31-7
Grafik kapseln . . . . . . . . . . . . . . . . . 31-8
Registrierung. . . . . . . . . . . . . . . . . . 31-8
Eine neue Komponente erzeugen . . . . . . . . 31-9
Der Komponentenexperte . . . . . . . . . 31-10
Eine Komponente manuell erzeugen . . . 31-12
Eine Unit erzeugen . . . . . . . . . . . 31-12
Die Komponente ableiten . . . . . . . . 31-12
Beispiel für die Ableitung einer
Komponente . . . . . . . . . . . . . . 31-13
Die Komponente registrieren. . . . . . 31-13
Komponenten vor der Installation testen . . 31-14
xviii
Kapitel 32

Objektorientierte Programmierung für
Komponentenentwickler 32-1
Neue Klassen definieren . . . . . . . . . . . . .32-2
Neue Klassen ableiten . . . . . . . . . . . . .32-2
Ändern der Voreinstellungen einer Klasse
zur Vermeidung von Wiederholung . .32-2
Einer Klasse neue Fähigkeiten
hinzufügen. . . . . . . . . . . . . . . . .32-3
Eine neue Komponentenklasse deklarieren .32-3
Vorfahren, Nachkommen und Klassen-
hierarchien . . . . . . . . . . . . . . . . . . . . 32-4
Zugriffssteuerung . . . . . . . . . . . . . . . . .32-4
Implementierungsdetails verbergen . . . . .32-5
Die Schnittstelle des Komponentenentwicklers
definieren . . . . . . . . . . . . . . . . . . .32-6
Die Laufzeit-Schnittstelle definieren . . . . .32-7
Die Entwurfszeit-Schnittstelle definieren . .32-7
Dispatch-Methoden . . . . . . . . . . . . . . . .32-8
Statische Methoden . . . . . . . . . . . . . .32-8
Virtuelle Methoden. . . . . . . . . . . . . . .32-9
Methoden überschreiben. . . . . . . . . .32-9
Dynamische Methoden. . . . . . . . . . 32-10
Abstrakte Klassenelemente . . . . . . . . . . . 32-10
Klassen und Zeiger . . . . . . . . . . . . . . . 32-11
Kapitel 33
Eigenschaften erstellen 33-1
Wozu dienen Eigenschaften? . . . . . . . . . . .33-1
Typen von Eigenschaften . . . . . . . . . . . . .33-2
Geerbte Eigenschaften als published
deklarieren . . . . . . . . . . . . . . . . . . . .33-3

Eigenschaften definieren . . . . . . . . . . . . .33-4
Die Deklaration von Eigenschaften . . . . .33-4
Interne Datenspeicherung. . . . . . . . . . .33-5
Direkter Zugriff. . . . . . . . . . . . . . . . .33-5
Zugriffsmethoden . . . . . . . . . . . . . . .33-6
Die Methode read. . . . . . . . . . . . . .33-7
Die Methode write . . . . . . . . . . . . .33-7
Standardwerte für Eigenschaften. . . . . . .33-8
Keinen Standardwert angeben . . . . . .33-8
Array-Eigenschaften erstellen . . . . . . . . . .33-9
Eigenschaften speichern und laden . . . . . . 33-10
Der Speicher- und Lademechanismus . . . 33-10
Standardwerte festlegen . . . . . . . . . . . 33-11
Was soll gespeichert werden? . . . . . . . . 33-12
Initialisieren nach dem Laden. . . . . . . . 33-12
Nicht als published deklarierte Eigenschaften
speichern und laden. . . . . . . . . . . . 33-13
Methoden zum Speichern und Laden von
Eigenschaftswerten erstellen . . . . . 33-13
Die Methode DefineProperties
überschreiben. . . . . . . . . . . . . . 33-14
Kapitel 34
Ereignisse erzeugen 34-1
Was sind Ereignisse? . . . . . . . . . . . . . . . 34-1
Ereignisse sind Methodenzeiger. . . . . . . 34-2
Ereignisse sind Eigenschaften . . . . . . . . 34-3
Ereignistypen sind Methodenzeigertypen . 34-3
Ereignisbehandlungstypen sind
Prozeduren . . . . . . . . . . . . . . . . 34-3
Ereignisbehandlungsroutinen sind optional 34-4

Die Standardereignisse implementieren . . . . 34-5
Standardereignisse identifizieren . . . . . . 34-5
Standardereignisse für alle
Steuerelemente . . . . . . . . . . . . . . 34-5
Standardereignisse für Standard-
Steuerelemente . . . . . . . . . . . . . . 34-6
Ereignisse sichtbar machen. . . . . . . . . . 34-6
Die Standard-Ereignisbehandlung ändern . 34-6
Eigene Ereignisse definieren. . . . . . . . . . . 34-7
Ereignisse auslösen . . . . . . . . . . . . . . 34-7
Zwei Arten von Ereignissen . . . . . . . 34-8
Den Typ der Behandlungsroutine definieren34-8
Einfache Benachrichtigungen . . . . . . 34-8
Ereignisspezifische Behandlungs-
routinen . . . . . . . . . . . . . . . . . . 34-8
Informationen von der Behandlungsroutine
zurückliefern . . . . . . . . . . . . . . . 34-9
Ereignisse deklarieren . . . . . . . . . . . . 34-9
Ereignisnamen beginnen mit »On« . . . 34-9
Ereignisse aufrufen . . . . . . . . . . . . . . 34-9
Kapitel 35
Methoden erzeugen 35-1
Abhängigkeiten vermeiden . . . . . . . . . . . 35-1
Methoden benennen . . . . . . . . . . . . . . . 35-2
Methoden schützen. . . . . . . . . . . . . . . . 35-3
Methoden, die als public deklariert sein
sollten . . . . . . . . . . . . . . . . . . . . . 35-3
Methoden, die als protected deklariert sein
sollten . . . . . . . . . . . . . . . . . . . . . 35-3
Abstrakte Methoden . . . . . . . . . . . . . 35-4

Methoden virtuell machen. . . . . . . . . . . . 35-4
Methoden deklarieren . . . . . . . . . . . . . . 35-4
xix
Kapitel 36
Grafiken in Komponenten 36-1
Überblick über die Grafikfunktionen . . . . . .36-1
Die Zeichenfläche . . . . . . . . . . . . . . . . .36-3
Mit Bildern arbeiten . . . . . . . . . . . . . . . .36-3
Mit einem Bild, einer Grafik oder einer
Zeichenfläche arbeiten . . . . . . . . . . . .36-4
Grafiken laden und speichern . . . . . . . .36-4
Paletten . . . . . . . . . . . . . . . . . . . . .36-5
Eine Palette für ein Steuerelement
definieren . . . . . . . . . . . . . . . . .36-5
Offscreen-Bitmaps . . . . . . . . . . . . . . . . .36-6
Offscreen-Bitmaps erzeugen und verwalten 36-6
Bitmaps kopieren. . . . . . . . . . . . . . . .36-7
Auf Änderungen reagieren . . . . . . . . . . . .36-7
Kapitel 37
Botschaftsbehandlung 37-1
Das Botschaftsbehandlungssystem . . . . . . . 37-1
Was enthält eine Windows-Botschaft? . . . .37-2
Botschaften verteilen. . . . . . . . . . . . . .37-2
Den Botschaftsfluß verfolgen . . . . . . . 37-3
Die Behandlung von Botschaften ändern . . . .37-3
Die Behandlungsmethode überschreiben . .37-4
Botschaftsparameter verwenden . . . . . . .37-4
Botschaften abfangen . . . . . . . . . . . . . 37-4
Neue Routinen zur Botschaftsbehandlung
erstellen . . . . . . . . . . . . . . . . . . . . . .37-5

Eigene Botschaften definieren. . . . . . . . .37-5
Einen Botschaftsbezeichner deklarieren . 37-6
Einen Botschafts-Record-Typ deklarieren 37-6
Eine neue Botschaftsbehandlungsmethode
deklarieren . . . . . . . . . . . . . . . . . .37-7
Kapitel 38
Komponenten zur Entwurfszeit
verfügbar machen 38-1
Komponenten registrieren . . . . . . . . . . . .38-1
Die Register-Prozedur deklarieren . . . . . .38-2
Die Prozedur Register implementieren . . .38-2
Die Komponenten angeben . . . . . . . . 38-3
Die Palettenseite angeben . . . . . . . . .38-3
Die Prozedur RegisterComponents
aufrufen . . . . . . . . . . . . . . . . . .38-3
Paletten-Bitmaps hinzufügen. . . . . . . . . . .38-4
Hilfe für Komponenten bereitstellen . . . . . .38-4
Die Hilfedatei erstellen . . . . . . . . . . . .38-4
Einträge erstellen . . . . . . . . . . . . . .38-5
Kontextsensitive Hilfe erstellen . . . . . 38-6
Hilfedateien für Komponenten
hinzufügen . . . . . . . . . . . . . . . . 38-7
Eigenschaftseditoren hinzufügen . . . . . . . . 38-7
Ableiten einer Eigenschaftseditor-Klasse . . 38-7
Die Eigenschaft als Text bearbeiten . . . . . 38-8
Den Eigenschaftswert anzeigen . . . . . 38-9
Den Eigenschaftswert angeben. . . . . . 38-9
Die Eigenschaft als Einheit bearbeiten . . 38-10
Editorattribute festlegen . . . . . . . . . . .38-11
Den Eigenschaftseditor registrieren . . . . 38-12

Komponenteneditoren hinzufügen . . . . . . 38-13
Einträge in das lokale Menü einfügen . . 38-13
Menüeinträge angeben . . . . . . . . . 38-14
Befehle implementieren . . . . . . . . . 38-14
Das Doppelklickverhalten ändern. . . . . 38-15
Zwischenablageformate hinzufügen . . . 38-15
Den Komponenteneditor registrieren . . . 38-16
Eigenschaftskategorien. . . . . . . . . . . . . 38-16
Eine Eigenschaft registrieren. . . . . . . . 38-17
Mehrere Eigenschaften gleichzeitig
registrieren . . . . . . . . . . . . . . . . . 38-18
Eigenschaftskategorieklassen . . . . . . . 38-18
Integrierte Eigenschaftskategorien. . . 38-18
Neue Eigenschaftskategorien ableiten. 38-19
Die Funktion IsPropertyInCategory. . . . 38-20
Komponenten in Packages compilieren . . . 38-20
Fehlerbeseitigung für benutzerdefinierte
Komponenten . . . . . . . . . . . . . . . . . 38-21
Kapitel 39
Vorhandene Komponenten
modifizieren 39-1
Die Komponente erstellen und registrieren . . 39-1
Die Komponentenklasse ändern . . . . . . . . 39-2
Den Konstruktor überschreiben . . . . . . . 39-2
Den neuen Standardwert für die Eigenschaft
festlegen . . . . . . . . . . . . . . . . . . . 39-3
Kapitel 40
Grafische Komponenten erzeugen 40-1
Die Komponente erzeugen und registrieren . . 40-1
Geerbte Eigenschaften als published

deklarieren . . . . . . . . . . . . . . . . . . . . 40-2
Grafische Funktionen hinzufügen . . . . . . . 40-3
Was soll gezeichnet werden?. . . . . . . . . 40-3
Den Eigenschaftstyp deklarieren. . . . . 40-3
Die Eigenschaft deklarieren . . . . . . . 40-4
xx
Die Implementierungsmethode
schreiben . . . . . . . . . . . . . . . . . . 40-4
Konstruktor und Destruktor überschreiben. 40-4
Voreingestellte Eigenschaftswerte
überschreiben . . . . . . . . . . . . . . . 40-5
Stift und Pinsel als published deklarieren . .40-5
Die Klassenfelder deklarieren . . . . . . .40-6
Die Zugriffseigenschaften deklarieren . .40-6
Untergeordnete Klassen initialisieren . .40-7
Eigenschaften untergeordneter Klassen
setzen. . . . . . . . . . . . . . . . . . . .40-8
Die Komponente zeichnen . . . . . . . . . .40-8
Letzte Korrekturen . . . . . . . . . . . . . . .40-9
Kapitel 41
Gitter anpassen 41-1
Die Komponente erzeugen und registrieren . .41-1
Geerbte Eigenschaften als published
deklarieren . . . . . . . . . . . . . . . . . . . .41-2
Die Initialisierungswerte ändern. . . . . . . . .41-3
Die Größe der Zellen ändern . . . . . . . . . . .41-4
Die Zellen füllen . . . . . . . . . . . . . . . . . .41-5
Das Datum festlegen . . . . . . . . . . . . . .41-5
Das interne Datum speichern . . . . . . .41-6
Auf den Tag, den Monat und das Jahr

zugreifen . . . . . . . . . . . . . . . . . .41-6
Die Anzahl der Tage im Monat
generieren . . . . . . . . . . . . . . . . .41-8
Den aktuellen Tag auswählen . . . . . . 41-10
Durch Monate und Jahre navigieren. . . . . . 41-10
Durch die Tage navigieren . . . . . . . . . . . 41-11
Die Markierung bewegen . . . . . . . . . . 41-11
Das Ereignis OnChange hinzufügen . . . . 41-12
Bewegung zu leeren Zellen verhindern . . 41-13
Kapitel 42
Datensensitive Steuerelemente
definieren 42-1
Ein Steuerelement zur Datensuche erzeugen . .42-2
Die Komponente erstellen und registrieren .42-2
Den Kalender als Nur-Lesen-Steuerelement
definieren . . . . . . . . . . . . . . . . . . .42-3
Die Eigenschaft ReadOnly hinzufügen. .42-3
Erforderliche Aktualisierungen zulassen 42-4
Die Datenverknüpfung hinzufügen . . . . .42-5
Das Klassenfeld deklarieren . . . . . . . .42-5
Die Zugriffseigenschaften deklarieren . .42-5
Beispiel für die Deklaration von
Zugriffseigenschaften. . . . . . . . . . .42-6
Die Datenverknüpfung initialisieren . . 42-6
Auf Datenänderungen antworten . . . . . . 42-7
Ein Bearbeitungselement erstellen . . . . . . . 42-8
Den Standardwert von FReadOnly ändern. 42-9
Maustasten- und Tastendruckbotschaften
behandeln . . . . . . . . . . . . . . . . . . 42-9
Auf Maustastenbotschaften antworten . 42-9

Auf Tastendruckbotschaften antworten 42-10
Die Datenverknüpfungsklasse des Feldes
aktualisieren . . . . . . . . . . . . . . . . .42-11
Die Methode Change ändern . . . . . . . 42-12
Die Datenmenge aktualisieren. . . . . . . 42-12
Kapitel 43
Dialogfelder als Komponenten 43-1
Die Komponentenschnittstelle definieren . . . 43-2
Die Komponente erstellen und registrieren . . 43-2
Die Komponentenschnittstelle erstellen . . . . 43-3
Die Unit des Formulars einfügen . . . . . . 43-3
Die Schnittstelleneigenschaften hinzufügen 43-3
Die Methode Execute hinzufügen . . . . . . 43-5
Die Komponente testen . . . . . . . . . . . . . 43-6
Teil V
COM-Anwendungen entwickeln
Kapitel 44
COM-Technologien im Überblick 44-1
COM als Spezifikation und
Implementierung. . . . . . . . . . . . . 44-2
COM-Erweiterungen . . . . . . . . . . . 44-2
Elemente einer COM-Anwendung . . . . . . . 44-3
COM-Schnittstellen . . . . . . . . . . . . . . 44-3
Die grundlegende COM-Schnittstelle
IUnknown . . . . . . . . . . . . . . . . 44-4
COM-Schnittstellenzeiger. . . . . . . . . 44-5
COM-Server . . . . . . . . . . . . . . . . . . 44-5
Hilfsklassen (CoClasses) und Klassen-
generatoren . . . . . . . . . . . . . . . . 44-6
In-Process-Server, Out-of-Process-Server

und Remote-Server . . . . . . . . . . . 44-7
Der Sequenzbildungsmechanismus
(Marshaling) . . . . . . . . . . . . . . . 44-8
COM-Clients . . . . . . . . . . . . . . . . . . 44-9
COM-Erweiterungen . . . . . . . . . . . . . . . 44-9
Automatisierungsserver und -Controller. 44-12
ActiveX-Steuerelemente . . . . . . . . . . 44-13
Typbibliotheken . . . . . . . . . . . . . . . 44-13
xxi
Der Inhalt der Typbibliotheken . . . . . 44-14
Erzeugen von Typbibliotheken . . . . . 44-14
Wann werden Typbibliotheken
eingesetzt? . . . . . . . . . . . . . . . . 44-15
Zugriff auf Typbibliotheken . . . . . . . 44-15
Die Vorteile von Typbibliotheken . . . . 44-16
Tools für Typbibliotheken . . . . . . . . 44-16
Active-Server-Seiten . . . . . . . . . . . . . 44-17
Active-Dokumente . . . . . . . . . . . . . . 44-17
Visuelle prozeßübergreifende Objekte . . . 44-18
Implementieren von COM-Objekten mit Hilfe der
Experten . . . . . . . . . . . . . . . . . . . . 44-18
Kapitel 45
Ein einfaches COM-Objekt erstellen 45-1
Das Erstellen eines COM-Objekts im Überblick45-1
Ein COM-Objekt entwerfen. . . . . . . . . . . . 45-2
Ein COM-Objekt mit dem COM-Objekt-Experten
entwerfen . . . . . . . . . . . . . . . . . . . . .45-2
Instantiierungstypen für COM-Objekte . . . . .45-3
Ein Threading-Modell auswählen . . . . . . . .45-3
Ein Objekt schreiben, das das freie Threading-

Modell unterstützt . . . . . . . . . . . . . .45-5
Ein Objekt schreiben, das das Apartment-
Threading-Modell unterstützt. . . . . . . .45-6
Ein COM-Objekt registrieren . . . . . . . . . . .45-6
Ein COM-Objekt testen . . . . . . . . . . . . . .45-7
Kapitel 46
Automatisierungs-Controller
erzeugen 46-1
Einen Automatisierungs-Controller durch
Importieren einer Typbibliothek erzeugen . .46-2
Ereignisse in einem Automatisierungs-
Controller verarbeiten . . . . . . . . . . . .46-3
Die Verbindung zu einem Server herstellen und
trennen . . . . . . . . . . . . . . . . . . . .46-3
Einen Automatisierungsserver über eine duale
Schnittstelle steuern . . . . . . . . . . . . .46-4
Einen Automatisierungsserver über eine
Dispatch-Schnittstelle steuern. . . . . . . .46-4
Beispiel: Ein Dokument mit Microsoft Word
drucken . . . . . . . . . . . . . . . . . . . .46-5
Schritt 1: Delphi für dieses Beispiel
vorbereiten. . . . . . . . . . . . . . . . . 46-5
Schritt 2: Die Typbibliothek von Word
importieren . . . . . . . . . . . . . . . .46-5
Schritt 3: Microsoft Word mit einer VTable-
oder einer Dispatch-Schnittstelle
steuern. . . . . . . . . . . . . . . . . . . 46-6
Schritt 4: Bereinigungsarbeiten. . . . . . 46-7
Weitere Informationen . . . . . . . . . . . . 46-8
Kapitel 47

Automatisierungsserver erstellen 47-1
Automatisierungsobjekte für eine Anwendung
erstellen . . . . . . . . . . . . . . . . . . . . . 47-1
Ereignisse in Ihrem Automatisierungsobjekt
verwalten. . . . . . . . . . . . . . . . . . . . . 47-3
Eigenschaften, Methoden und Ereignisse einer
Anwendung für die Automatisierung b
ereitstellen . . . . . . . . . . . . . . . . . . . . 47-3
Eine Eigenschaft für die Automatisierung
bereitstellen. . . . . . . . . . . . . . . . . . 47-3
Eine Methode für die Automatisierung
bereitstellen. . . . . . . . . . . . . . . . . . 47-4
Ein Ereignis für die Automatisierung
bereitstellen. . . . . . . . . . . . . . . . . . 47-5
Weitere Informationen . . . . . . . . . . . . 47-6
Eine Anwendung als Automatisierungsserver
registrieren . . . . . . . . . . . . . . . . . . . . 47-6
Einen In-Process-Server registrieren . . . . 47-6
Einen Out-of-Process-Server registrieren . . 47-6
Die Anwendung testen und Fehler entfernen . 47-7
Automatisierungsschnittstellen . . . . . . . . . 47-7
Duale Schnittstellen . . . . . . . . . . . . . . 47-7
Dispatch-Schnittstellen . . . . . . . . . . . . 47-8
Benutzerdefinierte Schnittstellen . . . . . . 47-9
Sequenzbildung für Daten (Marshaling) . . . 47-10
Automatisierungskompatible Typen . . . 47-10
Typeinschränkungen bei der automatischen
Sequenzbildung . . . . . . . . . . . . . . .47-11
Benutzerdefinierte Sequenzbildung. . . . .47-11
Kapitel 48

ActiveX-Steuerelemente erstellen 48-1
ActiveX-Steuerelemente erzeugen – Übersicht 48-1
Elemente eines ActiveX-Steuerelements . . 48-2
VCL-Steuerelement . . . . . . . . . . . . 48-2
Typbibliothek. . . . . . . . . . . . . . . . 48-3
Eigenschaften, Methoden und Ereignisse48-3
Eigenschaftenseite . . . . . . . . . . . . . 48-3
Ein ActiveX-Steuerelement entwerfen . . . . . 48-3
ActiveX-Steuerelemente aus VCL-Steuerelementen
erstellen . . . . . . . . . . . . . . . . . . . . . 48-4
ActiveX-Steuerelemente lizensieren . . . . . . 48-7
xxii
ActiveX-Steuerelemente auf der Basis eines VCL-
Formulars erstellen . . . . . . . . . . . . . . .48-8
Eigenschaften, Methoden und Ereignisse von
ActiveX-Steuerelementen . . . . . . . . . . . 48-10
Weitere Eigenschaften, Methoden und
Ereignisse hinzufügen . . . . . . . . . . . 48-11
So fügt Delphi Eigenschaften hinzu . . 48-11
So fügt Delphi Methoden hinzu. . . . . 48-12
So fügt Delphi Ereignisse hinzu. . . . . 48-12
Einfache Datenbindung mit der Typbibliothek
ermöglichen . . . . . . . . . . . . . . . . . 48-13
Einfache Datenbindung von ActiveX-
Steuerelementen im Delphi-Container
ermöglichen . . . . . . . . . . . . . . . . . 48-14
Eine Eigenschaftenseite für ein ActiveX-
Steuerelement erstellen . . . . . . . . . . . . 48-16
Eine neue Eigenschaftenseite erstellen. . . 48-16
Steuerelemente zu einer Eigenschaftenseite

hinzufügen . . . . . . . . . . . . . . . . . 48-17
Steuerelemente auf Eigenschaftenseiten mit
Eigenschaften von ActiveX-Steuerelementen
verbinden . . . . . . . . . . . . . . . . . . 48-17
Die Eigenschaftenseite aktualisieren . . 48-17
Das Objekt aktualisieren . . . . . . . . . 48-18
Eine Eigenschaftenseite mit einem ActiveX-
Steuerelement verbinden . . . . . . . . . 48-18
Eigenschaften eines ActiveX-Steuerelements als
published deklarieren . . . . . . . . . . . . . 48-19
ActiveX-Steuerelemente registrieren. . . . . . 48-20
ActiveX-Steuerelemente testen . . . . . . . . . 48-20
ActiveX-Steuerelemente im Web weitergeben 48-21
Optionen einstellen . . . . . . . . . . . . . 48-22
Optionen für Distribution über das Web,
Kontrollfeld Vorgabe . . . . . . . . . . 48-22
INF-Datei . . . . . . . . . . . . . . . . . 48-23
Optionskombinationen. . . . . . . . . . 48-23
Die Registerkarte Projekt . . . . . . . . . . 48-24
Die Registerkarte Packages . . . . . . . . . 48-25
Von diesem Projekt verwendete
Packages . . . . . . . . . . . . . . . . . 48-25
CAB-Optionen . . . . . . . . . . . . . . 48-25
VersionsInfo . . . . . . . . . . . . . . . . 48-25
Optionen für Verzeichnis und URL . . . 48-25
Die Registerkarte Zusätzliche Dateien . . . 48-26
Mit dem Projekt verbundene Dateien . 48-26
CAB-Optionen . . . . . . . . . . . . . . 48-26
VersionsInfo . . . . . . . . . . . . . . . . 48-26
Optionen für Verzeichnis und URL . . . 48-26

Kapitel 49
Eine Active-Server-Seite erstellen 49-1
Ein ASP-Objekt erstellen . . . . . . . . . . . . . 49-2
ASP-Objekte für In-Process- oder Out-of-
Process-Server erstellen. . . . . . . . . . . 49-3
Eine Anwendung als ASP-Objekt registrieren. 49-4
Einen In-Process-Server registrieren . . . . 49-4
Einen Out-of-Process-Server registrieren . . 49-4
Die ASP-Anwendung testen. . . . . . . . . . . 49-5
Kapitel 50
Mit Typbibliotheken arbeiten 50-1
Der Typbibliothekseditor. . . . . . . . . . . . . 50-3
Die Werkzeugleiste . . . . . . . . . . . . . . 50-4
Die Objektliste . . . . . . . . . . . . . . . . . 50-5
Die Statusleiste. . . . . . . . . . . . . . . . . 50-6
Registerkarten mit Typinformationen. . . . 50-6
Die Registerkarte Attribute . . . . . . . . 50-6
Die Registerkarte Text . . . . . . . . . . . 50-7
Die Registerkarte Flags . . . . . . . . . . 50-7
Typbibliotheksinformationen . . . . . . . . . . 50-8
Die Registerkarte Attribute für
Typbibliotheken . . . . . . . . . . . . . . . 50-8
Die Registerkarte Verwendet für
Typbibliotheken . . . . . . . . . . . . . . . 50-9
Die Registerkarte Flags für Typbibliotheken 50-9
Schnittstelleninformationen . . . . . . . . . . . 50-9
Die Registerkarte Attribute für
Schnittstellen . . . . . . . . . . . . . . . . . 50-9
Die Registerkarte Flags für Schnittstellen. 50-10
Schnittstellenelemente . . . . . . . . . . . 50-10

Schnittstellenmethoden . . . . . . . . . .50-11
Schnittstelleneigenschaften . . . . . . . 50-12
Die Registerkarte Parameter für
Eigenschaften und Methoden. . . . . 50-13
Dispatch-Typinformationen . . . . . . . . . . 50-15
Die Registerkarte Attribute für Dispatch-
Schnittstellen . . . . . . . . . . . . . . . . 50-16
Die Registerkarte Flags für Dispatch-
Schnittstellen . . . . . . . . . . . . . . . . 50-16
Dispatch-Elemente . . . . . . . . . . . . . 50-16
CoClass-Typinformationen . . . . . . . . . . 50-17
Die Registerkarte Attribute für CoClass-
Objekte . . . . . . . . . . . . . . . . . . . 50-17
Die Registerkarte Implementierung für CoClass-
Objekte . . . . . . . . . . . . . . . . . . . 50-18
Die Registerkarte Flags für CoClass-
Objekte . . . . . . . . . . . . . . . . . . . 50-18
Enumeration-Typinformationen . . . . . . . 50-19
xxiii
Die Registerkarte Attribute für Enum-
Objekte. . . . . . . . . . . . . . . . . . . . 50-19
Enum-Elemente. . . . . . . . . . . . . . . . 50-20
Alias-Typinformationen. . . . . . . . . . . . . 50-20
Die Registerkarte Attribute für Alias-
Objekte. . . . . . . . . . . . . . . . . . . . 50-20
Record-Typinformationen. . . . . . . . . . . . 50-21
Die Registerkarte Attribute für Record-
Objekte. . . . . . . . . . . . . . . . . . . . 50-21
Record-Elemente . . . . . . . . . . . . . . . 50-22
Union-Typinformationen . . . . . . . . . . . . 50-22

Die Registerkarte Attribute für Union-
Objekte. . . . . . . . . . . . . . . . . . . . 50-22
Union-Elemente . . . . . . . . . . . . . . . 50-23
Modul-Typinformationen . . . . . . . . . . . . 50-23
Die Registerkarte Attribute für Modul. . . 50-23
Modul-Elemente . . . . . . . . . . . . . . . 50-24
Modulmethoden . . . . . . . . . . . . . 50-24
Modulkonstanten . . . . . . . . . . . . . 50-24
Typbibliotheken erstellen . . . . . . . . . . . . 50-25
Gültige Typen. . . . . . . . . . . . . . . . . 50-25
Sichere Arrays. . . . . . . . . . . . . . . 50-27
Object-Pascal- oder IDL-Syntax
verwenden . . . . . . . . . . . . . . . . . . 50-27
Attribute-Spezifikationen . . . . . . . . 50-27
Schnittstellen-Syntax . . . . . . . . . . . 50-29
Syntax von Dispatch-Schnittstellen . . . 50-29
CoClass-Syntax . . . . . . . . . . . . . . 50-30
Enum-Syntax . . . . . . . . . . . . . . . 50-31
Alias-Syntax . . . . . . . . . . . . . . . . 50-31
Record-Syntax. . . . . . . . . . . . . . . 50-31
Union-Syntax . . . . . . . . . . . . . . . 50-32
Modul-Syntax . . . . . . . . . . . . . . . 50-32
Eine neue Typbibliothek erstellen . . . . . 50-33
Eine vorhandene Typbibliothek öffnen . . 50-33
Eine Schnittstelle hinzufügen . . . . . . . . 50-34
Eigenschaften und Methoden einer Schnittstelle
oder Dispatch-Schnittstelle hinzufügen . 50-34
Ein CoClass-Objekt hinzufügen . . . . . . 50-35
Eine Aufzählung zur Typbibliothek
hinzufügen . . . . . . . . . . . . . . . . . 50-35

Typinformationen speichern und
registrieren . . . . . . . . . . . . . . . . . 50-36
Aktualisierung durchführen
(Dialogfeld) . . . . . . . . . . . . . . . 50-37
Eine Typbibliothek speichern . . . . . . 50-37
Eine Typbibliothek aktualisieren . . . . 50-37
Eine Typbibliothek registrieren . . . . . 50-38
Eine IDL-Datei exportieren . . . . . . . 50-38
Typbibliotheken weitergeben . . . . . . . . . 50-38
Kapitel 51
MTS-Objekte erstellen 51-1
Komponenten von Microsoft Transaction
Server. . . . . . . . . . . . . . . . . . . . . . . 51-2
Anforderungen an eine MTS-Komponente. 51-4
Verwalten von Ressourcen durch Just-in-time-
Aktivierung und Ressourcen-Pooling . . . . 51-5
Just-in-time-Aktivierung . . . . . . . . . . . 51-5
Ressourcen-Pooling . . . . . . . . . . . . . . 51-6
Ressourcen freigeben . . . . . . . . . . . . . 51-6
Objekt-Pooling. . . . . . . . . . . . . . . . . 51-7
Auf den Objektkontext zugreifen . . . . . . 51-7
Unterstützung von Transaktionen in MTS . . . 51-8
Transaktionsattribute . . . . . . . . . . . . . 51-8
Der Objektkontext enthält das
Transaktionsattribut . . . . . . . . . . . . . 51-9
Statusbehaftete und statuslose Objekte . . 51-10
Aktivieren multipler Objekte zum Unterstützen
von Transaktionen. . . . . . . . . . . . . 51-10
MTS- oder client-gesteuerte Transaktionen.51-11
Vorteile von Transaktionen . . . . . . . . . 51-12

Zeitüberschreitung bei Transaktionen . . 51-12
Rollenbasierte Sicherheit . . . . . . . . . . . . 51-13
Ressourcenspender . . . . . . . . . . . . . . . 51-13
BDE-Ressourcenspender . . . . . . . . . . 51-14
Shared Property Manager . . . . . . . . . 51-14
Tips für die Verwendung des Shared
Property Managers. . . . . . . . . . . 51-15
Basis-Clients und MTS-Komponenten . . . . 51-16
Zugrundeliegende Technologien von MTS,
COM und DCOM . . . . . . . . . . . . . . . 51-17
Übersicht über die Erstellung von MTS-
Objekten . . . . . . . . . . . . . . . . . . . . 51-17
Den MTS-Objektexperten verwenden . . . . 51-17
Auswahl eines Threading-Modells für ein
MTS-Objekt. . . . . . . . . . . . . . . . . 51-18
MTS-Aktivitäten. . . . . . . . . . . . . . . 51-19
Setzen des Transaktionsattributs . . . . . . . 51-20
Objektreferenzen übergeben. . . . . . . . . . 51-21
Die Methode SafeRef verwenden . . . 51-21
Callbacks . . . . . . . . . . . . . . . . . 51-22
Ein Transaktionsobjekt auf der Client-Seite
einrichten . . . . . . . . . . . . . . . . . . . . 51-22
Ein Transaktionsobjekt auf der Server-Seite
einrichten. . . . . . . . . . . . . . . . . . . . 51-23
Fehlersuche und Testen von MTS-Objekten . 51-24