O l i v i e r D a h a n

Delphi 8pour .NET

Lu et approuvé parBorland France

Titre_Delphi8 01/07/04 11:17 Page 1

© Groupe Eyrolles, 2004

ISBN : 2-212-11309-9

Table des matières

Avant-propos

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Pourquoi ce livre ?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Structure de l’ouvrage

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

À qui s’adresse cet ouvrage ?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

P

ARTIE

I

Nouveautés Delphi et framework .NET

. . . . . . . . . . . . . . . . . . . . . . . . 7

CHAPITRE 1

Delphi pour .NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Delphi or not Delphi ?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Ce qui ne change pas

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Ce qui change

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Delphi et le framework .NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Les plus de Delphi

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Delphi.Livre Page XI Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NET

XII

Les différentes versions de Delphi

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Le nouvel EDI

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

L’installation de Delphi 8

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

CHAPITRE 2

La plate-forme .NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

.NET : une vision du futur ?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

L’architecture .NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Les bases de .NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Le CLR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24La BCL ou FCL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Les espaces de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25CIL, CLI, JITer et code managé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26Les fichiers PE - Portable Executable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Les métadonnées et la réflexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Assemblages et manifestes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Le ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32Quelques avantages de .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

CHAPITRE 3

Delphi sous .NET

vs

Delphi Win 32

. . . . . . . . . . . . . . . . . . . . . . . . . . 35

Généralités

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Le nouvel environnement de développement intégré

. . . . . . . . . . . . . . 37

Les nouveautés du langage

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

Ce qui n’est plus possible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46Les espaces de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48Unités et simulation de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50Nouveaux spécificateurs de visibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51Les champs de classe (static data) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51Les propriétés de classe (static properties) . . . . . . . . . . . . . . . . . . . . . . . . 52La surcharge des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Delphi.Livre Page XII Lundi, 28. juin 2004 5:17 17

Table des matières

XIII

CHAPITRE 4

Fondements du langage Delphi sous .NET

. . . . . . . . . . . . . . . . . 57

Les nouveautés du langage

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Les types imbriqués (nested types) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Classes scellées et abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Méthodes virtuelles finales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Les attributs personnalisés (custom attributes) . . . . . . . . . . . . . . . . . . . . . 60

Les types par valeur (value types) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

Les assistances de classe (class helpers) . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Les événements multicast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Les propriétés indexées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Version du compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

CHAPITRE 5

Delphi sous .NET – Aspects avancés

. . . . . . . . . . . . . . . . . . . . . . . 79

Les nouveautés du langage

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Le code non sécurisé (unsafe code) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Les exports non managés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Le Platform Invoke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

La gestion de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

La sérialisation

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Conclusion intermédiaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

Le portage des applications Win32

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

L’intérêt de passer en VCL.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Portage de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Portage d’applications VCL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

Utiliser la compilation conditionnelle pour maintenir la compatibilité . . 100

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

Delphi.Livre Page XIII Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NET

XIV

P

ARTIE

II

Réussir ses interfaces

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

CHAPITRE 6

Concevoir ses interfaces

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

La conception des IHM

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

VCL ou Windows Forms ?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

L’ergonomie des dialogues

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Le focus d’entrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Le focus dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

La dynamique du focus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Menu, options, boutons : grisé ou invisible ? . . . . . . . . . . . . . . . . . . . . . . 113

Échappement et Validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

Stratégie de placement et retaille automatique . . . . . . . . . . . . . . . . . . . . . 115

La gestion du presse-papiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

Les traitements longs

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

Le blocage de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Les bulles d’aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

CHAPITRE 7

La VCL.NET – Première migration d’une application Win32

137

Qu’est-ce que la VCL ?

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

La VCL sous .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

De Win32 à .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

Reprendre une application VCL Win32 . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

Migrer une application Win32

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

L’application de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

Migration étape 1 : contrôles sous Delphi 7 . . . . . . . . . . . . . . . . . . . . . . . 145

Migration étape 2 : Delphi pour .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

Fin de la migration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Delphi.Livre Page XIV Lundi, 28. juin 2004 5:17 17

Table des matières

XV

CHAPITRE 8

Les packages VCL.NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

Migration d’un composant

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

Le composant à migrer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

Étape 1 – Préparation sous Delphi 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

Étape 2 – Premier chargement sous Delphi .NET . . . . . . . . . . . . . . . . . . . 163

Étape 3 – Modification de l’icône . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

Étape 4 - Modification du package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

Étape 5 – Installation du composant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

Étape 6 – Vérification de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

Étape 7 – Chargement de l’application de test . . . . . . . . . . . . . . . . . . . . . 166

Les packages Delphi pour .NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

La motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

Les différents types de packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

Les fichiers des packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

Directives de compilation des packages . . . . . . . . . . . . . . . . . . . . . . . . . . 171

Installer un package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Équivalences des packages Win32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Unités implicitement liées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

Importation d’un contrôle Windows Forms

. . . . . . . . . . . . . . . . . . . . . 173

Le choix du composant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

Importation du contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

Compilation et installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Contrôle du composant importé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Les modèles de composant

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

Notre modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

Création et test du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

Enregistrement du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

Utilisation du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Suppression d’un modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Stockage des modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Delphi.Livre Page XV Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NET

XVI

CHAPITRE 9

Les Windows Forms

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

Présentation

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

Structure de la bibliothèque

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

Composants et contrôles

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

Le Compact Framework

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

Les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

Les contrôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

Les graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

Conclusion intermédiaire

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

La bibliothèque

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

Les contrôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

La classe Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

La gestion de la Culture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

La programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

P

ARTIE

III

La gestion des données

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

CHAPITRE 10

Les différents modes d’accès aux données VCL .NET

. . . . . . 207

Les données, matière première de l’application

. . . . . . . . . . . . . . . . . . 208

L’accès aux bases de données relationnelles

. . . . . . . . . . . . . . . . . . . . . . 209

Le BDE et le BDE.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

dbExpress.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

DataSnap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

Interbase Express (IBX.NET) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

MyBase (DataSnap Briefcase)

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

ADO.NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

Delphi.Livre Page XVI Lundi, 28. juin 2004 5:17 17

Table des matières

XVII

CHAPITRE 11

dbExpress.NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

L’accès unifié

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

La migration d’applications Win32 SQL Links . . . . . . . . . . . . . . . . . . . . 226

Architecture d’une application dbExpress.NET . . . . . . . . . . . . . . . . . . . . 227

Migration SQL Links/dbExpress.NET

. . . . . . . . . . . . . . . . . . . . . . . . . . 228

Les différences fondamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

La raison des performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

Un déploiement simplifié . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230

L’anti-gadget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230

dbExpress.NET - concepts clés

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

Fonctions de base d’un pilote SGBD-R . . . . . . . . . . . . . . . . . . . . . . . . . . 231

Les objets de base de dbExpress.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

Les pilotes fournis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

Les composants dbExpress.NET

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

TSQLConnection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

TSQLDataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

TSQLQuery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

TSQLStoredProc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

TSQLTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

TSQLMonitor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Navigation et mise à jour des données

. . . . . . . . . . . . . . . . . . . . . . . . . . 235

Un exemple en mode unidirectionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

Une application complète

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

Ouvrir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

Fermer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

Start Trans. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

Annuler Trans. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

Valider Trans. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

Appliquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

Conclusion

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

Delphi.Livre Page XVII Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NETXVIII

CHAPITRE 12

IBX.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

Logique d’accès aux données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

Accès aux données et aux schémas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

TIBDatabase, connexion à la base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

TIBTransaction, gestion des transactions . . . . . . . . . . . . . . . . . . . . . . . . . 249

TIBDataset, composant d’accès générique . . . . . . . . . . . . . . . . . . . . . . . . 252

TIBSQL, composant requête SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

Ressources mémoire et mode navigationnel . . . . . . . . . . . . . . . . . . . . . . . 256

TIBStoredProc, accès aux procédures stockées . . . . . . . . . . . . . . . . . . . . . 258

TIBDatabaseInfo, accès au schéma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

TIBSQLMonitor, tracer les requêtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

TIBExtract, extraction des métadonnées . . . . . . . . . . . . . . . . . . . . . . . . . . 260

TIBQuery et TIBTable, composants de compatibilité . . . . . . . . . . . . . . . . 260

TIBConnectionBroker, gestion de la charge . . . . . . . . . . . . . . . . . . . . . . . 261

TIBScript, exécution de scripts SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262

TIBSQLParser, analyse de scripts SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

TIBDatabaseINI, paramétrage runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

Les composants d’administration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

Propriétés communes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

TIBConfigService . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

TIBBackupService, TIBRestoreService . . . . . . . . . . . . . . . . . . . . . . . . . . 268

TIBValidationService, validation d’une base . . . . . . . . . . . . . . . . . . . . . . 271

TIBStatisticalService, informations sur une base . . . . . . . . . . . . . . . . . . . 272

TIBLogService, accès au fichier de log du serveur . . . . . . . . . . . . . . . . . . 273

TIBSecurityService, gestion des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . 274

TIBServerProperties, accès aux propriétés du serveur . . . . . . . . . . . . . . . 275

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

CHAPITRE 13

MyBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

MyBase, pour quelles applications ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

Delphi.Livre Page XVIII Lundi, 28. juin 2004 5:17 17

Table des matièresXIX

Une application avec MyBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

Le projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281La création de la table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281La réalisation de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284Pour conclure sur l’application MyBase . . . . . . . . . . . . . . . . . . . . . . . . . . 293

Les fonctions statistiques de MyBase (agrégats) . . . . . . . . . . . . . . . . . . 293

Exemple de champs agrégats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299

CHAPITRE 14

ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302Les fournisseurs de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304La classe Dataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306Représentation XML des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308Databinding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309Exemples de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326

CHAPITRE 15

Introduction au Borland Data Provider (BDP) . . . . . . . . . . . . . . . 327

Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

L’architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

Les assemblages BDP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

Borland.Data.Common . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330Borland.Data.Provider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330Borland.Data.Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330Borland.Data.Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330Borland.Data.* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

La connexion aux bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

Les transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333Les métadonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

L’exécution de code SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

Delphi.Livre Page XIX Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NETXX

CHAPITRE 16

Mise en œuvre du Borland Data Provider (BDP) . . . . . . . . . . . . 349

Une application minimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

La connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349Les commandes SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351L’adaptateur de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354Visualisation des tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355La mise en page de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357Les composants BDP utilisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358L’éditeur de la collection de tables du Dataset . . . . . . . . . . . . . . . . . . . . . 359L’éditeur de la collection de relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360Le code de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362Exécuter l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363Conclusion intermédiaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365

ADO.NET et BDP sous VCL.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365

TADONetConnector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367Référencer ADO.NET et le BDP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369Le code de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373

PARTIE IV

Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375

CHAPITRE 17

ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

L’architecture ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378

Les pages ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

Le code côté serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382Les contrôles côté serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383Les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384La gestion du dialogue client/serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385L’identification des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

Delphi.Livre Page XX Lundi, 28. juin 2004 5:17 17

Table des matièresXXI

Les services Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397

CHAPITRE 18

Programmer le Web – Configuration . . . . . . . . . . . . . . . . . . . . . . . . 399

Le serveur de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399

Microsoft IIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400

Cassini et CassiniEx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

Une démonstration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

La base de données exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

Le répertoire virtuel du serveur Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

Compiler l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406

Exécuter l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406

Conclusion intermédiaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410

La configuration d’un site ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411

Le format du fichier web.config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411

Démarrer un projet Web Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

Serveur Cassini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

Serveur IIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415

Premier test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

Structure du projet et compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419

CHAPITRE 19

Programmer le Web – Contrôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421

Les différents types de contrôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421

Les contrôles HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421

Les contrôles Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424

Utiliser le ViewState . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426

Session et persistance des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427

La persistance des données applicatives . . . . . . . . . . . . . . . . . . . . . . . . . . 428

La gestion des sessions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436

Delphi.Livre Page XXI Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NETXXII

CHAPITRE 20

Programmer le Web – Gestion des données . . . . . . . . . . . . . . . . 437

Les données et le Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437

Les composants Borland . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437Une grille de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439La modification des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442Relation maître/détail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447Déploiement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449La validation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450

Les contrôles utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453

Un premier exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454Une gestion de login . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462

CHAPITRE 21

Les Services Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463

La technologie et le concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463

XML-RPC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466WSDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467UDDI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467

La réalisation d’un client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468

Présentation du service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468Étape 1 – Création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468Étape 2 – Importation du fichier WSDL . . . . . . . . . . . . . . . . . . . . . . . . . . 469Étape 3 – Appel au service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471D’autres clients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473

La réalisation d’un serveur de service Web . . . . . . . . . . . . . . . . . . . . . . 474

Nature et technique des serveurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474L’application serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475Étape 1 – Création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475Étape 2 – Saisie du code du service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476Étape 3 – Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478Le client de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484

Delphi.Livre Page XXII Lundi, 28. juin 2004 5:17 17

Table des matièresXXIII

PARTIE V

Étendre Delphi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485

CHAPITRE 22

Packages, plug-ins et réflexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487

Qu’est-ce qu’un package ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487

La motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488

Réduire la taille du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488Englober un ensemble de composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489

Les différents types de packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489

Les fichiers des packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490

Installation des packages dans l’IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . 490

Créer vos propres packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492

L’éditeur de package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492La section Contient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493La section Requiert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493

La stratégie de conception des packages . . . . . . . . . . . . . . . . . . . . . . . . 493

Les packages de composants Design time et Runtime . . . . . . . . . . . . . . . 493L’enregistrement des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495

Les directives de compilation spécifiques aux packages . . . . . . . . . . . 497

Conventions de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497

Les packages dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498

Les divers types de plug-ins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499L’application exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513

CHAPITRE 23

Composants VCL.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515

Qu’est-ce qu’un composant ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515

Les grandes différences avec la programmation habituelle . . . . . . . . 516

La hiérarchie VCL ou savoir d’où partir… . . . . . . . . . . . . . . . . . . . . . . 517

Modèle de composant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519

Delphi.Livre Page XXIII Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NETXXIV

Les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520

Quels types pour les propriétés ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

Les spécificateurs de stockage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524

Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525

Les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526

La hiérarchie de classe de la VCL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530

La classe TComponent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532

État du composant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532

Style du composant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533

Composant propriétaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533

La notification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533

Les initialisations après lecture de flux . . . . . . . . . . . . . . . . . . . . . . . . . . . 535

Les autres classes importantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537

TControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537

TGraphicControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538

TWinControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539

TCustomControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541

Le processus de création d’un composant . . . . . . . . . . . . . . . . . . . . . . . 541

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543

CHAPITRE 24

Éditeur de propriétés et éditeur de composants . . . . . . . . . . . . 545

Les Tools API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546

L’espace de nommage Borland.Vcl.Design.DesignIntf . . . . . . . . . . . . . . . 546

L’espace de nommage Borland.Vcl.Design.VCLEditors . . . . . . . . . . . . . 552

L’espace de nommage Borland.Vcl.Design.DesignEditors . . . . . . . . . . . . 554

Les éditeurs de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555

Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555

Un premier exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556

Les interfaces et les comportements sophistiqués . . . . . . . . . . . . . . . . . . . 560

Pour conclure sur les éditeurs de propriétés . . . . . . . . . . . . . . . . . . . . . . . 565

Les catégories de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565

Delphi.Livre Page XXIV Lundi, 28. juin 2004 5:17 17

Table des matièresXXV

Les éditeurs de composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567

Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567

Un éditeur de composants complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575

PARTIE VI

Réussir ses projets Delphi .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577

CHAPITRE 25

Conseils de mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579

Lisibilité du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580

Normalisation du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581

Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584

Traitements génériques et variables globales . . . . . . . . . . . . . . . . . . . . 585

L’initialisation des Globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586

Le traitement des structures dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . 587

Utiliser les propriétés dans les fiches . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590

La méthode de la fonction appelante . . . . . . . . . . . . . . . . . . . . . . . . . . . 592

Le cas général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

Les fiches de sélection de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595

L’externalisation des traitements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596

Administrer une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598

La gestion centralisée des logs et des erreurs d’exécution . . . . . . . . . . 599

La gestion des logs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600

Le suivi des erreurs d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601

L’utilisateur Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602

Gérer les accès à l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602

Prévoir les traitements génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604

Delphi.Livre Page XXV Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NETXXVI

CHAPITRE 26

Imprimer sous .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

Imprimer via le framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

Les principales classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

Imprimer un texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606

Le choix de l’imprimante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609

Paramétrer les pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610

Prévisualiser un document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611

Rave Reports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613

Qu’est-ce que Rave Reports ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613

Une première approche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613

Les composants (concepteur Rave) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615

Les formats de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621

La connexion aux données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622

La création d’un état par les experts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623

Gérer les états dans un projet Delphi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624

Utilisation avancée de Rave Reports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624

Report Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628

CHAPITRE 27

UML et les design patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629

UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629

Finalité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630

Bref historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630

Définitions des diagrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631

Terminologie de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632

Les diagrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635

Les design patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648

Le formalisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649

Les design patterns et Delphi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649

Catalogue de design patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650

D’autres design patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668

Delphi.Livre Page XXVI Lundi, 28. juin 2004 5:17 17

Table des matièresXXVII

CHAPITRE 28

ECO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669

Qu’est-ce qu’ECO ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669

Comprendre par l’exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670

Débuter un projet ECO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670Créer un modèle ECO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672Créer l’interface de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676Exécuter l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677La persistance des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678Le mode d’édition Auto Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679

Améliorer l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681

Suppression de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681Les relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682Les bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686

PARTIE VII

Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687

ANNEXE 1

Glossaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689

ANNEXE 2

Types de données .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699

Types standards .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699

ANNEXE 3

Les espaces de nommage du framework . . . . . . . . . . . . . . . . . . . 701

ANNEXE 4

Les codes culture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707

Delphi.Livre Page XXVII Lundi, 28. juin 2004 5:17 17

Delphi 8 pour .NETXXVIII

ANNEXE 5

Migration depuis une application VisualCLX . . . . . . . . . . . . . . . . 715

Les étapes d’une migration VisualCLX Windows vers VCL .NET . . . . 716

Les tests de compatibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716

Renommer les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716

Modifier les références aux unités QT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717

Changer les références aux ressources fiches . . . . . . . . . . . . . . . . . . . . . . 717

Ouvrir le projet sous Delphi 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717

Passage sous Delphi 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718

ANNEXE 6

Déploiement et utilitaires framework . . . . . . . . . . . . . . . . . . . . . . . . 719

Deploy.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719

Installation dans le cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719

Désassemblage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720

Exploration d’exécutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720

Signature électronique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 721

Obfuscation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722

ANNEXE 7

Contenu du CD-Rom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725

Installation du CD-Rom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725

Processus manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726

Les exemples du livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726

Bonus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731

Conférence Borland (BorCon) 2003 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731

MK Query Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731

DSP 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731

Sons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733

Delphi.Livre Page XXVIII Lundi, 28. juin 2004 5:17 17