RAD Studio

Copyright© 2008 Embarcadero Technologies, Inc. Tous droits réservés.

 RAD Studio

Sommaire

Concepts 1
Débogage d'applications C++ avec les rapports d'erreurs CodeGuard 3
Erreurs CodeGuard 3
Erreurs d'accès 4
Erreurs d'exceptions 5
Erreurs d'échec de fonction 6
Erreurs de ressources 7
Présentation de CodeGuard 9
Avertissements CodeGuard 10
Avertissements pour la comparaison de blocs mémoire 11
Avertissements sur la fusion et la scission de noms de chemins 11
Avertissements de comparaison de chaînes 12

Développement d'applications de bases de données pour la plate-forme Win32 13

Présentation de dbGo 14
Présentation de BDE 15
Composants dbExpress 16
Introduction à InterBase Express 17
Présentation des nouvelles fonctionnalités de dbExpress 4 22
Présentation de la migration BDP 26
Concepteurs de composants ADO.NET 30
Déploiement d'applications de bases de données pour le .NET Framework 33
Framework dbExpress 35
Compatibilité du framework dbExpress 37

Développement des applications interopérables 39

Développement d'applications COM 39

Développement d'états pour vos applications Win32 45

Utilisation de Rave Reports dans RAD Studio 45

Développement d'applications avec des composants VCL 46

Présentation de la VCL 46
Utilisation de TEncoding pour les fichiers Unicode 48

Développement d'applications Web avec WebSnap 51

Présentation des applications Web Win32 51

Développement de services Web avec des applications Win32 54

iii
 RAD Studio

Présentation des services Web 54

Développement d'applications Windows 55

Présentation de Windows 55

Procédures 57
Procédures CodeGuard 58
Utilisation de CodeGuard 58

Procédures de bases de données 60

Accès aux informations de schéma 61
Configuration d'une connexion TSQL 62
Connexion au serveur d'applications à l'aide de composants DataSnap 64
Débogage d'applications dbExpress à l'aide de TSQLMonitor 65
Exécution des commandes à l'aide de TSQLDataSet 65
Récupération des données à l'aide de TSQLDataSet 67
Spécification des données à afficher à l'aide de TSQLDataSet 68
Spécification du fournisseur à l'aide d'un composant TLocalConnection ou TConnectionBroker 69
Utilisation du BDE 70
Utilisation de DataSnap 70
Utilisation de TBatchMove 71
Connexion aux bases de données avec TDatabase 72
Utilisation de TQuery 73
Utilisation de TSQLQuery 75
Utilisation de TSQLStoredProc 76
Utilisation de TSQLTable 77
Gestion des sessions de bases de données avec TSession 78
Utilisation de TSimpleDataSet 78
Utilisation de TSimpleObjectBroker 79
Utilisation de TStoredProc 80
Utilisation de TTable 81
Utilisation de TUpdateSQL pour mettre à jour un ensemble de données 83
Utilisation de dbExpress 83
Utilisation de l'explorateur de données pour obtenir des informations de connexion 84

Procédures d'applications interopérables 86

Utilisation des experts COM 86

Procédures de génération d'états 88

Ajout de Rave Reports à RAD Studio 88

iv
 RAD Studio

Procédures VCL 89
Construction d'une application console "Hello World" Windows 96
Développement d'une application Windows 97
Construction des menus d'applications 97
Construction d'une application Fiches VCL avec des composants d'aide à la décision 99
Construction d'applications Fiches VCL avec graphiques 101
Construction d'une application MDI Fiches VCL à l'aide d'un expert 101
Construction d'une application MDI Fiches VCL sans utiliser d'expert 102
Construction d'une application SDI Fiches VCL 104
Création d'un nouveau composant VCL 105
Conception d'une application Fiches VCL de base de données ADO 106
Construction d'une application Fiches VCL 108
Création d'actions dans une application Fiches VCL 108
Construction d'une application Fiches VCL "Hello World" 109
Utilisation de ActionManager pour créer des actions dans une application Fiches VCL 110
Conception d'une application Fiches VCL de base de données dbExpress 111
Construction d'une application avec des composants XML 113
Copie de données d'un flux vers un autre 115
Copie de la totalité d'une liste de chaînes 116
Création de chaînes 118
Création d'une instance de fiche VCL en utilisant une variable locale 119
Suppression de chaînes 121
Affichage d'une fiche VCL créée automatiquement 122
Affichage d'une image bitmap dans une application Fiches VCL 124
Affichage d'une image bitmap plein écran dans une application Fiches VCL 125
Dessin d'un polygone dans une application Fiches VCL 126
Dessin de rectangles et d'ellipses dans une application Fiches VCL 127
Dessin d'un rectangle arrondi dans une application Fiches VCL 128
Dessin de lignes droites dans une application Fiches VCL 128
Création dynamique d'une fiche VCL modale 129
Création dynamique d'une fiche VCL non modale 131
Parcours des chaînes d'une liste 132
Construction d'une application multithread 134
Ecriture du code de nettoyage 134
Eviter les accès de threads simultanés dans la même mémoire 134
Définition de l'objet thread 136
Gestion des exceptions 139
Initialisation d'un thread 139
Utilisation du thread VCL principal 140

v
 RAD Studio

Attente des threads 142

Ecriture de la fonction Thread 144
Insertion d'une image bitmap dans un contrôle d'une application Fiches VCL 144
Lecture d'une chaîne et écriture de cette chaîne dans un fichier 145
Renommage de fichiers 146
Ajout et tri de chaînes 147
Création d'un bouton ActiveX Fiches VCL 148
Création d'une fiche active VCL ActiveX 150
Construction d'une application de navigateur Web Fiches VCL 151
Création d'une application qui utilise les contrôles ruban 152
Ajout de commandes au ruban 153

Procédures WebSnap 157

Construction d'une application WebSnap 157
Construction d'une application "Hello world" WebSnap 158
Débogage d'une application WebSnap à l'aide du débogueur d'application Web 160

Procédures de services Web 162

Construction d'une application de services Web "Hello World" 162
Accès à une application services Web "Hello World" 164
Construction d'une application de services Web "Hello World" ASP.NET 165

Référence 167
Référence C++ 168
Utilitaires en ligne de commande 168
BCC32, le compilateur C++ en ligne de commande 171
BRC32, le Shell de ressources 176
BRCC32.EXE, le compilateur de ressources 177
COFF2OMF.EXE, l'outil de conversion d'une bibliothèque d'importation 178
CPP32.EXE, le préprocesseur du compilateur C 179
DCC32.EXE, le compilateur en ligne de commande Delphi. 181
DCCIL.EXE, le compilateur en ligne de commande Delphi pour .NET 183
GREP.EXE, l'utilitaire de recherche de texte 184
ILINK32.EXE, le lieur incrémentiel 189
IMPDEF.EXE, le gestionnaire de définition de module 194
IMPLIB.EXE, l'outil bibliothèque d'importation 196
Utilisation des fichiers d'inclusion 197
MAKE 198
Directives MAKE 201
Macros MAKE 206

vi
 RAD Studio

Commandes et règles (explicites et implicites) de MAKE 208

Options des messages 212
Fichiers de définition de module 214
Fichiers en-tête précompilés 219
RLINK32.DLL, le lieur de ressources (C++) 220
TDUMP.EXE, l'utilitaire de vidage de fichier 221
TLIB.EXE, le gestionnaire de bibliothèques 224
Utilisation de TOUCH.EXE 227
TRIGRAPH 228
Liste de tous les avertissements et erreurs du compilateur C++ 229
E2066: Héritage MOM invalide 272
E2525: Vous devez définir _PCH_STATIC_CONST avant d'inclure xstring afin d'utiliser cette fonctionnalité 272
E2526: La propriété 'nom' utilise une autre propriété comme getter/setter ; non autorisé 272
E2008: Les fonctions d'accès à la propriété publiée doivent utiliser la convention d'appel __fastcall 272
E2122: L'appel de fonction s'est terminé par une exception non gérée 'valeur' à l'adresse 'adresse' 273
E2506: La spécialisation explicite de 'spécificateur' est ambiguë : des arguments modèles doivent être 273
spécifiés
E2483: La dimension du tableau 'spécificateur' n'a pas pu être déterminée 273
E2509: Valeur hors limites 273
E2510: Non concordance de taille d'opérande 273
E2050: La classe __declspec(delphireturn) 'classe' doit avoir exactement une donnée membre 273
E2530: Option non reconnue ou aide indisponible 274
E2527: L'option 'nom' ne peut pas être définie via 'nom' 274
E2528: L'option 'nom' doit être définie avant la compilation 274
E2074: La valeur après -g ou -j doit être comprise entre 0 et 255 inclus 274
E2492: Les propriétés peuvent uniquement être affectées en utilisant une instruction simple, par exemple 274
\"prop = valeur;\"
E2505: L'instanciation explicite requiert un spécificateur de type élaboré (par exemple, "class foo<int>") 275
E2100: Liste de déclarateurs de modèles incorrecte 275
E2102: Impossible d'utiliser le modèle 'modèle' sans spécifier des paramètres de spécialisation 275
E2107: Utilisation incorrecte du modèle 'modèle' 275
E2105: Le qualificateur 'modèle' doit spécifier un nom de modèle membre 276
E2066: Information non disponible 276
E2471: pragma checkoption a échoué : les options ne sont pas celles attendues 276
E2504: 'dynamic' ne peut être utilisé qu'avec des fonctions membre non modèle 277
E2191: '__far16' ne peut être utilisé qu'avec '__pascal' ou '__cdecl' 277
E2199: La fonction amie modèle 'fonction' doit être préalablement déclarée 277
E2502: Erreur de résolution de #import : problème 277
E2501: Impossible d'ouvrir le fichier d'importation 'nom_fichier' 278
E2494: Modificateur __declspec non reconnu 278

vii
 RAD Studio

E2493: Chaîne GUID incorrecte 278

E2499: Format __declspec(uuid(GuidString)) non valide 278
E2496: Appel non valide à uuidof(struct type|variable) 278
E2511: Argument de macro non terminé 278
E2489: Profondeur maximum de répétitions d'options dépassée ; vérifiez la récursivité 279
E2488: Profondeur maximum de réponse dépassée ; vérifiez la récursivité 279
E2491: Compte VIRDEF maximum dépassé ; vérifiez la récursivité 279
E2230: L'initialisation de données membre en ligne nécessite une expression constante intégrale 279
E2241: Les classes de style VCL ont besoin de destructeurs virtuels 279
E2524: Les unions/structs anonymes ne sont pas autorisées à avoir des membres anonymes en C++ 280
E2246: x n'est pas une hiérarchie de classes d'héritage simples, publiques, abstraites sans données 280
E2249: = attendu 280
E2267: La première base doit être une classe VCL 280
E2472: Impossible de déclarer une fonction membre via une instanciation 280
E2515: Impossible de spécialiser explicitement un membre d'une classe modèle générique 281
E2474: 'fonction' ne peut pas être déclarée comme static ou inline 281
E2498: Définition préalable de la structure du GUID requise 281
E2295: Trop de spécialisations de modèle candidat depuis 'spécificateur' 282
E2475: 'fonction' ne peut pas être une fonction modèle 282
E2299: Impossible de créer une spécialisation de modèle à partir de 'spécificateur' 282
E2300: Impossible de générer un type correspondant de spécialisation pour 'spécificateur' 282
E2497: Aucun GUID associé au type 'type' 282
E2522: Fonction non const 'fonction' appelée pour un objet const 283
E2523: Fonction non volatile 'nom' appelée pour un objet volatile 283
E2513: Impossible d'émettre des informations RTTI pour 'paramètre' dans 'fonction' 283
E2512: Impossible d'émettre des informations RTTI pour le type renvoyé par 'fonction' 283
E2507: 'classe' n'est pas une classe de base directe de 'classe' 283
E2529: Le chemin 'chemin' dépasse la taille maximale 'n' 283
E2495: Redéfinition de uuid non identique 283
E2500: __declspec(selectany) ne s'adresse qu'aux variables initialisées et visibles de façon externe 284
E2482: Constante chaîne attendue 284
E2481: Constante chaîne inattendue 284
E2386: Impossible d'impliquer le paramètre 'paramètre' dans une expression de spécialisation partielle 284
complexe
E2387: Les spécialisations partielles ne peuvent pas spécialiser les paramètres dépendants non-typés 284
('paramètre')
E2388: La liste d'arguments de spécialisation ne peut pas être identique à la liste de paramètres de 284
modèle primaire
E2389: Non concordance dans le type d'argument de substitution et le paramètre modèle 'paramètre' 285

viii
 RAD Studio

E2480: Impossible d'impliquer des paramètres de modèle dans les arguments de spécialisation partielle 285
complexe
E2392: L'instance du modèle 'template' est déjà instanciée 285
E2393: Impossible de prendre l'adresse du paramètre modèle non-typé, non-référencé 'paramètre' 286
E2399: Impossible de référencer de cette façon l'argument 'arg' du modèle dans la classe modèle 'classe' 286
E2397: L'argument du modèle ne peut pas avoir une liaison statique ou locale 286
E2485: Impossible d'utiliser l'élément adresse de tableau comme un argument de modèle non typé 286
E2402: Type de classe de base incorrect : type formel 'type' résolu en 'type' 286
E2403: Le spécificateur d'appel dépendant produit une non-fonction 'nom' 287
E2404: Le qualificateur de type dépendant 'qualificateur' n'a aucun type membre nommé 'nom' 287
E2405: La référence de modèle dépendante 'identificateur' fournit un symbole non modèle 287
E2406: Le qualificateur de type dépendant 'qualificateur' n'est pas un type class ou struct 287
E2407: Le qualificateur de type dépendant 'qualificateur' n'a aucun symbole membre nommé 'nom' 288
E2408: Les valeurs par défaut doivent être spécifiées seulement dans les déclarations de modèle de 288
classe primaire
E2409: Impossible de trouver une spécialisation correcte pour 'spécificateur' 288
E2410: Paramètres de modèle manquants pour le modèle ami 'modèle' 288
E2486: Impossible d'utiliser l'adresse du membre de classe comme un argument de modèle non typé 288
E2411: La déclaration des paramètres par défaut d'une fonction membre après une spécialisation a déjà 289
été développée
E2412: Tentative de lier une référence membre à un type dépendant 289
E2414: Les destructeurs ne peuvent pas être déclarés comme fonctions modèles 289
E2473: Spécialisation explicite de 'spécificateur' incorrecte 289
E2490: Spécialisation dans des classes modèle non encore implémentées 289
E2416: Déclaration de fonction modèle incorrecte 290
E2417: Impossible de spécifier des paramètres de modèle dans la spécialisation explicite de 'spécificateur' 290
E2418: Profondeur d'instanciation maximum dépassée ; vérifiez la récursivité 290
E2420: Une instanciation explicite ne peut être utilisée que sur l'étendue globale 290
E2422: Le type d'argument ne correspond pas dans la redéclaration du paramètre modèle 'paramètre' 290
E2423: Spécialisation ou instanciation explicite d'un modèle non existant 'modèle' 291
E2479: Impossible d'avoir à la fois une classe modèle et une fonction appelée 'nom' 291
E2484: Le nom de la classe modèle 'classe' ne peut pas être surchargé 291
E2426: La spécialisation explicite de 'spécificateur' nécessite une déclaration 'template<>' 291
E2487: Impossible de spécifier des arguments de fonction par défaut pour des spécialisations explicites 291
E2427: 'main' ne peut pas être une fonction modèle 292
E2429: Ce n'est pas une spécialisation partielle correcte de 'spécificateur' 292
E2430: Le nombre de paramètres de modèles ne correspond pas dans la redéclaration de 'spécificateur' 292
E2477: Trop peu de paramètres de modèle ont été déclarés pour le modèle 'modèle' 292
E2478: Trop de paramètres de modèle ont été déclarés pour le modèle 'modèle' 292
E2431: Les paramètres de modèle non-typé ne peuvent pas être de type virgule flottante, classe ou void 293

ix
 RAD Studio

E2434: Les paramètres de modèle manquent dans la déclaration de modèle ('template<...>') 293
E2435: Trop d'ensembles de paramètres de modèles ont été spécifiés 293
E2436: Le type par défaut de l'argument modèle 'arg' ne nomme pas une classe modèle primaire 293
E2437: 'typename' doit être suivi par un nom de type dépendant qualifié 293
E2438: Les arguments du modèle template doivent nommer une classe 294
E2439: 'typename' n'est autorisé que dans les déclarations modèle 294
E2440: Impossible de créer une spécialisation depuis 'spécificateur' car ce type n'est pas encore défini 294
E2441: Instanciation de 'spécificateur' 294
E2503: Version manquante ou incorrecte de TypeLibImport.dll 294
E2470: Il faut inclure l'en-tête <typeinfo> pour utiliser typeid 294
E2514: Impossible (pour le moment) d'utiliser la résolution des surcharges de membre pendant 295
l'instanciation de modèle
E2508: 'using' ne peut pas faire référence à une spécialisation de modèle 295
E2462: 'virtual' ne peut être utilisé qu'avec des fonctions membre non modèle 295
W8086: Utilisation incorrecte de l'alias #pragma "NomAlias"="NomSubstitué" 295
W8099: main statique n'est pas traité comme un point d'entrée 296
W8093: Utilisation incorrecte de #pragma codeseg [nom_seg] ["classe_seg"] [groupe] 296
W8094: Utilisation incorrecte de #pragma comment( <type> [,"chaîne"] ) 296
W8085: Fonction 'fonction' redéfinie comme non-en ligne 296
W8105: Membre %s '%s' dans la classe sans constructeur 297
W8095: Utilisation incorrecte de #pragma message( "chaîne" ) 297
W8098: Constante caractère multicaractère 297
W8096: Utilisation incorrecte de #pragma code_seg(["nom_seg"[,"classe_seg"]]) 297
W8083: Pragma pack pop sans pack push correspondant 297
W8097: Toutes les options ne peuvent pas être restaurées pour l'instant 298
W8084: Nous suggérons des parenthèses pour clarifier la priorité 298
W8092: L'argument 'type' 'spécificateur' transmis à 'fonction' n'est pas un itérateur : itérateur 'type' requis 298
W8087: 'opérateur::opérateur==' doit être publiquement visible pour être contenu par un 'type' 298
W8090: 'type::opérateur<' doit être publiquement visible pour être utilisé avec 'type' 299
W8089: 'type::opérateur<' doit être publiquement visible pour être contenu par un 'type' 299
W8091: L'argument 'type' 'spécificateur' transmis à 'fonction' est un itérateur 'catégorie d'itérateur' : 299
itérateur 'catégorie d'itérateur' requis
W8076: L'instance du modèle 'spécificateur' est déjà instanciée 299
W8077: La spécialisation explicite d'un membre de classe explicitement spécialisé n'a pas de sens 299
Messages d'information 299
E2196: Impossible de prendre l'adresse de la fonction membre 'fonction' 300
F1002: Impossible de créer le fichier de sortie 'nomfichier' 300
F1003: Erreur de directive : 'message' 300
F1004: Erreur interne du compilateur 300
F1006: Appel incorrect d'une fonction intrinsèque 300

x
 RAD Studio

F1007: Arborescence d'expression irréductible 301

F1009: Impossible d'ouvrir le fichier d'entrée 'nomfichier' 301
F1011: Echec d'allocation de registre 301
F1012: Débordement de pile du compilateur 301
F1013: Erreur d'écriture du fichier de sortie 301
F1000: Limite de la table du compilateur dépassée 301
F1005: Fichiers d'inclusion imbriqués trop profondément 302
F1008: Plus de mémoire 302
F1010: Impossible d'ouvrir 'nomfichier' 302
E2000: Instructions 286/287 non activées 302
Fin de programme anormale 302
E2009: Tentative d'accorder ou de réduire l'accès à 'identificateur' 302
E2011: Il est incorrect de prendre l'adresse d'un champ de bits 303
E2010: Impossible d'ajouter ou de soustraire des symboles relogeables 303
E2013: 'fonction1' ne peut pas être distinguée de 'fonction2' 303
E2014: Membre ambigu : 'membre1' et 'membre2' 303
E2015: Ambiguïté entre 'fonction1' et 'fonction2' 303
E2017: Nom de membre 'nom' ambigu 303
E2019: 'identificateur' ne peut pas être déclaré dans une union anonyme 304
E2020: Union anonyme globale non statique 304
E2022: Taille de tableau trop grande 304
E2024: Impossible de modifier un objet const 304
E2025: Affectation de 'this' non autorisée, utilisez plutôt l'opérateur X:: new 304
E2026: Instruction d'assembleur trop longue 304
E2001: Constructeurs et destructeurs non autorisés dans la section __automated 305
E2002: Seules les fonctions __fastcall sont autorisées dans la section __automated 305
E2003: Définition de données membre non autorisée dans la section __automated 305
E2004: Seule la clause read (lecture) ou write (écriture) est autorisée dans la déclaration de propriété de la 305
section __automated
E2005: Redéclaration de propriété non autorisée dans la section __automated 306
E2027: L'adresse d'un emplacement mémoire est obligatoire 306
E2028: L'opérateur -> doit renvoyer un pointeur ou une classe 306
E2029: 'identificateur' doit être une classe ou une structure précédemment définie 306
E2030: Caractère de fin de ligne mal placé 306
E2031: Transtypage impossible de 'type1' en 'type2' 307
E2033: Instruction continue mal placée 308
E2034: Impossible de convertir 'type1' en 'type2' 308
E2036: L'opérateur de conversion ne peut pas avoir de spécification de type de retour 308
E2037: Le constructeur 'constructeur' n'est pas autorisé 308

xi
 RAD Studio

E2039: Séparateur décimal mal placé 309

E2041: Utilisation incorrecte du mot clé default 309
E2042: Déclarer l'opérateur delete (void*) ou (void*, size_t) 309
E2044: L'opérateur delete doit retourner void 309
E2045: Le nom du destructeur doit correspondre au nom de la classe 309
E2048: Directive de préprocesseur inconnue : 'identificateur' 310
E2046: Format de nom de fichier incorrect dans la directive include OU format de nom de fichier incorrect 310
dans la directive line
E2051: Utilisation incorrecte du point 310
E2053: Directive elif mal placée 311
E2054: Instruction else mal placée 311
E2055: Directive else mal placée 311
E2056: Directive endif mal placée 311
E2059: Langage inconnu, doit être du C ou du C++ 311
E2060: Utilisation incorrecte de la virgule flottante 311
E2061: Les amis doivent être des fonctions ou des classes 312
E2062: Indirection incorrecte 312
E2063: Initialisation incorrecte 312
E2064: Impossible d'initialiser 'type1' avec 'type2' 312
E2068: 'identificateur' n'est pas une donnée membre non statique et ne peut pas être initialisé ici 312
E2069: Utilisation incorrecte d'un pointeur de membre 312
E2071: L'opérateur new doit avoir un paramètre initial de type size_t 313
E2072: L'opérateur new[] doit renvoyer un objet de type void 313
E2075: Option 'type' incorrecte : option 314
E2076: Opérateur surchargeable attendu 314
E2080: La fonction 'fonction' doit être déclarée avec un paramètre 314
E2077: 'opérateur' doit être déclaré avec un ou sans paramètre 314
E2079: 'fonction' doit être déclarée sans paramètres 314
E2078: 'opérateur' doit être déclaré avec un ou deux paramètres 315
E2081: 'fonction' doit être déclarée avec deux paramètres 315
E2082: 'identificateur' doit être une fonction membre ou avoir un paramètre de type classe 315
E2083: Le dernier paramètre de 'opérateur' doit être de type 'int' 315
E2084: Les noms de paramètres sont utilisés seulement avec un corps de fonction 315
E2085: Addition de pointeurs incorrecte 315
E2086: Soustraction de pointeurs incorrecte 316
E2087: Utilisation incorrecte du pointeur 316
E2088: Syntaxe incorrecte pour la définition de fonctions pures 316
E2089: L'identificateur 'identificateur' ne peut pas avoir un qualificateur de type 316
E2090: Le qualificateur 'identificateur' n'est pas un nom de classe ou d'espace de nommage 317

xii
 RAD Studio

E2092: La classe de stockage 'classe de stockage' n'est pas autorisée ici 317
E2096: Opération de structure incorrecte 317
E2104: Utilisation incorrecte du mot clé template 317
E2108: Utilisation incorrecte de typedef 'identificateur' 317
E2109: Type non autorisé 317
E2110: Conversion de type incompatible 317
E2113: Conflits de fonction virtuelle 'fonction1' avec la classe de base 'base' 318
E2114: Plusieurs classes de base nécessitent des noms de classes explicites 318
E2115: Champ de bits trop grand 318
E2116: Les champs de bits doivent contenir au moins un bit 318
W8005: Les champs de bits doivent être des entiers signés ou non signés 318
E2119: Pause utilisateur 318
E2111: Le type 'nomtype' ne peut pas être défini ici 319
E2121: ) manquante dans l'appel de fonction 319
E2123: La classe 'classe' ne doit pas contenir des fonctions pures 319
E2126: Case a contourné l'initialisation d'une variable locale 319
E2127: Instruction case manquante : 319
E2128: Case en dehors du switch 319
E2129: Constante caractère trop longue (ou vide) 319
E2133: Impossible d'exécuter la commande 'commande' 320
E2134: Accolade fermante manquante dans une instruction composée 320
E2137: Un destructeur pour 'classe' est nécessaire dans l'expression conditionnelle 320
E2135: Un constructeur/destructeur ne peut pas être déclaré 'const' ou 'volatile' 320
E2138: Conflit de modificateurs de type 320
E2136: Un constructeur ne peut pas avoir de spécification de type de retour 320
E2038: Impossible de déclarer ou de définir 'identificateur' ici : espace de nommage incorrect 321
E2154: Impossible de définir 'identificateur' en utilisant un alias d'espace de nommage 321
E2421: Impossible d'utiliser le type local 'identificateur' comme argument modèle 321
E2035: Les conversions d'une classe en elle-même ou en classe de base ne sont pas autorisées 321
E2139: ; manquant dans la déclaration 321
E2140: La déclaration n'est pas autorisée ici 321
E2141: Erreur de syntaxe de déclaration 321
E2142: La classe de base 'classe' contient des fonctions qui peuvent être réparties de façon dynamique 322
E2143: La fonction 'fonction' de classe de base correspondante a un numéro de répartition différent 322
E2144: La fonction de classe de base correspondante 'fonction' n'est pas dynamique 322
E2145: Les fonctions 'fonction1' et 'fonction2' utilisent le même numéro de répartition 322
E2146: Vous devez fournir un identificateur à déclarer 322
E2147: 'identificateur' ne peut pas démarrer une déclaration de paramètre 322
E2150: Mauvaise correspondance de type dans la valeur de l'argument par défaut 323

xiii
 RAD Studio

E2152: L'expression par défaut ne doit pas utiliser des variables locales 323
E2153: La directive define nécessite un identificateur 323
E2155: Trop d'instructions default 323
E2156: Default en dehors du switch 323
E2158: L'opérande de 'delete' doit être un pointeur non-const 323
E2159: Tentative de dériver une classe far depuis la base huge 'base' 324
E2160: Tentative de dériver une classe far depuis la base near 'base' 324
E2161: Tentative de dériver une classe huge depuis la base far 'base' 324
E2162: Tentative de dériver une classe huge depuis la base near 'base' 324
E2163: Tentative de dériver une classe near depuis la base far 'base' 324
E2164: Tentative de dériver une classe near depuis la base huge 'base' 324
E2165: Un destructeur ne peut pas avoir de spécification de type de retour 324
E2166: Le destructeur de 'classe' n'est pas accessible 325
E2167: 'fonction' a été précédemment déclarée avec le langage 'langage' 325
E2168: Division par zéro 325
E2169: 'identificateur' spécifie des accès multiples ou dupliqués 325
E2170: La classe de base 'classe' est incluse plusieurs fois 325
E2171: Le corps a déjà été défini pour la fonction 'fonction' 325
E2172: Case dupliqué 326
E2175: Trop de classes de stockage dans la déclaration 326
E2176: Trop de types dans la déclaration 326
E2179: virtual spécifié plusieurs fois 326
E2007: Dispid n'est autorisé que dans les sections __automated 326
Erreur de division 327
E2182: Paramètre incorrect pour __emit__ 327
E2183: Le fichier doit contenir au moins une déclaration externe 327
E2184: Erreur de syntaxe pour une énumération 327
E2185: La valeur de 'identificateur' n'est pas un entier 327
E2186: Fin de fichier inattendue dans le commentaire qui commence à la ligne 'numéro de ligne' 327
E2187: Fin de fichier inattendue dans l'instruction conditionnelle qui commence à la ligne 'numéro de ligne' 327
E2188: Syntaxe de l'expression 328
E2190: Accolade fermante inattendue 328
E2189: La variable extern ne peut pas être initialisée 328
E2344: Déclaration précédente de 'identificateur' 328
E2192: Trop peu de paramètres dans l'appel 328
E2193: Trop peu de paramètres dans l'appel à 'fonction' 329
E2194: Impossible de trouver le fichier 'nomfichier' 329
E2197: Nom de fichier trop long 329
E2195: Impossible d'évaluer l'appel de fonction 329

xiv
 RAD Studio

E2198: Ce n'est pas un type de format d'expression correct 329

E2200: Les fonctions ne peuvent pas faire partie d'une structure ou d'une union 329
Erreur de calcul à virgule flottante : Erreur de division par 0 OU de calcul à virgule flottante : Erreur de 329
domaine ou de calcul à virgule flottante : Dépassement de capacité
Erreur de calcul à virgule flottante : Faute de pile 330
Erreur de calcul à virgule flottante : Perte de précision partielle OU Erreur de calcul à virgule flottante : 330
Débordement inférieur
E2201: Trop de données globales définies dans le fichier 330
E2203: Goto évite l'initialisation d'une variable locale 330
E2204: Le groupe a dépassé la taille maximum : 'nom' 330
E2206: Caractère 'caractère' (0x'valeur') incorrect 331
E2207: Conversion implicite de 'type1' en 'type2' non autorisée 331
E2208: Impossible d'accéder à une portée inactive 331
E2209: Impossible d'ouvrir le fichier include 'nomfichier' 331
E2210: Le membre de référence 'membre' n'est pas initialisé 331
E2212: La fonction a été définie inline après avoir été utilisée comme extern 332
E2211: L'assemblage en ligne n'est pas autorisé dans les fonctions inline et template 332
F1001: Erreur du générateur de code interne 332
E2413: Déclaration de modèle incorrecte 332
E2070: Utilisation incorrecte de l'espace de nommage 'identificateur' 332
E2214: Impossible d'avoir des 'données fonction/statique non inline' dans une classe locale 333
E2215: Spécification de lien non autorisée 333
E2216: Impossible de créer turboc.$ln 333
E2218: Les modèles ne peuvent être déclarés qu'au niveau d'un espace de nommage ou d'une classe 333
E2217: Les données locales dépassent la limite de taille du segment 333
E2219: Nombre incorrect d'arguments dans l'appel de la macro 'macro' 333
E2220: Séparateur d'arguments de macro incorrect 334
E2221: Erreur de syntaxe dans l'argument de macro 334
E2222: Développement de macro trop long 334
E2223: Trop de séparateurs décimaux 334
E2224: Trop d'exposants 334
E2225: Trop d'initialiseurs 334
E2226: Paramètre supplémentaire dans l'appel 334
E2227: Paramètre supplémentaire dans l'appel de fonction 334
E2228: Trop de messages d'erreur ou d'avertissement 335
E2233: Impossible d'initialiser un membre de classe ici 335
E2232: Membre 'membre' constante/référence dans la classe sans constructeur 335
E2229: Le membre 'membre' a le même nom que sa classe 335
E2234: Référence mémoire attendue 335
E2231: Le membre 'membre' ne peut pas être utilisé sans objet 335

xv
 RAD Studio

E2235: Une fonction membre doit être appelée ou son adresse prise 336
O2237: Les programmes DPMI doivent utiliser le modèle de mémoire large 336
E2238: Plusieurs déclarations pour 'identificateur' 336
E2239: 'identificateur' doit être une fonction membre 337
E2240: Conversion de pointeur near non autorisée 337
E2243: Un tableau alloué avec 'new' ne peut pas avoir d'initialisateur 337
E2244: 'new' et 'delete' ne sont pas gérés 337
E2245: Impossible d'allouer une référence 337
E2309: Assembleur Inline non autorisé 337
E2250: Aucune classe de base à initialiser 338
E2254: : attendu après private/protected/private 338
E2255: Utiliser :: pour prendre l'adresse d'une fonction membre 338
E2256: Pas de : qui suit le ? 338
E2257: , attendue 338
E2258: Une déclaration était attendue 338
E2259: Valeur par défaut manquante 339
E2260: Une valeur par défaut manque après le paramètre 'paramètre' 339
E2263: La gestion des exceptions n'est pas activée 339
E2264: Expression attendue 339
E2266: Aucun nom de fichier donné 339
E2265: Aucun signe de fin dans le nom de fichier 339
E2271: Il manque un libellé à l'instruction goto 339
E2272: Identificateur attendu 339
E2275: Accolade ouvrante attendue 340
E2276: ( attendue 340
E2274: < attendu 340
E2277: Lvalue nécessaire 340
E2278: Les classes de base multiples ne sont pas gérées pour les classes Delphi 340
E2280: Identificateur de membre attendu 340
E2279: Impossible de trouver le constructeur par défaut pour initialiser le membre 'identificateur' 341
E2310: Seules les fonctions membre peuvent être 'const' ou 'volatile' 341
E2311: La fonction non-virtuelle 'fonction' est déclarée pure 341
E2283: Utilisez . ou -> pour appeler 'fonction' 341
E2284: Utilisez . ou -> pour appeler 'membre', ou & pour prendre son adresse 341
E2285: Impossible de trouver une correspondance pour le(s) 'argument(s)' 342
E2286: Résolution de fonction surchargée non gérée 342
E2287: Nom manquant dans le paramètre 'numéro' 342
E2288: Pointeur sur structure nécessaire du côté gauche de -> ou ->* 342
E2290: ] manquant dans 'code' 342

xvi
 RAD Studio

E2291: Accolade attendue 342

E2292: La fonction doit renvoyer une valeur 343
E2293: ) attendue 343
E2294: Structure nécessaire sur le côté gauche de . ou .* 343
E2312: 'constructeur' n'est pas une classe de base non ambiguë de 'classe' 343
E2313: Expression constante nécessaire 343
E2296: Modèles non gérés 343
E2314: Appel d'une non fonction 343
E2321: La déclaration ne spécifie pas un repère ou un identificateur 344
E2297: 'this' ne peut être utilisé que dans une fonction membre 344
E2316: 'identificateur' n'est pas un membre de 'structure' 344
E2317: 'identificateur' n'est pas un paramètre 344
E2319: 'identificateur' n'est pas une classe de base publique de 'type de classe' 344
E2320: Expression de type scalaire attendue 344
E2302: Pas d'informations de type 345
E2303: Nom de type attendu 345
E2304: La variable 'variable' Constant/Reference doit être initialisée 345
E2305: Impossible de trouver 'class::class' ('class' &) pour copier un vecteur OU Impossible de trouver 345
'class'::operator=('class'&) pour copier un vecteur
E2306: Les classes de base virtuelles ne sont pas gérées par les classes Delphi 346
E2308: L'instruction 'do' doit avoir un 'while' 346
E2322: Format numérique incorrect 346
E2324: Constante numérique trop grande 346
E2282: Nom d'espace de nommage attendu 347
E2334: Le membre de l'espace de nommage 'identificateur' a été déclaré en dehors de son espace de 347
nommage
E2325: Chiffre octal incorrect 347
E2329: Combinaison incorrecte d'instruction et d'opérandes 347
E2327: Les opérateurs ne doivent pas avoir de valeurs d'argument par défaut 347
E2330: Un opérateur doit être déclaré comme une fonction 347
E2333: Le membre de classe 'membre' a été déclaré en dehors de sa classe 348
E2335: 'fonction' surchargée ambiguë dans ce contexte 348
E2339: Impossible de surcharger 'main' 348
E2336: Le pointeur sur la fonction surchargée 'fonction' ne correspond pas à 'type' 348
E2337: Seule une fonction d'un ensemble de fonctions surchargées peut être "C" 348
E2338: Les overlays ne sont supportés que dans les modèles mémoire medium, large et huge 348
E2340: Non concordance de type dans le paramètre 'nombre' 349
E2341: Non concordance de type dans le paramètre 'numéro' dans l'appel à 'fonction' 349
E2342: Non concordance de type dans le paramètre 'paramètre' 349
E2343: Non concordance de type dans le paramètre 'paramètre' dans l'appel à 'fonction' 349

xvii
 RAD Studio

E2345: L'accès peut seulement être changé en public ou protected 350

E2349: Conversion de pointeur non portable 350
E2350: Impossible de définir un pointeur ou une référence sur une référence 350
E2352: Impossible de créer une instance de la classe abstraite 'classe' 350
E2354: Deux opérandes doivent être évalués de même type 351
E2355: Fonction modèle récursive : 'x' a instancié 'y' 351
E2356: Non concordance de type dans la redéclaration de 'identificateur' 351
E2357: Référence initialisée avec 'type1', nécessite lvalue de type 'type2' 352
E2358: Le membre référence 'membre' a besoin d'un temporaire pour l'initialisation 352
E2360: Combinaison de registre incorrecte (ex : [BP+BX]) 352
E2361: 'spécificateur' a déjà été inclus 352
E2362: Le nombre de répétitions a besoin d'une lvalue 352
E2363: Tentative de renvoyer une référence à la variable locale 'identificateur' 353
E2364: Tentative de renvoyer une référence à un objet local 353
E2365: Un pointeur membre est nécessaire à droite de .* ou ->* 353
E2366: Impossible d'hériter une classe non-RTTI depuis la base RTTI (E2367) OU Impossible d'hériter une 353
classe RTTI depuis la base non-RTTI
E2368: RTTI non disponible pour une évaluation d'expression 353
E2371: sizeof ne peut pas être appliqué à un champ de bits 354
E2372: sizeof ne peut pas être appliqué à une fonction 354
E2373: Un champ de bits ne peut pas être statique 354
E2374: La fonction 'fonction' ne peut pas être statique 354
Débordement de pile 354
E2376: ( manquante dans l'instruction 354
E2377: ) manquante dans l'instruction 354
E2378: ; manquant dans l'instruction do-while ou for 355
E2379: ; manquante dans l'instruction 355
E2380: Constante chaîne ou caractère non terminée 355
E2381: Taille de la structure trop grande 355
E2382: Les effets de bord ne sont pas autorisés 355
E2383: L'expression de sélection switch doit être de type entier 355
E2433: Spécialisation après la première utilisation du modèle 355
E2384: Impossible d'appeler une fonction membre de classe near avec un pointeur de type 'type' 355
E2390: Non concordance de type dans le paramètre 'numéro' du nom de classe modèle 'modèle' 356
E2391: Non concordance de type dans le paramètre 'paramètre' du nom de classe modèle 'modèle' 356
E2394: Trop peu d'arguments passés au modèle 'modèle' 356
E2395: Trop d'arguments passés au modèle 'modèle' 356
E2396: L'argument du modèle doit être une expression constante 356
E2401: Liste des arguments de modèles incorrecte 356

xviii
 RAD Studio

E2400: L'argument de modèle non typé doit être de type scalaire 357
E2415: Les fonctions modèle doivent avoir seulement des 'arguments de type' 357
E2425: 'membre' n'est pas un membre de type modèle correct 357
E2428: Les modèles doivent être des classes ou des fonctions 357
E2432: Le qualificateur 'template' doit nommer une classe modèle ou une instance de fonction 357
E2442: Deux points consécutifs 357
E2443: La classe de base 'classe' est initialisée plus d'une fois 357
E2444: Le membre 'membre' est initialisé plus d'une fois 358
E2445: La variable 'identificateur' est initialisée plus d'une fois 358
E2446: La définition de fonction ne peut pas être une déclaration typedef 358
E2132: Les modèles et les opérateurs surchargés ne peuvent pas avoir de lien C 358
E2447: 'identificateur' doit être un repère d'énumération précédemment défini 358
E2448: Etiquette non définie 'identificateur' 358
E2449: La taille de 'identificateur' est inconnue ou zéro 358
E2450: Structure 'structure' non définie 359
E2451: Symbole 'identificateur' non défini 359
E2453: La taille du type 'identificateur' est inconnue ou égale à zéro 359
E2452: La taille du type est inconnue ou zéro 359
E2454: Une union ne peut pas être un type de base 359
E2455: Une union ne peut pas avoir un type de base 360
E2456: Le membre de l'union 'membre' est de classe type avec 'constructeur' (ou destructeur ou opérateur 360
=)
E2461: '%s' nécessite une initialisation/finalisation d'exécution 360
E2464: 'virtual' ne peut être utilisé qu'avec des fonctions membre 360
E2465: Les unions ne peuvent pas avoir de fonctions membre virtuelles 360
E2466: void & n'est pas un type correct 360
E2467: Une fonction Void ne peut pas renvoyer une valeur 361
E2468: Une valeur de type void n'est pas autorisée 361
E2469: Impossible d'utiliser le modèle mémoire tiny ou huge avec Windows 361
E2006: Les programmes protégés par CodeGuard doivent utiliser le modèle de mémoire large et être 361
prévus pour Windows
E2269: La fonction 'fonction' n'est pas disponible 361
E2124: Appel de fonction incorrect 361
E2213: 'expression' incorrecte dans la redéfinition de portée 361
E2236: 'identificateur' manquant dans la redéfinition de portée 362
Fonction virtuelle pure appelée 362
E2095: Littéral chaîne non autorisé dans ce contexte 362
Fin anattendue pendant la compilation [Module Seg#:offset] OU Fin inattendue pendant la liaison [Module 362
Seg#:offset]
E2012: Impossible de prendre l'adresse de 'main' 362

xix
 RAD Studio

E2016: Redéfinition ambiguë du membre de base virtuel 'fonction_de_base': 'fonction_dérivée' 362

E2021: Un tableau doit avoir au moins un élément 363
E2023: Tableau de références non autorisé 363
E2032: Utilisation incorrecte d'un pointeur de clôture (closure) 363
E2040: Terminaison de déclaration incorrecte 363
E2047: Syntaxe de la directive 'directive' incorrecte 364
E2049: Le type de classe 'type' ne peut pas être marqué comme __declspec(delphireturn) 364
E2052: Conflits de la fonction dynamique 'fonction' avec la classe de base 'classe' 364
E2057: Spécification d'exception non autorisée ici 364
E2058: La variable de gestion des exceptions ne peut pas être utilisée ici 364
E2065: L'utilisation du symbole d'espace de nommage 'symbole' crée un conflit avec un intrinsèque du 365
même nom
E2067: Le type renvoyé par 'main' doit être int 365
E2073: Rien n'est autorisé après l'option pragma pop 365
E2091: Les fonctions ne peuvent pas renvoyer des tableaux ou des fonctions 365
E2093: Opérateur 'opérateur' non implémenté dans le type 'type' pour les arguments du même type 365
E2094: Opérateur 'opérateur' non implémenté dans le type 'type' pour les arguments de type 'type' 365
E2097: Instanciation explicite uniquement autorisée dans les fichiers ou les espaces de nommage 366
E2098: Un déclarateur de spécialisation explicite "template<>" est maintenant nécessaire 366
E2099: Spécialisation explicite uniquement autorisée dans les fichiers ou les espaces de nommage 366
E2101: Le mot clé 'export' doit précéder une déclaration de modèle 366
E2103: Une instanciation explicite doit être utilisée avec une classe ou une fonction modèle 366
E2106: Une spécialisation explicite doit être utilisée avec une classe ou une fonction modèle 366
E2112: Directive d'unité inconnue : 'directive' 366
E2118: Les champs de bits doivent être de type entier 367
E2120: Impossible d'appeler 'main' depuis le programme 367
E2125: Le compilateur n'a pas pu générer de constructeur de copie pour la classe 'classe' OU Le 367
compilateur n'a pas pu générer de constructeur par défaut pour la classe 'classe' OU Le compilateur n'a
pas pu générer d'opérateur = pour la classe 'classe'
E2130: Définition de propriété circulaire 367
E2131: Les objets de type 'type' ne peuvent pas être initialisés avec des { } 367
E2148: La valeur de l'argument par défaut a été redéclarée pour le paramètre 'paramètre' 367
E2149: La valeur de l'argument par défaut a été redéclarée 368
E2151: Mauvaise correspondance de type dans la valeur par défaut pour le paramètre 'paramètre' 368
E2157: La suppression d'un objet nécessite exactement une conversion en opérateur de pointeur 368
E2173: Le gestionnaire dupliqué pour 'type1' avait déjà 'type2' 368
E2174: Le gestionnaire spécifié doit être le dernier 368
E2177: Redéclaration de #pragma package avec différents arguments 369
E2178: Conflit de nom VIRDEF pour 'fonction' 369
E2180: Numéro dispid déjà utilisé par l'identificateur 369

xx
 RAD Studio

E2181: Impossible de redéfinir une fonction 'dynamique/virtuelle' avec une fonction 'dynamique/virtuelle' 369
E2202: Goto est interdit dans un gestionnaire d'exception 369
E2205: Type 'type' incorrect dans la section __automated 369
E2242: Le spécificateur a besoin d'un type de classe de style Delphi 370
E2247: 'membre' n'est pas accessible 370
E2248: Impossible de trouver un constructeur par défaut pour initialiser un élément de tableau de type 371
'classe'
E2251: Impossible de trouver un constructeur par défaut pour initialiser la classe de base 'classe' 371
E2252: 'catch' attendu 371
E2253: La convention d'appel doit être attribuée au type de fonction, non au closure 371
E2261: L'utilisation d'un dispid avec une propriété nécessite un getter ou un setter 372
E2262: '__except' ou '__finally' attendu après '__try' 372
E2270: > attendu 372
E2273: 'main' ne peut pas être déclaré comme statique ou en ligne 372
E2281: Identificateur1 nécessite la définition de Identificateur2 comme type pointeur 372
E2289: Les sections __published ou __automated ne sont gérées que par les classes Delphi 372
E2298: Impossible de créer 'fonction' à partir de la fonction modèle 'modèle' 373
E2301: Impossible d'utiliser des modèles dans les arguments closure ; utilisez un typedef 373
E2307: Le type 'type' n'est pas une classe définie avec des fonctions virtuelles 373
E2315: 'Membre' n'est pas un membre de 'classe', car le type n'est pas encore défini 373
E2318: 'type' n'est pas un type de classe polymorphe 374
E2323: Suffixe numérique incorrect 374
E2326: Utilisez __declspec(spec1[, spec2]) pour combiner plusieurs __declspecs 374
E2328: Les classes avec des propriétés ne peuvent pas être copiées par valeur 374
E2331: Nombre de contextes d'option admissibles dépassé 374
E2332: La variable 'variable' a été optimisée et n'est pas disponible 375
E2476: Impossible de surcharger 'fonction' 375
E2346: Le spécificateur d'accès 'x' de la propriété 'propriété' doit être une fonction membre 375
E2347: Non concordance de paramètre dans le spécificateur d'accès 'spécificateur' de la propriété 375
'propriété'
E2348: Spécificateur de stockage non autorisé pour les propriétés de tableau 375
E2351: Membres de données statiques non autorisés dans les sections __published ou __automated 376
E2353: La classe 'classe' est abstraite car 'membre = 0' 376
E2359: Le membre référence 'membre' a été initialisé avec un paramètre non-référence 376
E2369: Impossible d'utiliser le résultat d'une affectation de propriété comme une rvalue 377
E2370: Nom de type simple attendu 377
E2398: L'argument 'argument' de la fonction modèle n'est pas utilisé dans les types d'argument 377
E2419: Erreur pendant l'instanciation du modèle 'modèle' 377
E2424: Classe modèle imbriquée trop profondément : 'class' 377
E2457: Les classes de style Delphi doivent être prises par référence 378

xxi
 RAD Studio

E2458: Les classes Delphi doivent être dérivées de classes Delphi 378
E2459: Les classes de style Delphi doivent être construites en utilisant l'opérateur new 378
E2460: Les classes de style Delphi nécessitent que la gestion d'exception soit activée 379
E2463: 'base' est une classe de base virtuelle indirecte de 'classe' 379
Affectation de pointeur Null 379
E2268: Appel à une fonction 'fonction' non définie 379
E2375: Débordement de pile assembleur 379
Initialisation d'une énumération avec un type 379
<nom> n'est pas un identificateur correct 380
Exemple pour les messages d'erreur d'"utilisation temporaire..." 380
Application en cours d'exécution 380
Formats en virgule flottante Printf/Scanf non liés 380
W8000: Les opérateurs ambigus requièrent des parenthèses 381
W8060: Affectation peut-être incorrecte 381
W8002: Redémarrage de la compilation avec l'assembleur 381
W8003: Instruction assembleur inconnue 381
W8052: Initialisation de base sans nom de classe maintenant obsolète 382
E2117: Les champs de bits doivent être des entiers signés ou non signés 382
W8064: Appel à une fonction sans prototype 382
W8065: Appel à la fonction 'fonction' sans prototype 382
W8009: La constante est longue 382
W8008: La condition est toujours vraie OU W8008 La condition est toujours fausse 383
W8012: Comparaison de valeurs signées et non signées 383
W8010: Caractère de continuation \ trouvé dans un commentaire // 383
W8080: 'identificateur' est déclaré mais jamais utilisé 383
W8014: Déclaration ignorée 384
W8068: Constante hors limites dans la comparaison 384
W8016: Taille de tableau ignorée pour 'delete' 384
W8082: Division par zéro 385
W8018: Affectation de 'type' à 'énumération' 385
W8006: Initialisation de 'identificateur' avec 'identificateur' 385
W8001: & superflu avec une fonction 385
W8020: 'identificateur' est déclaré à la fois externe et statique 385
W8007: La valeur hexadécimale contient plus de trois chiffres 386
W8024: La classe de base 'classe1' est aussi une classe de base de 'classe2' 386
W8022: 'fonction1' cache la fonction virtuelle 'fonction2' 386
W8023: La variable tableau 'identificateur' est near 386
W8061: L'initialisation est partiellement entre accolades 387
W8038: Le membre constante 'identificateur' n'est pas initialisé 387

xxii
 RAD Studio

W8071: La conversion peut perdre des chiffres significatifs 387

W8043: Définition de macro ignorée 387
W8017: La redéfinition de 'x' n'est pas identique 387
W8079: Mélange de pointeurs de plusieurs types 'char' 387
W8067: Instructions de retour avec et sans valeur utilisées 388
W8048: Utilisez un nom qualifié pour accéder au type membre 'identificateur' 388
W8039: Liste d'initialiseurs de constructeurs ignorée 388
W8040: Corps de fonction ignoré 388
W8042: Initialiseur pour l'objet 'x' ignoré 388
W8044: Directive #undef ignorée 389
W8037: Fonction non const 'fonction' appelée pour un objet const 389
W8051: Fonction non volatile 'fonction' appelée pour un objet volatile 389
W8019: Le code n'a pas d'effet 389
W8057: Paramètre 'paramètre' jamais utilisé 390
W8070: La fonction doit renvoyer une valeur 390
W8047: Déclaration de la fonction statique function ignorée 390
W8041: Valeur non signée rendue négative 390
W8054: Ce style de définition de fonction est maintenant obsolète 390
W8025: Pragma mal formé 391
W8063: Opérateur de préfixe surchargé 'opérateur' utilisé comme un opérateur de suffixe 391
W8015: Déclarez 'type' avant de l'utiliser dans le prototype 391
W8069: Conversion de pointeur non portable 391
W8066: Code inatteignable 392
W8029: Un temporaire a été utilisé pour le paramètre '???' 392
W8031: Temporaire utilisé pour le paramètre 'paramètre' OU W8029 Temporaire utilisé pour le paramètre 392
'numéro' OU W8030 Temporaire utilisé pour le paramètre 'paramètre' dans l'appel à 'fonction' OU W8032
Temporaire utilisé pour le paramètre 'numéro' dans l'appel à 'fonction'
W8032: Un temporaire a été utilisé pour le paramètre 2 dans l'appel à '???' 392
W8028: Variable temporaire utilisée pour initialiser 'identificateur' 393
W8074: Structure transmise par valeur 393
W8011: Comparaison de pointeur non portable 393
W8075: Conversion de pointeur suspecte 394
W8059: La taille de la structure a changé 394
8045: Pas de déclaration pour la fonction 'fonction' 394
W8073: Structure 'structure' non définie 395
W8013: Utilisation possible de 'identificateur' avant sa définition 395
W8004: 'identificateur' a une valeur qui n'est jamais utilisée 395
W8081: Les fonctions void ne peuvent pas renvoyer de valeur 395
W8078: L'expression throw viole la spécification d'exception 396
W8021: Le gestionnaire de 'type1' est caché par le gestionnaire précédent de 'type2' 396

xxiii
 RAD Studio

W8056: Débordement arithmétique d'entiers 396

W8035: Message défini par l'utilisateur 396
W8049: Utilisez '> >' pour les modèles imbriqués au lieu de '>>' 396
W8026: Les fonctions avec des spécifications d'exception ne sont pas développées en ligne 397
W8058: Impossible de créer un en-tête précompilé : 'raison' 397
W8046: Option pragma pop sans option push correspondante 397
W8050: Aucun fichier OBJ présent. Désactivation de l'option des types externes. 397
W8027: Les fonctions contenant 'instruction' ne sont pas développées en ligne 398
W8036: Mot clé non ANSI utilisé : 'mot clé' 398
W8053: 'identificateur' obsolète 399
W8103: Le chemin 'chemin' et le nom de fichier 'nomfichier' dépassent la taille maximale 'n' 399
W8062: Options et avertissements précédents non restaurés 399
W8055: Débordement possible dans une opération shift 399
W8072: Arithmétique de pointeur suspecte 399
W8033: La conversion en 'type' échouera pour les membres de la base virtuelle 'classe' 400
W8034: Précision maximum utilisée pour le type pointeur membre 'type' 400
Exemples C++ 400
Exemple Remove et MessageDlg 400
Guide du langage C++ 401
Spécificités du C++ 401
Liste alphabétique des mots clés 519
Mots clés par catégorie 583
Structure du langage 590
Eléments lexicaux 666
Le préprocesseur 692
C Runtime Library Reference 717
alloc.h 718
assert.h 736
conio.h 738
ctype.h 772
delayimp.h 793
direct.h 796
dirent.h 798
dir.h 805
dos.h 824
errno.h 837
except.h 844
fastmath.h 848
fcntl.h 850

xxiv
 RAD Studio

float.h 859
io.h 870
limits.h 922
locale.h 924
malloc.h 929
math.h 930
mem.h 968
new.h 977
process.h 980
setjmp.h 1002
share.h 1005
signal.h 1006
stdarg.h 1012
stddef.h 1013
stdio.h 1015
stdlib.h 1087
string.h 1146
sys\stat.h 1193
sys\timeb.h 1197
sys\types.h 1199
time.h 1200
typeinfo.h 1218
utime.h 1220
values.h 1221

Guide du développeur Win32 1224

Guide du concepteur de composants 1224
Création d'un composant graphique 1225
Création d'événements 1239
Création de méthodes 1250
Création de propriétés 1255
Personnalisation d'une grille 1268
Extensions de l'EDI 1287
Gestion des messages 1310
Présentation de la création d'un composant 1323
Contrôles orientés données 1339
Accessibilité des composants au moment de la conception 1355
Transformation d'une boîte de dialogue en composant 1375
Modification d'un composant existant 1380
Programmation orientée objet et écriture des composants 1384

xxv
 RAD Studio

Graphiques et composants 1394

Développement d'applications COM 1400
Principes de COM 1401
Création d'une page Active Server 1419
Utilisation des contrôles ActiveX 1426
Création de clients COM 1438
Création de serveurs COM simples 1453
Utilisation des bibliothèques de types 1468
Développement d'applications de bases de données 1496
Utilisation des composants ADO 1496
Connexion aux bases de données 1524
Création d'applications multiniveaux 1540
Création d'états avec Rave Reports 1584
Conception d'applications de bases de données 1589
Présentation des ensembles de données 1607
Utilisation du moteur de bases de données Borland 1677
Utilisation d'ensembles de données client 1743
Utilisation de contrôles de données 1790
Utilisation de composants d'aide à la décision 1831
Utilisation des composants fournisseur 1859
Utilisation des composants dbExpress 1876
Utilisation de XML dans les applications de bases de données 1897
Manipulation des composants champ 1907
Programmation avec Delphi 1939
Création d'applications, de composants et de bibliothèques 1940
Création d'applications internationales 1983
Principes de la programmation en Delphi 1999
Déploiement des applications 2002
Conception de l'interface utilisateur des applications 2021
Gestion des exceptions 2083
Types de contrôles 2098
Présentation de la bibliothèque de composants 2121
Utilisation du modèle objet 2130
Utilisation de la VCL/RTL 2152
Utilisation des composants 2212
Manipulation des contrôles 2219
Utilisation des graphiques et du multimédia 2240
Utilisation des packages et des composants 2282
Ecriture d'applications multithreads 2299

xxvi
 RAD Studio

Ecriture d'applications Internet 2318

Création d'applications serveur Internet 2319
Utilisation d'IntraWeb 2330
Utilisation de WebBroker 2337
Utilisation de services Web 2367
Utilisation de WebSnap 2390
Utilisation des sockets 2417
Utilisation de documents XML 2434

Index a

xxvii
1 RAD Studio

1 Concepts
Rubriques
Nom Description
Débogage d'applications C++ avec les rapports d'erreurs CodeGuard ( see CodeGuard permet de déboguer l'exécution des applications C++ développées
page 3) avec RAD Studio. CodeGuard signale les erreurs non détectées par le
compilateur parce qu'elles n'outrepassent pas les règles de syntaxe. CodeGuard
assure le suivi des bibliothèques d'exécution et prend totalement en charge les
applications multithread.
Développement d'applications de bases de données pour la plate-forme Win32 Les applications de bases de données permettent aux utilisateurs d'interagir
( see page 13) avec les informations stockées dans les bases de données. Les bases de
données permettent de structurer les informations et de les partager entre
plusieurs applications.
Delphi permet de gérer les applications de bases de données relationnelles. Les
bases de données relationnelles organisent les informations en tables, qui
contiennent des lignes (enregistrements) et des colonnes (champs). Ces tables
peuvent être manipulées par des opérations simples appelées calculs
relationnels.
Développement des applications interopérables ( see page 39) RAD Studio fournit des experts et des classes qui facilitent l'implémentation
d'applications basées sur le modèle COM (Component Object Model) de
Microsoft. Grâce à ces experts, vous pouvez créer des classes et des
composants basés sur COM que vous utiliserez dans des applications, ou vous
pouvez créer des clients ou des serveurs COM complètement fonctionnels qui
implémentent des objets COM sophistiqués, des serveurs Automation (y
compris, des objets Active Server), des contrôles ActiveX ou des fiches
ActiveForms.
Développement d'états pour vos applications Win32 ( see page 45) RAD Studio est livré avec Rave Reports de Nevrona. A l'aide des composants
d'états, vous pouvez construire des états complets pour vos applications. Vous
pouvez construire des solutions incluant des fonctionnalités de génération
d'états, qui pourront être utilisées et personnalisées par vos clients. De plus, les
outils ComponentOne livrés avec RAD Studio incluent des composants
permettant de créer et de générer des états.
Développement d'applications avec des composants VCL ( see page 46) La VCL (Visual Component Library) est un ensemble de composants visuels
permettant le développement rapide d'applications Windows dans le langage
Delphi.
La VCL contient une gamme étendue de classes utilitaires visuelles ou non
visuelles pour des tâches telles que la construction d'applications Windows,
d'applications web, d'applications de bases de données et d'applications de
consoles.

1
 RAD Studio 1

Développement d'applications Web avec WebSnap ( see page 51) Cette section fournit l'arrière-plan conceptuel de construction des applications
WebSnap avec RAD Studio. WebSnap facilite la construction d'applications
serveur Web fournissant des pages Web complexes orientées données. La prise
en charge par WebSnap des modules multiples et des scripts côté serveur
facilite le développement et la maintenance pour les équipes de développeurs et
de concepteurs Web.
Veuillez noter que WebSnap est en cours de dépréciation dans RAD Studio.
Bien que WebSnap soit toujours documenté dans l'aide en ligne, le produit
WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser
IntraWeb (VCL pour le Web). IntraWeb ( see page 2330) est documenté dans
cette... suite ( see page 51)
1 Développement de services Web avec des applications Win32 ( see page 54) Les services Web sont des applications modulaires indépendantes qui peuvent
être publiées ou invoquées sur Internet. Les services Web fournissent des
interfaces bien définies qui décrivent les services fournis. A la différence des
applications de serveur Web qui génèrent des pages Web pour les navigateurs
client, les services Web ne sont pas conçus pour une interaction humaine
directe. Ils sont plutôt destinés à être appelés par programme de la part
d'applications client. Cette section contient une présentation des services web et
de leur prise en charge.
Développement d'applications Windows ( see page 55) Windows propose une approche traditionnelle du développement d'interfaces
utilisateur, d'applications client/serveur, de contrôles et de la logique applicative.
Cette section propose une présentation du développement d'applications
Windows utilisant RAD Studio pour Win32 et décrit les étapes de construction
d'un projet Windows simple.

2
1.1 Débogage d'applications C++ avec les RAD Studio Erreurs CodeGuard

1.1 Débogage d'applications C++ avec les

rapports d'erreurs CodeGuard
CodeGuard permet de déboguer l'exécution des applications C++ développées avec RAD Studio. CodeGuard signale les
1
erreurs non détectées par le compilateur parce qu'elles n'outrepassent pas les règles de syntaxe. CodeGuard assure le suivi des
bibliothèques d'exécution et prend totalement en charge les applications multithread.

Rubriques
Nom Description
Erreurs CodeGuard ( see page 3) CodeGuard signale quatre types d'erreurs d'exécution.
Présentation de CodeGuard ( see page 9) CodeGuard permet de déboguer l'exécution des applications C++ développées
avec RAD Studio. CodeGuard signale les erreurs non détectées par le
compilateur parce qu'elles n'outrepassent pas les règles de syntaxe. CodeGuard
assure le suivi des bibliothèques d'exécution et prend totalement en charge les
applications multithread.
CodeGuard couvre principalement deux domaines :

• Utilisation de la mémoire et des ressources

• Validation des appels de fonctions
Avertissements CodeGuard ( see page 10) CodeGuard signale les cas où votre application accède à de la mémoire au-delà
de la taille maximale d'un tampon. Les avertissements concernent trois types de
fonctions des bibliothèques d'exécution.

1.1.1 Erreurs CodeGuard

CodeGuard signale quatre types d'erreurs d'exécution.

Rubriques
Nom Description
Erreurs d'accès ( see page 4) Les erreurs d'accès proviennent d'une gestion incorrecte de la mémoire.
Lorsque CodeGuard détecte des accès à des blocs mémoire libérés ou à des
objets supprimés, il peut identifier l'endroit où chaque bloc a été alloué et
supprimé. Activez l'option Retarder "Free" dans la boîte de dialogue
Configuration CodeGuard pour utiliser cette fonctionnalité.
Voici les types d'erreurs d'accès possibles :

• Accès à de la mémoire libérée

• Accès dans une pile non initialisée
• Accès dans une pile invalide
Erreurs d'exceptions ( see page 5) Lorsqu'une exception système survient, CodeGuard signale l'erreur d'exécution à
l'aide d'informations données par le système d'exploitation. Si possible, le journal
CodeGuard indique l'endroit où votre application a provoqué l'exception.
CodeGuard n'intercepte pas l'exception, ne la redirige pas et n'interfère en
aucune manière avec le comportement normal du programme.
Les exceptions suivantes illustrent la façon dont CodeGuard signale les
exceptions :

• Erreur de protection générale

• Division par zéro

3
 Erreurs CodeGuard RAD Studio 1.1 Débogage d'applications C++ avec les

Erreurs d'échec de fonction ( see page 6) CodeGuard signale tous les appels de fonctions qui ont échoué, d'après leur
valeur de retour.
Dans l'exemple suivant, la fonction close reçoit un descripteur de fichier invalide
qui la conduit à renvoyer une valeur indiquant qu'elle n'est pas parvenue à fermer
un fichier.
Erreurs de ressources ( see page 7) Les ressources sont des blocs mémoire (alloués par des fonctions telles que
malloc, GlobalAlloc) et des tableaux d'objets, tels que des descripteurs de
fichiers, des descripteurs de flux, des modules et des éléments renvoyés par
new[].
Les exemples d'erreurs d'exécution suivants montrent la manière dont
1 CodeGuard signale une utilisation incorrecte des ressources.

• Paramètre incorrect
• Référence à une ressource libérée
• Incompatibilité entre types de ressources
• Pertes de ressources
• Ressource d'une bibliothèque d'exécution différente

1.1.1.1 Erreurs d'accès

Les erreurs d'accès proviennent d'une gestion incorrecte de la mémoire.

Lorsque CodeGuard détecte des accès à des blocs mémoire libérés ou à des objets supprimés, il peut identifier l'endroit où
chaque bloc a été alloué et supprimé. Activez l'option Retarder "Free" dans la boîte de dialogue Configuration CodeGuard
pour utiliser cette fonctionnalité.

Voici les types d'erreurs d'accès possibles :

• Accès à de la mémoire libérée

• Accès dans une pile non initialisée
• Accès dans une pile invalide
Accès à de la mémoire libérée
Dans l'exemple suivant, CodeGuard identifie la ligne sur laquelle se produit un accès invalide. CodeGuard indique ensuite où le
bloc mémoire a été alloué puis libéré.
Error 00004. 0x100430 (Thread 0xFFF87283):
Access in freed memory: Attempt to access 19 byte(s) at 0x00B423DC.
strcpy(0x00B423DC, 0x004091CA ["Copie vers un bloc libre"])
| lang.cpp line 106:
|
| free(buf_h);
|> strcpy(buf_h, "Copie vers un bloc libre");
|
| //-----------------------//
Call Tree:
0x004011F1(=LANG.EXE:0x01:0001F1) lang.cpp#106
0x00407EE5(=LANG.EXE:0x01:006EE5)

The memory block (0x00B423DC) [size: 21 bytes] was allocated with malloc
| lang.cpp line 80:
| char * pad = (char *) malloc(200);
| // Un tableau dans le tas de la RTL.
|> char * buf_h = (char *) malloc(21);
| char * p;
| // Un tampon de travail.
Call Tree:
0x004011A1(=LANG.EXE:0x01:0001A1) lang.cpp#80
0x00407EE5(=LANG.EXE:0x01:006EE5)

4
1.1 Débogage d'applications C++ avec les RAD Studio Erreurs CodeGuard

The memory block (0x00B423DC) was freed with free

| lang.cpp line 105:
| //-------------//
|
|> free(buf_h);
| strcpy(buf_h, "Copie vers un bloc libre");
|
Call Tree:
0x004011E5(=LANG.EXE:0x01:0001E5) lang.cpp#105
0x00407EE5(=LANG.EXE:0x01:006EE5) 1
Accès dans une pile non initialisée
Dans l'exemple suivant, le pointeur p est devenu incorrect lorsque getBadLocal a été renvoyé après exécution. Aucune
information supplémentaire n'est fournie, car le cadre de pile pour getBadLocal a été automatiquement supprimé.
Error 00005. 0x120400 (Thread 0xFFF87283):
Access in uninitialized stack: Attempt to access 20 byte(s) at 0x0072FC88.
memcpy(0x0072FCC4, 0x0072FC88, 0x14 [20])
| lang.cpp line 112:
| //-----------------------//
| p = getBadLocal();
|> memcpy(buffer, p, 20);
|
| //-------------//
Call Tree:
0x00401208(=LANG.EXE:0x01:000208) lang.cpp#112
0x00407EE5(=LANG.EXE:0x01:006EE5)
Accès dans une pile invalide
Dans l'exemple suivant, une allocation a été effectuée pour buf_s dans la pile. Toutefois, la fonction strcpy écrit juste en
dessous du début de la région valide de la pile. CodeGuard identifie cela comme une erreur même si la longueur de la chaîne de
caractères n'est que d'un octet.
Error 00002. 0x110400 (Thread 0xFFF87283):
Access in invalid stack: Attempt to access 22 byte(s) at 0x0072FD8F.
strcpy(0x0072FD8F, 0x00409188 ["Cette chaîne est longue!\n"])
| LANG.CPP line 93:
|
| // Déficit de pile:
|> strcpy(buf_s -1, "Cette chaîne est longue!\n");
|
| // Débordement des données globales:
Call Tree:
0x004011C5(=LANG.EXE:0x01:0001C5) LANG.CPP#93
0x00407EED(=LANG.EXE:0x01:006EED)

1.1.1.2 Erreurs d'exceptions

Lorsqu'une exception système survient, CodeGuard signale l'erreur d'exécution à l'aide d'informations données par le système
d'exploitation. Si possible, le journal CodeGuard indique l'endroit où votre application a provoqué l'exception. CodeGuard
n'intercepte pas l'exception, ne la redirige pas et n'interfère en aucune manière avec le comportement normal du programme.

Les exceptions suivantes illustrent la façon dont CodeGuard signale les exceptions :

• Erreur de protection générale

• Division par zéro
Erreur de protection générale
Dans l'exemple suivant, CodeGuard fournit des informations sur une erreur de protection générale (exception système Intel
0xD). En plus de l'emplacement du code source qui a provoqué l'exception, le journal indique où la mémoire a été allouée puis

5
 Erreurs CodeGuard RAD Studio 1.1 Débogage d'applications C++ avec les

libérée. La valeur fausse signalée résulte de l'accès à un pattern d'octets que CodeGuard utilise pour identifier des
emplacements mémoire invalides.
Error 00003. 0x400003 (Thread 0x0090):
Exception 0xC0000005: Access violation at 0x80828082.
| gpfault.c line 32:
| {¬
| q = p[3];
|> *q = 1;
| }
1 | }
Call Tree:
0x004010E5(=GPFAULT.EXE:0x01:0000E5) gpfault.c#32
0x00406B29(=GPFAULT.EXE:0x01:005B29)

The bogus value (0x80828082) was most likely retrieved by accessing a(n)
memory block that has already been freed
The memory block (0x008322A4) [size: 16 bytes] was allocated with malloc
| gpfault.c line 17:
| int *q;
|
|> p = malloc(sizeof(*p) * 4);
|
| /* Initialise p */
Call Tree:
0x00401094(=GPFAULT.EXE:0x01:000094) gpfault.c#17
0x00406B29(=GPFAULT.EXE:0x01:005B29)

The memory block (0x008322A4) was freed with free

| gpfault.c line 17:
| int *q;
|
|> p = malloc(sizeof(*p) * 4);
|
| /* Initialise p */
Call Tree:
0x00401094(=GPFAULT.EXE:0x01:000094) gpfault.c#17
0x00406B29(=GPFAULT.EXE:0x01:005B29)
Division par zéro
Dans l'exemple suivant, CodeGuard identifie l'endroit exact dans le code source où la division par zéro s'est produite (exception
système Intel 0x0).
Error 00001. 0x400000 (Thread 0x008B):
Exception 0xC0000094:
| ZERODIV.C line 9:
| {¬
| x = 1;
|> return x / y;
| }
|
Call Tree:
0x0040109C(=ZERODIV.EXE:0x01:00009C) ZERODIV.C#9
0x00406321(=ZERODIV.EXE:0x01:005321)

1.1.1.3 Erreurs d'échec de fonction

CodeGuard signale tous les appels de fonctions qui ont échoué, d'après leur valeur de retour.

Dans l'exemple suivant, la fonction close reçoit un descripteur de fichier invalide qui la conduit à renvoyer une valeur indiquant
qu'elle n'est pas parvenue à fermer un fichier.
Error 00009. 0x820000 (r) (Thread 0xFFF840F1):
Function failure:

6
1.1 Débogage d'applications C++ avec les RAD Studio Erreurs CodeGuard

close(0x80868086 [-2138668922])=0xFFFFFFFF [-1]

| lang.cpp line 125:
| // utilisation de données non initialisées //
| //--------------------------//
|> close(m->handle);
|
|
Call Tree:
0x00401236(=LANG.EXE:0x01:000236) lang.cpp#125
0x00407EED(=LANG.EXE:0x01:006EED)
1
1.1.1.4 Erreurs de ressources
Les ressources sont des blocs mémoire (alloués par des fonctions telles que malloc, GlobalAlloc) et des tableaux d'objets,
tels que des descripteurs de fichiers, des descripteurs de flux, des modules et des éléments renvoyés par new[].

Les exemples d'erreurs d'exécution suivants montrent la manière dont CodeGuard signale une utilisation incorrecte des
ressources.

• Paramètre incorrect
• Référence à une ressource libérée
• Incompatibilité entre types de ressources
• Pertes de ressources
• Ressource d'une bibliothèque d'exécution différente
Paramètre incorrect
Lorsqu'une ressource est transmise à une fonction, CodeGuard vérifie les arguments d'exécution. CodeGuard vous avertit s'il
trouve un paramètre erroné.
Error 00017. 0x310000 (Thread 0xFFF87283):
Bad parameter: A bad file handle (0xEA) has been passed to the function.
close(0xEA [234])
| lang.cpp line 170:
| // utilisation d'un mauvais handle //
| //--------------------//
|> close(234);
|
| //----------------------//
Call Tree:
0x00401456(=LANG.EXE:0x01:000456) lang.cpp#170
0x00407EE5(=LANG.EXE:0x01:006EE5)
Référence à une ressource libérée
Dans l'exemple suivant, CodeGuard signale une tentative de lecture dans un fichier déjà fermé. Le journal CodeGuard montre
où le fichier a été ouvert puis fermé.
Error 00020. 0x310030 (Thread 0xFFF840F1):
Reference to freed resource:
read(0x3 [3], 0x0072FCC4, 0x5 [5])
| lang.cpp line 177:
| int i = open("lang.cpp", 0);
| close(i);
|> read (i, buffer, 5);
|
| //--------------//
Call Tree:
0x00401487(=LANG.EXE:0x01:000487) lang.cpp#177
0x00407EED(=LANG.EXE:0x01:006EED)

The file handle (0x00000003) [name: 'lang.cpp'] was opened with open

7
 Erreurs CodeGuard RAD Studio 1.1 Débogage d'applications C++ avec les

| lang.cpp line 175:

| // utilisation d'un handle libéré //
| //----------------------//
|> int i = open("lang.cpp", 0);
| close(i);
| read (i, buffer, 5);
Call Tree:
0x0040146C(=LANG.EXE:0x01:00046C) lang.cpp#175
0x00407EED(=LANG.EXE:0x01:006EED)

1 The file handle (0x00000003) was closed with close

| lang.cpp line 176:
| //----------------------//
| int i = open("lang.cpp", 0);
|> close(i);
| read (i, buffer, 5);
|
Call Tree:
0x00401477(=LANG.EXE:0x01:000477) lang.cpp#176
0x00407EED(=LANG.EXE:0x01:006EED)
Incompatibilité entre types de ressources
Dans l'exemple suivant, un bloc mémoire alloué avec l'opérateur new[], et qui doit donc être libéré avec l'opérateur delete[], est
libéré à la place par un appel à la fonction free.
Error 00024. 0x350010 (Thread 0xFFF840F1):
Resource type mismatch: a(n) memory block was expected.
free(0x00B42464)
| lang.cpp line 188:
| //---------------//
| char * ss = new char[21];
|> free(ss);
|
| #ifdef __WIN32__
Call Tree:
0x0040149F(=LANG.EXE:0x01:00049F) lang.cpp#188
0x00407EED(=LANG.EXE:0x01:006EED)

The object array (0x00B42464) [size: 21 bytes] was created with new[]
| lang.cpp line 187:
| // incompatibilité de types //
| //---------------//
|> char * ss = new char[21];
| free(ss);
|
Call Tree:
0x00401498(=LANG.EXE:0x01:000498) lang.cpp#187
0x00407EED(=LANG.EXE:0x01:006EED)
Pertes de ressources
Dans l'exemple suivant, de la mémoire a été allouée mais elle n'est jamais libérée.
The memory block (0x00B42310) [size: 200 bytes] was allocated with malloc
| lang.cpp line 78:
| // Un tableau sur la pile.
| char buf_s[21];
|> char * pad = (char *) malloc(200);
| // Un tableau dans le tas de la RTL.
| char * buf_h = (char *) malloc(21);
Call Tree:
0x00401199(=LANG.EXE:0x01:000199) lang.cpp#78
0x00407EE5(=LANG.EXE:0x01:006EE5)
Ressource d'une bibliothèque d'exécution différente
CodeGuard signale une erreur si votre application alloue, utilise ou libère des ressources de différentes versions de la

8
1.1 Débogage d'applications C++ avec les RAD Studio Présentation de CodeGuard

bibliothèque d'exécution. Cela peut arriver, comme le montre l'exemple suivant, si vous effectuez une liaison avec une
bibliothèque d'exécution statique mais que vous appelez une DLL.

Remarque: CodeGuard détecte les incompatibilités entre types de ressources avant de détecter les différences de versions de
la bibliothèque d'exécution. Lorsque les deux types d'erreur sont combinés, CodeGuard ne signale pas les bibliothèques
d'exécution différentes tant que vous n'avez pas corrigé l'incompatibilité entre les types de ressources.

Error 00001. 0x340010 (Thread 0x0062): 1

Resource from different RTL:
close(0x3 [3])
| testdll.cpp line 23:
| {¬
| MessageBox(NULL,"RTLMixHandle: DLL closing EXE handle", "TESTDLL.CPP", MB_OK );
|> close( handle );
| return 1;
| }
Call Tree:
0x0032115A(=testdll.dll:0x01:00015A) testdll.cpp#23
0x00401660(=WINAPI.EXE:0x01:000660) filescg.cpp#33
0x00401271(=WINAPI.EXE:0x01:000271) winapi.cpp#122
0x77EA15B3
0x00408B9A(=WINAPI.EXE:0x01:007B9A)

The file handle (0x00000003) [name: 'test2.dat'] was opened with open
| filescg.cpp line 32:
|
| MessageBox(NULL,"FilesMixCG: Mixing RTL file handles", "FILESCG.CPP", MB_OK );
|> i = open("test2.dat", O_CREAT, S_IREAD | S_IWRITE );
| RTLMixHandle( i );
| }
Call Tree:
0x00401657(=WINAPI.EXE:0x01:000657) filescg.cpp#32
0x00401271(=WINAPI.EXE:0x01:000271) winapi.cpp#122
0x77EA15B3
0x00408B9A(=WINAPI.EXE:0x01:007B9A)

1.1.2 Présentation de CodeGuard

CodeGuard permet de déboguer l'exécution des applications C++ développées avec RAD Studio. CodeGuard signale les
erreurs non détectées par le compilateur parce qu'elles n'outrepassent pas les règles de syntaxe. CodeGuard assure le suivi des
bibliothèques d'exécution et prend totalement en charge les applications multithread.

CodeGuard couvre principalement deux domaines :

• Utilisation de la mémoire et des ressources

• Validation des appels de fonctions
Utilisation de la mémoire et des ressources
CodeGuard vérifie les utilisations incorrectes de la mémoire, les allocations ou les libérations de mémoire incorrectes, les flux ou
les descripteurs de fichiers incorrects et les pertes de ressources provoquées par une utilisation incorrecte des flux ou des
descripteurs de fichiers. CodeGuard vérifie le déférencement des pointeurs et leur arithmétique. CodeGuard peut signaler une
erreur si votre programme tente d'accéder à de la mémoire ou à des ressources qui ont déjà été libérées.

Validation des appels de fonctions

CodeGuard vérifie les arguments d'une fonction et signale l'échec de leur exécution tel qu'il est rapporté par la valeur de retour
de cette fonction. Il valide les descripteurs de ressources Windows utilisés dans les appels de fonctions.

9
 Avertissements CodeGuard RAD Studio 1.1 Débogage d'applications C++ avec les

Voir aussi
Erreurs signalées par CodeGuard ( see page 3)

Avertissements signalés par CodeGuard ( see page 10)

Utilisation de CodeGuard ( see page 58)

1
1.1.3 Avertissements CodeGuard
CodeGuard signale les cas où votre application accède à de la mémoire au-delà de la taille maximale d'un tampon. Les
avertissements concernent trois types de fonctions des bibliothèques d'exécution.

Rubriques
Nom Description
Avertissements pour la comparaison de blocs mémoire ( see page 11) Chacune des fonctions suivantes possède un paramètre qui détermine le nombre
maximal d'octets qu'elle compare :

1. memcmp
2. memicmp
3. _fmemcmp
4. _fmemicmp
Lorsque l'option Avertissements est activée pour les
fonctions de la liste ci-dessus, CodeGuard vérifie qu'une
comparaison peut être effectuée pour chaque bloc
mémoire transmis à la fonction. Si un bloc mémoire est
trop grand (d'après le paramètre transmis à la fonction),
CodeGuard génère un avertissement.
Lorsque l'option Avertissements est activée pour les
fonctions de la liste ci-dessus, CodeGuard vérifie le
premier octet de chaque bloc mémoire transmis à la
fonction. Si le bloc mémoire est invalide, CodeGuard
génère un message d'erreur.... suite ( see page 11)
Avertissements sur la fusion et la scission de noms de chemins ( see page 11) Chacune des fonctions suivantes utilise les constantes définies dans dir.h pour
déterminer le nombre maximal d'octets à copier depuis ou vers un tampon
mémoire :

1. fnmerge
2. fnsplit
3. getcurdir

10
1.1 Débogage d'applications C++ avec les RAD Studio Avertissements CodeGuard

Avertissements de comparaison de chaînes ( see page 12) Chacune des fonctions suivantes possède un paramètre qui détermine le nombre
maximal d'octets qu'elle compare :

• strncmp
• strnicmp
• strncmpi
• _fstrncmp
• _fstrnicmp 1
Lorsque l'option Avertissements est activée pour les
fonctions de la liste ci-dessus, CodeGuard vérifie qu'une
comparaison de chaîne peut être effectuée pour chaque
bloc mémoire transmis à la fonction. Si le tampon est trop
grand (d'après le paramètre transmis à la fonction) et si le
tampon ne possède pas de zéro terminal, CodeGuard
génère un avertissement.
Lorsque l'option Avertissements est activée pour les
fonctions de la liste ci-dessus, CodeGuard vérifie le
premier octet de chaque bloc mémoire transmis à la...
suite ( see page 12)

1.1.3.1 Avertissements pour la comparaison de blocs mémoire

Chacune des fonctions suivantes possède un paramètre qui détermine le nombre maximal d'octets qu'elle compare :

1. memcmp
2. memicmp
3. _fmemcmp
4. _fmemicmp
Lorsque l'option Avertissements est activée pour les fonctions de la liste ci-dessus, CodeGuard vérifie qu'une comparaison
peut être effectuée pour chaque bloc mémoire transmis à la fonction. Si un bloc mémoire est trop grand (d'après le paramètre
transmis à la fonction), CodeGuard génère un avertissement.
Lorsque l'option Avertissements est activée pour les fonctions de la liste ci-dessus, CodeGuard vérifie le premier octet de
chaque bloc mémoire transmis à la fonction. Si le bloc mémoire est invalide, CodeGuard génère un message d'erreur.

1.1.3.2 Avertissements sur la fusion et la scission de noms de

chemins
Chacune des fonctions suivantes utilise les constantes définies dans dir.h pour déterminer le nombre maximal d'octets à
copier depuis ou vers un tampon mémoire :

1. fnmerge
2. fnsplit
3. getcurdir
fnmerge
Si l'option Avertissements est activée, le tampon de sortie est validé par rapport à MAXPATH avant l'appel à fnmerge.

Si l'option Avertissements est désactivée, le tampon de sortie est validé après l'appel à fnmerge à l'aide de la chaîne de
caractères à zéro terminal, pour déterminer sa longueur.

11
 Avertissements CodeGuard RAD Studio 1.1 Débogage d'applications C++ avec les

fnsplit
Si l'option Avertissements est activée, les tampons d'entrée sont validés par rapport à MAXDRIVE, MAXDIR, MAXFILE et
MAXEXT avant l'appel à fnsplit.

Si l'option Avertissements est désactivée, les tampons d'entrée sont validés après l'appel à fnsplit à l'aide de la chaîne de
caractères à zéro terminal, pour déterminer sa longueur.

getcurdir
1
Si l'option Avertissements est activée, le tampon de sortie est validé par rapport à MAXDIR avant l'appel à getcurdir.

Si l'option Avertissements est désactivée, le tampon de sortie est validé après l'appel à getcurdir à l'aide de la chaîne de
caractères à zéro terminal, pour déterminer sa longueur.

1.1.3.3 Avertissements de comparaison de chaînes

Chacune des fonctions suivantes possède un paramètre qui détermine le nombre maximal d'octets qu'elle compare :

• strncmp
• strnicmp
• strncmpi
• _fstrncmp
• _fstrnicmp
Lorsque l'option Avertissements est activée pour les fonctions de la liste ci-dessus, CodeGuard vérifie qu'une comparaison de
chaîne peut être effectuée pour chaque bloc mémoire transmis à la fonction. Si le tampon est trop grand (d'après le
paramètre transmis à la fonction) et si le tampon ne possède pas de zéro terminal, CodeGuard génère un avertissement.
Lorsque l'option Avertissements est activée pour les fonctions de la liste ci-dessus, CodeGuard vérifie le premier octet de
chaque bloc mémoire transmis à la fonction. Si le bloc mémoire est invalide, CodeGuard génère un message d'erreur.

12
1.2 Développement d'applications de RAD Studio

1.2 Développement d'applications de bases de

données pour la plate-forme Win32
Les applications de bases de données permettent aux utilisateurs d'interagir avec les informations stockées dans les bases de
1
données. Les bases de données permettent de structurer les informations et de les partager entre plusieurs applications.

Delphi permet de gérer les applications de bases de données relationnelles. Les bases de données relationnelles organisent les
informations en tables, qui contiennent des lignes (enregistrements) et des colonnes (champs). Ces tables peuvent être
manipulées par des opérations simples appelées calculs relationnels.

Rubriques
Nom Description
Présentation de dbGo ( see page 14) dbGo offre aux développeurs un modèle objet puissant et logique pour accéder
par programme aux données, les éditer et les mettre à jour à partir d'une grande
variété de sources de données par l'intermédiaire d'interfaces système OLE DB.
L'utilisation la plus courante de dbGo consiste à envoyer une requête à une ou
plusieurs tables d'une base de données relationnelle, pour ensuite récupérer les
résultats dans une application et permettre éventuellement aux utilisateurs de
modifier les données et de sauvegarder leurs modifications.
La couche ADO d'une application ADO comprend la dernière version de
Microsoft ADO, un fournisseur OLE ... suite ( see page 14)
Présentation de BDE ( see page 15) Le moteur de bases de données Borland (BDE) est un mécanisme d'accès aux
données pouvant être partagé entre plusieurs applications. Le BDE définit une
puissante bibliothèque d'appels API qui peuvent créer, restructurer, mettre à jour,
interroger ou manipuler des serveurs de bases de données locaux ou distants.
Le BDE fournit une interface uniforme permettant d'accéder à une grande variété
de serveurs, en utilisant des pilotes pour se connecter aux différentes bases de
données. Les composants de la catégorie BDE de la palette d'outils permettent
une connexion aux informations de la base de données avec le BDE.
Durant son déploiement, vous... suite ( see page 15)
Composants dbExpress ( see page 16) dbExpress est un ensemble de composants de base de données légers qui
permettent d'accéder rapidement aux serveurs de base de données SQL. Pour
chaque base de données prise en charge, dbExpress fournit un framework de
pilote qui adapte le logiciel serveur à un ensemble d'interfaces dbExpress
uniformes. Lorsque vous déployez une application de base de données qui
utilise dbExpress, vous incluez une bibliothèque de liaison dynamique (le pilote
propre au serveur) avec les fichiers d'application que vous créez.
dbExpress vous permet d'accéder aux bases de données à l'aide d'ensembles
de données unidirectionnels. Ceux-ci ont été conçus pour un accès léger... suite
( see page 16)
Introduction à InterBase Express ( see page 17) InterBase Express (IBX) est un ensemble de composants d'accès aux données
qui permet d'accéder à des données de bases de données InterBase. Les
composants Administration InterBase, qui requièrent InterBase 6, sont décrits
après les composants d'accès aux données InterBase.
Présentation des nouvelles fonctionnalités de dbExpress 4 ( see page 22) Le framework de niveau supérieur de dbExpress et le support des métadonnées
a été réécrit dans Delphi.
Il comporte un nouveau support de métadonnées enrichi.
Le pilote DbxClient traite à distance l'interface de framework dbExpress 4 sur un
transport réseau.
Ce document traite les fonctionnalités suivantes :

• Framework dbExpress
• Améliorations des métadonnées dbExpress
• Pilote DBXClient
• Pilote DBXDynalink
• DBTest

13
 Présentation de dbGo RAD Studio 1.2 Développement d'applications de

Présentation de la migration BDP ( see page 26) BDP (Borland Data Provider, Fournisseur de données Borland) étant en cours de
dépréciation, n'utilisez pas BDP pour vos nouveaux développements. En
revanche, utilisez AdoDbx Client. Cette rubrique décrit les différences et les
équivalences entre BDP et AdoDbx Client.
En conséquence de la dépréciation de BDP :

• BDP sera retiré du produit dans une future release.

• Il n'y aura pas d'autre développement BDP et seulement
un effort de contrôle qualité (QA) minimal. Seuls les
1 bogues critiques seront corrigés.
• Aucune documentation supplémentaire ne sera fournie et
la documentation existante n'a pas encore été retirée.
BDP était basé sur ADO.NET 1.1. De... suite ( see page 26)
Concepteurs de composants ADO.NET ( see page 30) Presque toutes les applications distribuées se ramènent à lire et actualiser des
informations dans des bases de données. Les applications que vous développez
en utilisant ADO.NET ont des exigences différentes pour manipuler les données.
Vous pouvez, par exemple, développer une application qui affiche simplement
des données dans une fiche. Ou vous pouvez développer une application qui
propose le moyen de partager des informations avec une autre entreprise. Dans
tous les cas, vous devez comprendre certains concepts fondamentaux sur
l'approche des données dans ADO.NET.
En utilisant ces concepteurs, vous pouvez travailler efficacement pour lire,
exposer et modifier des données par l'intermédiaire... suite ( see page 30)
Déploiement d'applications de bases de données pour le .NET Framework ( Pour déployer des applications de bases de données avec RAD Studio, copiez
see page 33) les assemblages d'exécution et les DLL de pilotes pour le déploiement à un
emplacement spécifié. Les sections suivantes indiquent le nom des assemblages
et des DLL et l'emplacement où chacun doit être placé.
Framework dbExpress ( see page 35) Le framework dbExpress (framework DBX) est un ensemble de classes
abstraites fournies dans l'unité DBXCommon. Les applications peuvent
s'interfacer avec le framework de différentes façons : en utilisant le framework
directement pour les applications natives et managées, et en utilisant les
composants dbExpress VCL disposés en couches au sommet du framework
pour les applications natives et managées.
Bien que de nombreuses applications s'interfacent avec les pilotes dbExpress via
les composants dbExpress VCL, le framework DBX offre une option utile et
légère pour communiquer avec un pilote de base de données. Vous pouvez
également créer un pilote de base de... suite ( see page 35)
Compatibilité du framework dbExpress ( see page 37) Certains logiciels dbExpress développés avant le framework de pilote dbExpress
(framework de pilote DBX) ont été modifiés pour fonctionner avec le framework
de pilote DBX. A cause de ces modifications, certains problèmes de compatibilité
se produisent.

1.2.1 Présentation de dbGo

dbGo offre aux développeurs un modèle objet puissant et logique pour accéder par programme aux données, les éditer et les
mettre à jour à partir d'une grande variété de sources de données par l'intermédiaire d'interfaces système OLE DB. L'utilisation
la plus courante de dbGo consiste à envoyer une requête à une ou plusieurs tables d'une base de données relationnelle, pour
ensuite récupérer les résultats dans une application et permettre éventuellement aux utilisateurs de modifier les données et de
sauvegarder leurs modifications.

La couche ADO d'une application ADO comprend la dernière version de Microsoft ADO, un fournisseur OLE DB ou un pilote
ODBC pour l'accès au stockage de données, le logiciel client propre au système de base de données utilisé (dans le cas des
bases de données SQL), un système de base de données dorsal accessible à l'application (dans le cas des systèmes de bases
de données SQL) et une base de données. Tous ces éléments doivent être accessibles à l'application ADO pour que celle-ci soit
totalement opérationnelle.

La catégorie dbGo de la palette d'outils héberge les composants dbGo. Ces composants permettent de se connecter à un
stockage de données ADO, d'exécuter des commandes et d'extraire des données de tables de bases de données utilisant le
modèle ADO. Les composants requièrent la dernière version de ADO sur l'ordinateur hôte. De plus, il faut que le logiciel client

14
1.2 Développement d'applications de RAD Studio Présentation de BDE

pour le système de bases de données cible (par exemple, Microsoft SQL Server) soit installé ainsi qu'un pilote OLE DB ou
ODBC spécifique à ce système de bases de données.

La plupart des composants dbGo ont des homologues directs dans les composants disponibles pour d'autres mécanismes
d'accès aux données : un composant connexion de base de données, TADOConnection et différents types d'ensembles de
données. En outre, dbGo comprend TADOCommand, simple composant qui n'est pas un ensemble de données mais qui
représente une commande SQL à exécuter sur le stockage de données ADO.

Les principaux composants dbGo sont les suivants :

1
Composants Fonction
TADOConnection Composant de connexion de base de données qui établit une connexion avec un stockage de données
ADO.
Plusieurs composants ensembles de données et commandes ADO peuvent partager cette connexion pour
exécuter des commandes, obtenir des données et agir sur des métadonnées.
TRDSConnection Composant de connexion base de données permettant de marshaler les données d'applications de bases
de données multiniveaux élaborées à l'aide de serveurs d'applications ADO.
TADODataSet Ensemble de données de base utilisé pour obtenir et transformer les données.
TADODataSet peut obtenir les données d'une ou de plusieurs tables ; il peut se connecter directement à
un stockage de données ou utiliser un composant TADOConnection.
TADOTable Ensemble de données de type table pour la lecture et la manipulation d'un ensemble d'enregistrements
produit par une table de base de données unique.
TADOTable peut se connecter directement à un stockage de données ou utiliser un composant
TADOConnection.
TADOQuery Ensemble de données de type requête pour la lecture et la manipulation d'un ensemble d'enregistrements
produit par une instruction SQL valide.
TADOQuery peut également exécuter des instructions SQL du langage de définition de données (DDL). Il
peut se connecter directement à un stockage de données ou utiliser un composant TADOConnection.
TADOStoredProc Ensemble de données de type procédure stockée pour l'exécution des procédures stockées.
TADOStoredProc exécute des procédures stockées qui peuvent ou non récupérer des données. Il peut
se connecter directement à un stockage de données ou utiliser un composant TADOConnection.
TADOCommand Composant simple pour l'exécution de commandes (instructions SQL ne renvoyant pas d'ensembles de
résultats).
TADOCommand peut être utilisé avec un composant ensemble de données de prise en charge ou
récupérer un ensemble de données à partir d'une table. Il peut se connecter directement à un stockage de
données ou utiliser un composant TADOConnection.

Voir aussi
Utilisation des composants dbGo ( see page 1522)

1.2.2 Présentation de BDE

Le moteur de bases de données Borland (BDE) est un mécanisme d'accès aux données pouvant être partagé entre plusieurs
applications. Le BDE définit une puissante bibliothèque d'appels API qui peuvent créer, restructurer, mettre à jour, interroger ou
manipuler des serveurs de bases de données locaux ou distants. Le BDE fournit une interface uniforme permettant d'accéder à
une grande variété de serveurs, en utilisant des pilotes pour se connecter aux différentes bases de données. Les composants
de la catégorie BDE de la palette d'outils permettent une connexion aux informations de la base de données avec le BDE.

Durant son déploiement, vous devez inclure le BDE avec votre application. Bien que cela augmente la taille de l'application et la

15
 Composants dbExpress RAD Studio 1.2 Développement d'applications de

complexité du déploiement, le BDE peut être partagé avec d'autres applications BDE et assurer un support plus large pour la
manipulation des bases de données. Même s'il est possible d'utiliser directement l'API du BDE dans votre application, les
composants de la catégorie BDE de la palette d'outils regroupent la plupart de ces fonctionnalités.

Les principaux composants BDE sont les suivants :

Composants Fonction
TTable Récupère les données d'une table physique, via le BDE, et les fournit à un ou plusieurs composants
1 orientés données par le biais d'un composant DataSource. Inversement, envoie les données reçues d'un
composant vers une base de données physique, via le BDE.
TQuery Utilise des instructions SQL pour récupérer les données d'une table physique, via le BDE, et les fournir à un
ou plusieurs composants orientés données par le biais d'un composant DataSource. Inversement, il utilise
des instructions SQL pour envoyer les données reçues d'un composant vers une base de données
physique, via le BDE.
TStoredProc Permet à une application d'accéder à des procédures stockées sur serveur. Il envoie les données reçues
d'un composant vers une base de données physique via le BDE.
TDatabase Met en place une connexion persistante à une base de données, en particulier à une base de données
distante nécessitant un nom de connexion utilisateur et un mot de passe.
TSession Assure le contrôle global d'un groupe de composants de base de données. Un composant TSession par
défaut est créé automatiquement pour chaque application base de données. Vous ne devez utiliser le
composant TSession que si vous créez une application de base de données multithread. Chaque thread de
la base de données doit avoir son propre composant Session.
TBatchMove Copie une structure de table et ses données. Il peut être utilisé pour transformer des tables entières d'un
format de base de données dans un autre.
TUpdateSQL Vous permet d'utiliser le support du cache pour les mises à jour des ensembles de données en lecture
seule.
TNestedTable Récupère les données d'un champ ensemble de données imbriqué et les fournit à des contrôles orientés
données via un composant source de données.

Voir aussi
Utilisation du BDE ( see page 70)

Moteur de bases de données Borland ( see page 2010)

1.2.3 Composants dbExpress

dbExpress est un ensemble de composants de base de données légers qui permettent d'accéder rapidement aux serveurs de
base de données SQL. Pour chaque base de données prise en charge, dbExpress fournit un framework de pilote qui adapte le
logiciel serveur à un ensemble d'interfaces dbExpress uniformes. Lorsque vous déployez une application de base de données
qui utilise dbExpress, vous incluez une bibliothèque de liaison dynamique (le pilote propre au serveur) avec les fichiers
d'application que vous créez.

dbExpress vous permet d'accéder aux bases de données à l'aide d'ensembles de données unidirectionnels. Ceux-ci ont été
conçus pour un accès léger et rapide aux informations de la base, avec des temps système réduits. Comme les autres
ensembles de données, ils peuvent envoyer une commande SQL au serveur de la base de données et, si la commande renvoie
un ensemble d'enregistrements, ils peuvent récupérer ces enregistrements. Les ensembles de données unidirectionnels ne
placent pas les données dans un tampon de mémoire, ce qui les rend plus rapides et moins consommateurs de mémoire que
les autres types d'ensembles de données. Mais, parce qu'ils ne mettent pas les enregistrements dans un tampon, les ensembles
de données unidirectionnels sont moins flexibles que les autres ensembles de données.

16
1.2 Développement d'applications de RAD Studio Introduction à InterBase Express

Les connexions, les tables, les vues et les procédures stockées dbExpress qui apparaissent dans une vue arborescente
prennent en charge les glisser-déplacer avec les fiches vcl managées et natives.

La catégorie dbExpress de la palette d'outils contient les composants qui utilisent dbExpress pour accéder aux informations
d'une base de données. Ce sont :

Composants Fonction
TSQLConnection Encapsule une connexion dbExpress à un serveur de base de données
TSQLDataSet Représente n'importe quelles données disponibles via dbExpress ou permet d'envoyer des 1
commandes à une base de données accessible via dbExpress.
TSQLQuery Un ensemble de données de type requête qui encapsule une instruction SQL et permet aux
applications d'accéder aux enregistrements trouvés, s'il y en a.
TSQLTable Un ensemble de données de type table qui représente toutes les lignes et colonnes d'une table de
base de données
TSQLStoredProc Un ensemble de données de type procédure stockée qui exécute une procédure stockée définie
sur un serveur de bases de données
TSQLMonitor Intercepte les messages transmis entre un composant connexion SQL et un serveur de base de
données, et les enregistre dans une liste de chaînes
TSimpleDataSet Un ensemble de données client qui utilise un TSQLDataSet et un TDataSetProvider internes
pour récupérer des données et appliquer des mises à jour.

Voir aussi
Utilisation de dbExpress ( see page 83)

Utilisation des ensembles de données dbExpress ( see page 1879)

Configuration d'une connexion TSQL ( see page 62)

Utilisation de l'explorateur de données pour obtenir des informations de connexion ( see page 84)

1.2.4 Introduction à InterBase Express

InterBase Express (IBX) est un ensemble de composants d'accès aux données qui permet d'accéder à des données de bases
de données InterBase. Les composants Administration InterBase, qui requièrent InterBase 6, sont décrits après les composants
d'accès aux données InterBase.

Composants IBX
Les composants suivants sont situés sur l'onglet InterBase de la palette des composants.

TIBTable

TIBQuery

TIBStoredProc

TIBDatabase

TIBTransaction

TIBUpdateSQL

TIBDataSet

17
 Introduction à InterBase Express RAD Studio 1.2 Développement d'applications de

TIBSQL

TIBDatabaseInfo

TIBSQLMonitor

TIBEvents

TIBExtract
1
TIBCustomDataSet

Bien que leurs noms soient similaires à ceux des composants BDE, les composants IBX sont quelque peu différents. Les
sections ci-dessous présentent ces différences pour les composants ayant un équivalent BDE.

Il n'existe pas de migration simple d'applications BDE vers des applications IBX. Vous devrez généralement remplacer les
composants BDE par les composants IBX comparables, puis recompiler vos applications. Toutefois, la vitesse gagnée et les
puissantes fonctionnalités InterBase auxquelles vous pouvez alors accéder justifient pleinement la migration.

IBDatabase

Utilisez un composant TIBDatabase pour établir des connexions à des bases de données susceptibles d'impliquer une ou
plusieurs transactions simultanées. A la différence de BDE, IBX possède un composant transaction distinct qui permet de
séparer les transactions des connexions de base de données.

Pour définir une connexion de base de données :

1. Déposez un composant IBDatabase sur une fiche ou un module de données.

2. Initialisez la propriété DatabaseName. Pour une connexion locale, il s'agit du lecteur, du chemin et du nom du fichier de la
base de données. Initialisez la propriété Connected à true.
3. Entrez un nom d'utilisateur et un mot de passe corrects puis cliquez sur OK pour établir la connexion à la base de données.
Avertissement: Astuce : Vous pouvez stocker le nom de l'utilisateur et son mot de passe dans la propriété Params du
composant IBDatabase en initialisant la propriété LoginPrompt à false après l'ouverture de la session. Par exemple, après
avoir ouvert une session en tant qu'administrateur système et avoir initialisé la propriété LoginPrompt à false, vous pourrez
voir les informations suivantes en éditant la propriété Params :

user_name=sysdba
password=masterkey
IBTransaction

A la différence de Borland Database Engine, IBX contrôle les transactions avec un composant séparé, TIBTransaction. Cette
fonctionnalité puissante vous permet de séparer les transactions des connexions de base de données pour pouvoir bénéficier du
mécanisme de validation à deux phases d'InterBase (les transactions s'étendant sur plusieurs connexions) et de plusieurs
transactions simultanées utilisant la même connexion.

Utilisez un composant IBTransaction pour gérer les contextes de transactions, qui peuvent mettre en jeu une ou plusieurs
connexions de base de données. Dans la plupart des cas, un modèle simple avec une base de données et une transaction fera
l'affaire.

Pour définir une transaction :

1. Définissez une connexion IBDatabase comme décrit ci-dessus.

2. Déposez un composant IBTransaction sur la fiche ou le module de données.
3. Affectez à la propriété DefaultDatabase le nom de votre composant IBDatabase.
4. Initialisez la propriété Active à true pour démarrer la transaction.

18
1.2 Développement d'applications de RAD Studio Introduction à InterBase Express

Composants ensemble de données IBX

Il existe plusieurs composants ensembles de données parmi lesquels vous pouvez faire votre choix avec IBX ; chacun possède
ses caractéristiques propres et est adapté à des tâches particulières :
IBTable
Utilisez un composant TIBTable pour définir un ensemble de données dynamique sur une table ou une vue sans avoir à entrer
d'instructions SQL.
Les composants IBTable sont faciles à configurer :
1
1. Ajoutez un composant IBTable à votre fiche ou votre module de données.
2. Spécifiez les composants base de données et transaction associés.
3. Spécifiez le nom de la relation à partir de la liste déroulante TableName.
4. Initialisez la propriété Active à true.
IBQuery
Utilisez un composant TIBQuery pour exécuter n'importe quelle instruction DSQL InterBase, restreindre votre ensemble de
résultats à certaines colonnes et certaines lignes, utiliser des fonctions d'agrégation et effectuer des jointures entre plusieurs
tables.
Les composants IBQuery fournissent un ensemble de données en lecture seule et s'adaptent bien à l'environnement
client-serveur d'InterBase. Pour définir un composant IBQuery :
1. Définissez une connexion IBDatabase comme décrit ci-dessus.
2. Définissez une connexion IBTransaction comme décrit ci-dessus.
3. Ajoutez un composant IBQuery à votre fiche ou votre module de données.
4. Spécifiez les composants base de données et transaction associés.
5. Entrez dans l'éditeur de listes de chaînes une instruction SQL valide pour la propriété SQL du composant IBQuery.
6. Initialisez la propriété Active à true.
IBDataSet
Utilisez un composant TIBDataSet pour exécuter n'importe quelle instruction DSQL InterBase, restreindre votre ensemble de
résultats à certaines colonnes et certaines lignes, utiliser des fonctions d'agrégation et effectuer des jointures entre plusieurs
tables. Les composants IBDataSet sont similaires aux composants IBQuery, mis à part qu'ils prennent en charge les
ensembles de données dynamiques sans nécessiter un composant IBUpdateSQL.
L'exemple suivant fournit un ensemble de données dynamique pour la table COUNTRY dans employee.gdb :
1. Définissez une connexion IBDatabase comme décrit ci-dessus.
2. Spécifiez les composants base de données et transaction associés.
3. Ajoutez un composant IBDataset à votre fiche ou votre module de données.
4. Entrez des instructions SQL pour les propriétés suivantes :

SelectSQL SELECT Country, Currency FROM Country

RefreshSQL SELECT Country, Currency FROM Country WHERE Country = :Country
ModifySQL UPDATE Country SET Country = :Country, Currency = :Currency WHERE Country = :Old_Country
DeleteSQL DELETE FROM Country WHERE Country = :Old_Country
InsertSQL INSERT INTO Country (Country, Currency) VALUES (:Country, :Currency)

1. Initialisez la propriété Active à true.

2.

19
 Introduction à InterBase Express RAD Studio 1.2 Développement d'applications de

Remarque: Remarque : Les paramètres et les champs transmis aux fonctions sont sensibles à la casse dans le dialecte 3.
Par exemple,

FieldByName(EmpNo)
ne renvoie rien dans le dialecte 3 si le champ est spécifié sous la forme 'EMPNO'.

IBStoredProc
1 Utilisez TIBStoredProc pour les procédures exécutables InterBase : les procédures qui renvoient au plus une ligne
d'informations. Pour les procédures stockées renvoyant plus d'une ligne de données ou les procédures "Select", utilisez des
composants IBQuery ou IBDataSet.

IBSQL

Utilisez un composant TIBSQL pour les opérations qui doivent être rapides et légères. Des opérations telles que la définition de
données et la copie de données d'une base de données vers une autre sont bien adaptées aux composants IBSQL.

Dans l'exemple suivant, un composant IBSQL est utilisé pour renvoyer la valeur suivante à partir d'un générateur :

1. Définissez une connexion IBDatabase comme décrit ci-dessus.

2. Positionnez un composant IBSQL sur la fiche ou le module de données et affectez le nom de la base de données à sa
propriété Database.
3. Ajoutez une instruction SQL dans l'éditeur de listes de chaînes pour la propriété SQL, par exemple :
SELECT GEN_ID(MyGenerator, 1) FROM RDB$DATABASE
IBUpdateSQL

Utilisez un composant TIBUpdateSQL pour mettre à jour des ensembles de données en lecture seule. Vous pouvez mettre à
jour une sortie IBQuery avec un composant IBUpdateSQL :

1. Définissez un composant IBQuery comme décrit ci-dessus.

2. Ajoutez un composant IBUpdateSQL à votre fiche ou votre module de données.
3. Entrez des instructions SQL pour les propriétés suivantes : DeleteSQL, InsertSQL, ModifySQL et RefreshSQL.
4. Affectez le nom du composant IBUpdateSQLà la propriété UpdateObject du composant IBQuery.
5. Initialisez la propriété Active du composant IBQuery à true.
IBSQLMonitor
Utilisez un composant TIBSQLMonitor pour développer des outils de diagnostic permettant de surveiller les communications
entre votre application et le serveur InterBase. Quand les propriétés TraceFlags d'un composant IBDatabase sont activées,
les composants TIBSQLMonitor actifs peuvent surveiller l'activité de la connexion et envoyer le résultat vers un fichier ou un
contrôle.
Un bon exemple consisterait à créer une application séparée avec un composant TIBSQLMonitor et un contrôle Memo. Lancez
cette deuxième application, puis dans l'application principale, activez les propriétés TraceFlags du composant IBDatabase.
Travaillez avec l'application principale et observez le contrôle Memo de la deuxième application se remplir de données.
IBDatabaseInfo
Utilisez un composant TIBDatabaseInfo pour lire des informations sur une base de données particulière, comme son intervalle
de nettoyage, sa version ODS et les noms des utilisateurs actuellement connectés à cette base de données.
Par exemple, pour définir un composant IBDatabaseInfo affichant les utilisateurs actuellement connectés à la base de données,
procédez comme suit :
1. Définissez une connexion IBDatabase comme décrit ci-dessus.
2. Placez un composant IBDatabaseInfo sur la fiche ou le module de données et affectez à sa propriété Database le nom de la
base de données.
3. Placez un composant Memo sur la fiche.

20
1.2 Développement d'applications de RAD Studio Introduction à InterBase Express

4. Placez un composant Timer sur la fiche et définissez son intervalle.

5. Double-cliquez sur le champ de l'événement OnTimer du composant Timer et entrez un code de la forme :
Memo1.Text := IBDatabaseInfo.UserNames.Text; // Exemple Delphi
Memo1->Text = IBDatabaseInfo->UserNames->Text; // Exemple C++
IBEvents

Utilisez un composant IBEvents pour demander la notification et traiter de manière asynchrone les événements transmis par un
serveur InterBase.
1
Pour définir un composant IBEvents :

1. Définissez une connexion IBDatabase comme décrit ci-dessus.

2. Positionnez un composant IBEvents sur la fiche ou le module de données et affectez le nom de la base de données à sa
propriété Database.
3. Entrez des événements dans l'éditeur de listes de chaînes de la propriété Events, par exemple :
IBEvents.Events.Add('EVENT_NAME'); // Exemple Delphi
IBEvents->Events->Add("EVENT_NAME"); // Exemple C++
1. 4. Initialisez la propriété Registered à true.
2. Composants Administration InterBase
Si vous avez installé InterBase 6, vous pouvez utiliser les composants Administration InterBase 6, qui vous permettent d'accéder
aux puissants appels à l'API des services InterBase.
Les composants suivants sont situés sur l'onglet d'administration d'InterBase de l'EDI :

TIBConfigService

TIBBackupService

TIBRestoreService

TIBValidationService

TIBStatisticalService

TIBLogService

TIBSecurityService

TIBLicensingService

TIBServerProperties

TIBInstall

TIBUnInstall

Remarque : Pour utiliser ces fonctionnalités, vous devez installer InterBase 6.

IBConfigService

Utilisez un objet TIBConfigService pour configurer les paramètres d'une base de données, y compris les tampons de pages, le
mode asynchrone, l'espace de réserve et l'intervalle de balayage.

IBBackupService

Utilisez un objet TIBBackupService pour effectuer une copie de sauvegarde de votre base de données. Cet objet vous permet
de définir des paramètres tels que le facteur de blocage, le nom du fichier de sauvegarde et les options de sauvegarde de la
base de données.

IBRestoreService

21
 Présentation des nouvelles fonctionnalités RAD Studio 1.2 Développement d'applications de

Utilisez un objet TIBRestoreService pour restaurer votre base de données. Cet objet vous permet de définir des options telles
que les tampons de pages, la taille des pages et les options de restauration de la base de données.

IBValidationService

Utilisez un objet TIBValidationService pour valider votre base de données et réconcilier vos transactions de base de données.
Cet objet vous permet de définir l'action de transaction par défaut, de renvoyer des informations sur les transactions limbo et de
définir d'autres options de validation de la base de données.

1 IBStatisticalService

Utilisez un objet TIBStatisticalService pour afficher les statistiques sur la base de données, par exemple les pages de données,
le journal de la base de données, les pages d'en-tête, les pages d'index et les relations système.

IBLogService

Utilisez un objet TIBLogService pour créer un fichier journal.

IBSecurityService

Utilisez un objet TIBSecurityService pour gérer l'accès des utilisateurs au serveur InterBase. Cet objet vous permet de créer, de
supprimer et de modifier des comptes utilisateur, d'afficher tous les utilisateurs et de définir des groupes de travail en utilisant
des rôles SQL.

IBLicensingService

Utilisez un composant TIBLicensingService pour ajouter ou supprimer des certificats d'activation logiciels InterBase.

IBServerProperties

Utilisez un composant TIBServerProperties pour renvoyer des informations sur le serveur, y compris les paramètres de
configuration, les informations relatives à la version et à la licence.

IBInstall

Utilisez un composant TIBInstall pour définir un composant d'installation InterBase, y compris les répertoires d'installation source
et de destination et les composants à installer.

IBUnInstall

Utilisez un composant TIBUnInstall pour définir un composant de désinstallation.

1.2.5 Présentation des nouvelles fonctionnalités de

dbExpress 4
Le framework de niveau supérieur de dbExpress et le support des métadonnées a été réécrit dans Delphi.

Il comporte un nouveau support de métadonnées enrichi.

Le pilote DbxClient traite à distance l'interface de framework dbExpress 4 sur un transport réseau.

Ce document traite les fonctionnalités suivantes :

• Framework dbExpress
• Améliorations des métadonnées dbExpress
• Pilote DBXClient
• Pilote DBXDynalink

22
1.2 Développement d'applications de RAD Studio Présentation des nouvelles fonctionnalités

• DBTest
Framework dbExpress

VCL
L'implémentation du composant VCL dbExpress a été modifiée avec des changements minimaux de l'API. La plupart des
applications ne sont pas affectées par les modifications apportées à la bibliothèque VCL dbExpress. Toutefois, des méthodes,
propriétés, événements, constantes et énumérations sont nouvelles. 1

Compatibilité d'interface de l'unité DBXCommon (classes "Ex")

Dans l'unité DbxCommon, plusieurs nouvelles classes étendent des classes existantes et ont le suffixe "Ex". Des classes
temporaires ont été introduites pour éviter d'interrompre la compatibilité d'interface avec les versions livrées début 2007. Dans la
prochaine release, ces méthodes et champs supplémentaires seront déplacés vers la version non-Ex des classes.

Améliorations des métadonnées dbExpress

Les métadonnées dbExpress 3 n'étaient pas assez riches pour les outils de base de données et ne prenaient pas en charge
tous les types de métadonnée attendus depuis un pilote ADO.NET 2.0. De nouveaux fournisseurs de métadonnées fournissent
des capacités accrues.

De nouveaux fournisseurs de métadonnées pour 9 dorsaux de base de données différents sont entièrement écrits dans Delphi.
Le code source complet de tous les fournisseurs de métadonnées est inclus dans le produit.

Séparation des capacités de lecture et d'écriture des métadonnées

Chaque fournisseur est composé d'une implémentation de lecteur et d'écrivain de métadonnée. Les lecteurs de métadonnée
résident dans le nouveau package DbxReadOnlyMetaData et les écrivains de métadonnée se trouvent dans le package
DbxMetaData. Les pilotes dbExpress et le nouveau pilote AdoDbx client ADO.NET ne nécessitent que les capacités de lecteur
de métadonnée. De nombreuses applications de base de données ont seulement besoin de lire les métadonnées, pas de les
écrire. En séparant les capacités de lecture et d'écriture, la taille des déploiements d'applications sont réduites.

Approche basée sur les fournisseurs

Les fournisseurs de métadonnées sont détachés du pilote, de telle sorte qu'un fournisseur de métadonnée peut être utilisé pour
plusieurs implémentations de pilote tant que le dorsal de base de données reste le même. L'explorateur de données profite
également des fournisseurs de métadonnées pour fournir le support des métadonnées à d'autres pilotes ADO.NET de base de
données.

Le fournisseur n'est pas lié à un pilote, mais à un dorsal de base de données. La nouvelle propriété
TDBXPropertyNames.MetaDataPackageLoader des fichiers dbxdrivers.ini peut être définie sur un objet TDBXCommandFactory.
Cette implémentation de fabrique de commande crée un TDBXCommand pouvant exécuter des commandes de métadonnée.
Cette approche permet à plusieurs implémentations de pilotes d'un dorsal de base de données spécifique d'utiliser le même
fournisseur de métadonnées. L'explorateur de données profite également de cette architecture pour fournir des métadonnées
structurées dbExpress 4 pour les pilotes ADO.NET des autres fournisseurs. Le découplage du pilote et du fournisseur de
métadonnées permet des implémentations de pilotes "légères". Si les commandes des métadonnées peuvent être traitées sur
un serveur, il n'est pas nécessaire d'avoir la logique de fournisseur de métadonnées sur le client.

Répertoire source du fournisseur

Il existe plusieurs répertoires pour le code source du fournisseur de métadonnées. Les unités ayant un intérêt pour les
applications ont été placées dans le répertoire "provider". Les applications doivent éviter de créer des dépendances sur les
unités hors de ce répertoire. Toutefois, les implémenteurs de métadonnées dbExpress doivent se développer à partir de classes
de base de lecteur et d'écrivain abstraites situées hors du répertoire provider.

23
 Présentation des nouvelles fonctionnalités RAD Studio 1.2 Développement d'applications de

Lecture des métadonnées

La nouvelle unité DBXMetaDataNames a été fournie pour lire les métadonnées. La classe dbExpress existante
TDBXMetaDataCommands fournit un ensemble de constantes pour lire divers types de métadonnées. Définissez la propriété
TDBXCommand.CommandType sur TDBXCommandTypes.DBXMetadata et définissez TDBXCommand.Text sur une des
constantes de TDBXMetaDataCommands pour acquérir la métadonnée désignée. TDBXCommand.ExecuteQuery renvoie un
TDBXReader pour accéder à la métadonnée. Les nouvelles classes de DBXMetaDataNames décrivent et fournissent un accès
1 aux colonnes de cette métadonnée.

Ecriture des métadonnées

Le support de la création des instructions CREATE, ALTER et DROP sensibles au dialecte SQL est fourni dans l'explorateur de
données. dbExpress expose également une classe DbxMetaDataProvider qui couvre cette capacité pour les applications. Cela
augmente légèrement la taille de l'application, puisque les écrivains de métadonnées doivent être inclus. La capacité de création
générique des tables est utile pour de nombreuses applications. L'interface vous permet de décrire l'aspect d'une table et de ses
colonnes et de passer cette description à la méthode TdbxMetaDataProvider.CreateTable. Voici un exemple simple qui montre
comment créer une table avec une colonne int32 nommée "C1", un décimal avec une précision de 10 et une échelle de 2
nommé "C2", et une colonne basée sur les caractères avec une précision de 32 nommée "C3".
var
MetaDataTable: TDBXMetaDataTable;
DataGenerator: TDbxDataGenerator;
Command: TDBXCommand;
Row: Integer;
begin
MetaDataTable := TDBXMetaDataTable.Create;
MetaDataTable.TableName := 'QCXXX_TABLE';
MetaDataTable.AddColumn(TDBXInt32Column.Create('C1'));
MetaDataTable.AddColumn(TDBXDecimalColumn.Create('C2', 10, 2));
MetaDataTable.AddColumn(TDBXUnicodeCharColumn.Create('C3', 32));
MetaDataProvider.CreateTable(MetaDataTable);
end
Remarque: DBXMetaDataProvider est seulement supporté pour le code managé sur la plate-forme .NET.

Déploiement
Pour le déploiement basé sur les packages, les packages suivants doivent être inclus :

• Borland.Data.DBXClient.dll
• Borland.Data.DBXReadOnlyMetaData.dll
• Borland.Data.DBXCommonDriver.dll
• Borland.Data.DBXMetaData.dll

Création de nouveaux fournisseurs de métadonnées

La plus grande partie du travail dans la création de nouveaux fournisseurs de métadonnées est l'extension des classes de base
abstraites TDBXMetaDataReader et TDBXMetaDataWriter.

Compatibilité
Les composants VCL de l'unité SqlExpr travaillent toujours avec des pilotes qui fournissent les métadonnées dbExpress 3 plus
limitées. Toutefois, l'explorateur de données travaille seulement avec les métadonnées dbExpress 4.

Notez que Delphi inclut des métadonnées pour 9 dorsaux de base de données différents. Toute implémentation de pilote
dbExpress pour les 9 dorsaux supportés peuvent ainsi réutiliser le fournisseur de métadonnées avec leur implémentation de
pilote.

24
1.2 Développement d'applications de RAD Studio Présentation des nouvelles fonctionnalités

Pilote DBXClient
DBXClient est un pilote dbExpress 4 léger qui traite à distance l'interface de framework dbExpress 4 sur un transport réseau
pluggable. Dans cette release, un protocole de transport TCP/IP est pris en charge. Le pilote utilise un protocole de flux
JSON/RPC (Java Script Object Notation).

Le DBXClient est implémenté en 100% Pascal Objet. Son code source est inclus dans le produit.

Blackfish SQL 1
Dans cette release, DBXClient peut seulement se connecter à Blackfish SQL. Blackfish SQL est une version Delphi pour .NET
du JDataStore de JBuilder.

Pour utiliser le pilote DBXClient avec Blackfish SQL, ajoutez l'unité DBXClient à la clause uses.

Déploiement
DBXClient ne nécessite pas l'installation d'une bibliothèque client de base de données lors du déploiement de votre application.
DBXClient est 100% Delphi et peut être directement lié dans votre application sous forme d'un fichier .exe unique.

Si vous préférez utiliser un déploiement basé sur les packages, vous devez inclure les packages suivants :

• DBXClient100.bpl
• DBXReadOnlyMetaData100.bpl
• DBXCommonDriver100.bpl
Pilote DBXDynalink
L'unité de pilote DBXDynalink a été déplacée du package DBXCommonDriver vers le package DBXDynalinkDriver. Avec
l'introduction du pilote DBXClient, CodeGear fournit à présent des pilotes non-Dynalink.

Nouvelles unités
De nouvelles unités ont été ajoutées dans le package DbxDynalinkDriver pour les 8 pilotes Dynalink :

• DBXDb2
• DBXInformix
• DBXInterbase
• DBXMsSql
• DBXMySql
• DBXOracle
• DBXSybaseASA
• DBXSybaseASE

Déploiement
Les pilotes Dynalink peuvent être liés dans un exécutable unique, mais vous devez toujours déployer les bibliothèques Dynalink
elles-mêmes et les bibliothèques client du fournisseur de base de données.

Pour le déploiement basé sur les packages, les packages suivants doivent être inclus :

• DBXCommonDriver100.bpl
• DBXReadOnlyMetaData100.bpl
• DBXDynalinkDriver100.bpl

25
 Présentation de la migration BDP RAD Studio 1.2 Développement d'applications de

Pour le déploiement basé sur les packages sur la plate-forme .NET, les assemblages suivants doivent être inclus :
• Borland.Data.DBXCommonDriver.dll
• Borland.Data.DBXReadOnlyMetaData.dll
• Borland.Data.DBXDynalinkDriver.dll
DBTest
C'est une collection de classes qui étendent les capacités de Dunit afin de faciliter le test des bases de données. Les tests Dunit
1 exemple qcreport et cts fournissent de bons exemples sur l'utilisation de DBTest. TestCaseExtension contient les extensions
non-base de données à Dunit et l'unité DBXTest contient les extensions base de données.

Propriétés de ligne de commande

De nouvelles unités ont été ajoutées au package DbxDynalinkDriver pour les 8 pilotes Dynalink :

Sélection de test
La ligne de commande -s:<TestName> peut être utilisée pour exécuter une seule méthode dans un cas de test Dunit. Cela est
utile pour déboguer un seul bogue. Voir l'unité TestCaseExtension.

Méthodes pratiques
Plusieurs méthodes permettent de créer une connexion par défaut et un fournisseur de métadonnées. Voir l'unité DBXTest.

Générateur de données
Il existe également un générateur de données simple et extensible. Voir l'unité DBXDataGenerator.

Voir aussi
Framework dbExpress ( see page 35)

TDBXMetaDataCommands

TDBXMetaDataCommands

1.2.6 Présentation de la migration BDP

BDP (Borland Data Provider, Fournisseur de données Borland) étant en cours de dépréciation, n'utilisez pas BDP pour vos
nouveaux développements. En revanche, utilisez AdoDbx Client. Cette rubrique décrit les différences et les équivalences entre
BDP et AdoDbx Client.

En conséquence de la dépréciation de BDP :

• BDP sera retiré du produit dans une future release.

• Il n'y aura pas d'autre développement BDP et seulement un effort de contrôle qualité (QA) minimal. Seuls les bogues critiques
seront corrigés.
• Aucune documentation supplémentaire ne sera fournie et la documentation existante n'a pas encore été retirée.
BDP était basé sur ADO.NET 1.1. De nombreuses fonctionnalités différentes de BDP, comme l'indépendance du fournisseur et
les métadonnées étendues, ont été ajoutées à ADO.NET 2 en utilisant différentes approches, incompatibles avec BDP. En
outre, ADO.NET 2 utilise les classes de base abstraites et a déprécié les interfaces ADO.NET 1.1. Cela a rendu difficilement
applicable l'extension de BDP à ADO.NET 2.0.
AdoDbx Client est basé sur ADO.NET 2.0 et fournit la plupart des capacités de BDP.
BDP est constitué de trois espaces de nommage :

26
1.2 Développement d'applications de RAD Studio Présentation de la migration BDP

Espace de nommage Description

de BDP

Borland.Data.Common Contient les objets communs à tout BDP.NET, y compris les classes d'erreur et d'exception, les
énumérations de type de données, les options de fournisseur et les interfaces pour concevoir vos
propres classes commande, connexion et curseur.
Borland.Data.Provider Contient les classes BDP.NET essentielles comme BdpCommand, BdpConnection, BdpDataAdapter,
BdpDataReader et d'autres qui permettent d'interagir avec des sources de données externes comme 1
les serveurs de bases de données Oracle, DB2, Interbase et MS SQL Server.
Borland.Data.Schema Contient les interfaces permettant de construire vos propres classes de manipulation de schéma de
base de données ainsi que divers types et énumérateurs définissant des métadonnées.

Ce document décrit la migration pour chacun de ces espaces de nommage.

Migration Borland.Data.Provider
Deux classes de cet espace de nommage fournissent la gestion distante des données et n'ont pas été dépréciées. Elles ne
nécessitent donc pas de migration, ce sont :

• DataHub
• DataSync

Classes correspondantes dans BDP et AdoDbx Client

La plupart des classes BDP de cet espace de nommage sont des implémentations des classes ADO.NET. Ces classes sont
également implémentées dans AdoDbx Client. La plupart du code source utilisant ces classes devrait être converti en AdoDbx
Client avec un effort minimal.

Le tableau suivant présente la correspondance entre les classes ADO.NET, BDP et AdoDbx Client :

ADO.NET BDP.NET Client AdoDbx

DbCommand BdpCommand TAdoDbxCommand
DbCommandBuilder BdpCommandBuilder TAdoDbxCommandBuilder
DbConnection BdpConnection TAdoDbxConnection
DbDataAdapter BdpDataAdapter TAdoDbxDataAdapter
DbDataReader BdpDataReader TAdoDbxDataReader
DbTransaction BdpTransaction TAdoDbxTransaction

La conversion des classes BDP de ce groupe est plutôt simple. Consultez la documentation pour voir si la méthode utilisée est
prise en charge dans la classe AdoDbx Client correspondante. Si elle l'est, vous n'avez probablement rien à faire. Si la méthode
n'est pas prise en charge, vous devez alors modifier votre code afin d'utiliser les méthodes prises en charge dans AdoDbx Client
ou ADO.NET lui-même.

Par exemple, la classe BdpDataReader accède aux enregistrements de base de données. La plupart de ses méthodes d'accès
aux données ont des méthodes TAdoDbxDataReader correspondantes, comme décrit à la section ISQLCursor.
BdpDataReader.GetSchemaTable peut être utilisée pour récupérer la métadonnée curseur en tant que DataTable.
Reportez-vous à la section ISQLExtendedMetaData et ISQLMetaData pour obtenir la description d'un accès aux métadonnées
pour AdoDbx Client.

Classes BDP sans classes AdoDbx Client correspondantes

La classe BdpCopyTable n'a pas de classe correspondante dans AdoDbx Client. Cette capacité n'est donc pas disponible dans

27
 Présentation de la migration BDP RAD Studio 1.2 Développement d'applications de

AdoDbx Client.

Migration Borland.Data.Common
Cet espace de nommage a sept classes et trois interfaces.

BdpConnectionString
La classe TAdoDbxConnection a une propriété ConnectionString. Cette classe prend également en charge le pooling de
connexion.
1
BdpError et BdpErrorCollection
Comme toutes les erreurs sont gérées comme des exceptions dans la classe TAdoDbxException de AdoDbx Client, ces classes
ne sont donc pas nécessaires.

BdpException, BdpParameter et BdpParameterCollection

Ces classes sont des implémentations des classes ADO.NET. Ces classes sont également implémentées dans AdoDbx Client.
La plupart du code source utilisant ces classes devrait être converti en AdoDbx Client avec un effort minimal.

La conversion des classes BDP de ce groupe est plutôt simple. Consultez la documentation pour voir si la méthode utilisée est
prise en charge dans la classe AdoDbx Client correspondante. Si elle l'est, vous n'avez probablement rien à faire. Si la méthode
n'est pas prise en charge, vous devez alors modifier votre code afin d'utiliser les méthodes prises en charge dans AdoDbx Client
ou ADO.NET lui-même.

Le tableau suivant présente la correspondance entre les classes ADO.NET, BDP et AdoDbx Client :

ADO.NET BDP.NET Client AdoDbx

DbException BdpException TAdoDbxException
DbParameter BdpParameter TAdoDbxParameter
DbParameterCollection BdpParameterCollection TAdoDbxParameterCollection

DbResolver
DbResolver est une implémentation de l'interface ISQLResolver de l'espace de nommage Borland.Data.Schema, décrite plus
loin dans cette rubrique.

ISQLCommand, IAQLConnection et ISQLCursor

Ces interfaces sont principalement utilisées par les concepteurs de pilotes et il n'y a pas d'équivalent AdoDbx Client. Vous
devrez réécrire le pilote à l'aide du framework dbExpress.

Migration Borland.Data.Schema
Cet espace de nommage contient cinq interfaces.

ISQLDataSource
La méthode GetProviders renvoie une liste des fournisseurs de données. Une capacité similaire est fournie par
TAdoDbxProviderFactory.CreateDataSourceEnumerator, qui crée un énumérateur pour tous les fournisseurs. Il n'y a pas
d'analogie pour les méthodes GetConnections et GetDbObjectTypes dans AdoDbx Client.

ISQLExtendedMetaData et ISQLMetaData
Utilisez la méthode GetSchema de TAdoDbxConnection pour obtenir une collection de métadonnées. Le paramètre Name de
GetSchema spécifie le type de métadonnée à obtenir. Les noms standard supportés par DbConnection.GetSchema sont pris en

28
1.2 Développement d'applications de RAD Studio Présentation de la migration BDP

charge dans AdoDbx Client.

En outre, vous pouvez spécifier une des constantes de nom dans TDBXMetaDataCollectionName pour obtenir une collection de
métadonnées particulière. Vous pouvez ensuite utiliser la classe correspondante dans l'espace de nommage
DBXMetaDataNames pour obtenir les informations de colonne que vous voulez pour cette collection de métadonnées.

Par exemple, pour obtenir le code source de procédure d'une base de données, utilisez la constante ProcedureSources pour
obtenir un DataTable avec les informations de source de procédure. Utilisez les classes TDBXProcedureSourcesColumns et
TDBXProcedureSourcesIndex de DBXMetaDataNames avec le DataTable renvoyé pour accéder aux informations de source de
procédure par nom ou ordinal.
1

ISQLResolver
Cette classe résout les commandes SQL.

L'analogie la plus proche est la classe TAdoDbxDataAdapter pour les méthodes ISQLResolver. Ce tableau présente les
propriétés qui correspondent aux méthodes.

ISQLResolver TAdoDbxDataAdapter
Méthode GetDeleteSQL Propriété DeleteCommand
Méthode GetInsertSQL Propriété InsertCommand
GetSelectSQL Propriété SelectCommand
GetUpdateSQL Propriété UpdateCommand

Pour les propriétés ISQLResolver, les analogies les plus proches sont les propriétés que TAdoDbxCommandBuilder hérite de la
classe ADO.NET DbCommandBuilder et une propriété TAdoDbxDataReader.

ISQLResolver Client AdoDbx

Propriété QuotePrefix Propriété TAdoDbxCommandBuilder.QuotePrefix
Propriété QuoteSuffix Propriété TAdoDbxCommandBuilder.QuoteSuffix
Propriété Row Propriété TAdoDbxDataReader.Item

ISQLSchemaCreate
Cette interface vous permet de créer un schéma de base de données dans votre propre fournisseur. Le client AdoDbx n'offre
pas cette capacité.

Voir aussi
Présentation de ADO.NET

Guide ADO.NET du développeur .NET Framework (MSDN)

TAdoDbxCommand

TAdoDbxCommandBuilder

TAdoDbxConnection

TAdoDbxDataAdapter

TAdoDbxDataReader

TAdoDbxException

TAdoDbxParameter

29
 Concepteurs de composants ADO.NET RAD Studio 1.2 Développement d'applications de

TAdoDbxParameterCollection

TAdoDbxProviderFactory

TAdoDbxTransaction

TDBXMetaDataCollectionName

1
1.2.7 Concepteurs de composants ADO.NET
Presque toutes les applications distribuées se ramènent à lire et actualiser des informations dans des bases de données. Les
applications que vous développez en utilisant ADO.NET ont des exigences différentes pour manipuler les données. Vous
pouvez, par exemple, développer une application qui affiche simplement des données dans une fiche. Ou vous pouvez
développer une application qui propose le moyen de partager des informations avec une autre entreprise. Dans tous les cas,
vous devez comprendre certains concepts fondamentaux sur l'approche des données dans ADO.NET.

En utilisant ces concepteurs, vous pouvez travailler efficacement pour lire, exposer et modifier des données par l'intermédiaire
d'objets de schémas propres au serveur de base de données comme les tables, les vues et les index. Ces concepteurs vous
permettent d'utiliser ces objets de schéma pour vous connecter à différentes bases de données courantes et d'effectuer des
opérations de bases de données d'une manière cohérente et fiable.

Cette rubrique comprend :

• Relations de concepteur de composant

• Editeur de connexions
• Editeur de texte de commande
• Boîte de dialogue Procédure stockée
• Génération d'ensembles de données
• Configuration d'adaptateur de données
• Explorateur de données
Relations de concepteur de composant
ANCIENNE IMAGE

NOUVELLE IMAGE

Les principaux éléments des concepteurs de composants de bases de données sont les suivants :

• L'éditeur de connexion permet de définir une connexion dynamique à une source de données
• La fenêtre Editeur de texte de commande permet de construire du texte de commande pour des composants de
commandes.

30
1.2 Développement d'applications de RAD Studio Concepteurs de composants ADO.NET

• La boîte de dialogue de configuration de l'adaptateur de données permet de configurer des commandes pour un
adaptateur de données.
• La boîte de dialogue Procédure stockée permet de visualiser et d'indiquer des valeurs pour les paramètres Input ou
InputOutput à utiliser avec les composants de commandes.
• La boîte de dialogue de génération d'un ensemble de données est utilisée pour construire des ensembles de données
personnalisés.
• L'explorateur de données vous permet de parcourir les objets de schémas spécifiques aux serveurs de bases de données
et d'utiliser le glisser-déplacer pour remplir automatiquement de données une source de données de votre projet Delphi pour 1
.NET.
Editeur de connexions
L'éditeur de connexion gère les chaînes de connexion et les options de connexion propres aux bases de données. Au moyen
de l'éditeur de connexions, vous pouvez ajouter, retirer, supprimer, renommer et tester vos connexions de bases de données.
Les modifications apportées aux informations de connexion sont enregistrées dans le fichier ADoDbxConnections.xml, où
elles sont accessibles dès que vous devez créer un nouvel objet de connexion. Lorsque vous avez choisi une connexion
particulière, l'éditeur de connexions génère la chaîne de connexion ainsi que toutes les options de connexion, puis les affecte
respectivement aux propriétés ConnectionString et ConnectionOptions.

Affichez la boîte de dialogue Editeur de connexions en faisant glisser le composant TAdoDbxConnection de la palette d'outils
vers la fiche, puis en cliquant sur le verbe du concepteur de composants dans le bas de l'inspecteur d'objets.

Editeur de texte de commande

L'éditeur de texte de commande peut être utilisé pour construire le texte de commande pour les composants commande qui
possèdent une propriété CommandText. Un contrôle d'édition multiligne de l'éditeur vous permet d'éditer manuellement la
commande ou de construire le texte de la commande en sélectionnant des tables ou des colonnes. Affichez la boîte de dialogue
Editeur de texte de commande en faisant glisser le composant TAdoDbxCommand de la palette d'outils vers la fiche, puis en
cliquant sur le verbe du concepteur dans le bas de l'inspecteur d'objets.

L'éditeur de texte de commande est une version simplifiée d'un concepteur SQL capable de générer du code SQL pour une
table unique. Les objets de bases de données sont filtrés par la propriété SchemaName définie dans ISQLSchemaCreate et
seules les tables faisant partie de ce schéma sont utilisées. Si aucune propriété SchemaName n'est listée, tous les objets
disponibles pour l'utilisateur de la connexion en cours sont listés. Le paramètre QuoteObjects de la propriété ConnectionOptions
détermine si les objets sont délimités par le caractère guillemet spécifique aux bases de données. Par exemple, ceci est
important lors de la récupération de tables à partir de bases de données qui autorisent les espaces dans les noms de tables.

Pour remplir les boîtes listes Tables et Colonnes avec des éléments ou construire des instructions SQL, vous devez avoir défini
une connexion TAdoDbxConnection active. Sinon, les données ne sont pas récupérables. L'éditeur de texte de commande
vous permet de choisir des noms de colonne et de table dans la liste des colonnes et des tables disponibles. A l'aide de ces
informations, l'éditeur génère une instruction SQL. Pour générer l'instruction SQL, l'éditeur utilise une instance de la classe
TAdoDbxCommandBuilder. Lorsque vous demandez le SQL optimisé, l'éditeur utilise les informations d'index pour générer la
clause WHERE pour les instructions SELECT, UPDATE et DELETE ; sinon, la clause WHERE est constituée par les colonnes
non BLOB et les colonnes autorisant les recherches.

Lorsque l'instruction SQL est générée, la propriété TAdoDbxCommand. CommandText est définie sur l'instruction SQL générée.

Boîte de dialogue Procédure stockée

La boîte de dialogue Procédure stockée est utilisée pour visualiser et entrer des paramètres Input et InputOutput pour une
procédure stockée et pour exécuter cette procédure. Affichez la boîte de dialogue Procédure stockée en faisant glisser un
composant TAdoDbxCommand de la palette d'outils vers la fiche, en réglant la propriété CommandType du composant
TAdoDbxCommand sur StoredProcedure, puis en cliquant sur le verbe du concepteur Editeur de texte de commande dans la
partie inférieure de l'inspecteur d'objet.

La boîte de dialogue Procédure stockée vous permet de sélectionner une procédure stockée à partir d'une liste des procédures

31
 Concepteurs de composants ADO.NET RAD Studio 1.2 Développement d'applications de

stockées disponibles, qui est déterminée par le TAdoDbxConnection spécifié dans la propriété Connection pour le composant
TAdoDbxCommand. Lorsque vous sélectionnez une procédure stockée, la boîte de dialogue affiche les paramètres associés à
la procédure stockée et les métadonnées des paramètres pour le paramètre sélectionné. Vous pouvez spécifier des valeurs
pour les paramètres Input ou InputOutput et exécuter la procédure stockée. Si la procédure stockée renvoie des résultats,
comme des paramètres Output, des paramètres InputOutput, des valeurs de retour, un (ou plusieurs) curseur(s) de retour, ils
sont tous remplis dans un DataGrid en bas de la boîte de dialogue lorsque la procédure stockée est exécutée. Après
l'initialisation des propriétés CommandText et Parameters pour TAdoDbxCommand, la procédure stockée peut être exécutée
lors de l'exécution au moyen d'un seul appel à la méthode ExecuteReader or ExecuteNonQuery.
1
Génération d'ensembles de données
Le concepteur Génération d'un ensemble de données est utilisé pour construire un ensemble de données. L'utilisation de cet
outil a pour résultat un typage strict, un code plus clair et la possibilité d'utiliser l'achèvement de code. Un ensemble de données
dérive d'abord de la classe de base DataSet puis utilise les informations d'un fichier schéma XML (un fichier .xsd) pour générer
une nouvelle classe. Les informations du schéma (tables, colonnes, etc.) sont générées et compilées dans cette nouvelle classe
dataset comme un ensemble de propriétés et d'objets "first-class". Affichez cette boîte de dialogue en faisant glisser un
composant TAdoDbxDataAdapter de la palette d'outils vers la fiche, puis en cliquant sur le verbe du concepteur de composants
dans le bas de l'inspecteur d'objet. Si ce composant n'est pas affiché, choisissez Composants Composants .NET installés
pour l'ajouter à la palette d'outils.

Configuration d'adaptateur de données

Le concepteur de configuration de l'adaptateur de données est utilisé pour générer les instructions SQL SELECT, INSERT,
UPDATE et DELETE. Après une génération SQL réussie, le concepteur Configuration de l'adaptateur de données crée de
nouveaux objets TAdoDbxCommand et les ajoute aux propriétés TAdoDbxDataAdapterSelectCommand, DeleteCommand,
InsertCommand et UpdateCommand.

Après une génération réussie d'une instruction SELECT de SQL, vous pouvez prévisualiser les données et générer un nouveau
DataSet. Vous pouvez également utiliser un DataSet existant pour remplir un nouveau DataTable. Si vous créez un nouveau
DataSet, il sera ajouté automatiquement à l'hôte du concepteur. Vous pouvez également générer des DataSet typés.

Les adaptateurs de données font partie intégrante des fournisseurs ADO.NET managés. Essentiellement, les adaptateurs sont
utilisés pour échanger des données entre une source de données et un ensemble de données. Cela veut dire lire les données
depuis une base de données dans un ensemble de données, et écrire dans la base de données les données modifiées dans
l'ensemble de données. Un adaptateur de données peut déplacer les données entre toute source et un ensemble de données.
Affichez la boîte de dialogue de configuration de l'adaptateur de données en faisant glisser un composant
TAdoDbxDataAdapter de la palette d'outils vers la fiche, puis en cliquant sur le verbe du concepteur de composants dans le
bas de l'inspecteur d'objets.

Explorateur de données
L'explorateur de données est un navigateur de base de données hiérarchique et un outil d'édition. L'explorateur de données
est intégré dans l'EDI et peut également être exécuté comme un exécutable autonome. Pour accéder à l'explorateur de
données de l'EDI, choisissez Voir Explorateur de données. Utilisez les menus contextuels de l'explorateur de données
pour effectuer les tâches suivantes :

• Gérer les connexions de base de données — ajouter une nouvelle connexion, modifier, supprimer ou renommer vos
connexions existantes
• Parcourir la structure de la base de données et les données, étendre et ouvrir les noeuds des fournisseurs pour parcourir les
objets de schémas propres aux serveurs de bases de données, notamment les tables, les vues, les définitions de procédures
stockées et les index
• Ajouter et modifier des tables — spécifier la structure des données pour une nouvelle table, ajouter ou supprimer des
colonnes et modifier les informations de colonnes pour une table existante
• Visualiser et tester les paramètres de procédures stockées — spécifier les valeurs pour les paramètres Input ou InputOutput
et exécuter la procédure stockée sélectionnée

32
1.2 Développement d'applications de RAD Studio Déploiement d'applications de bases de

• Migrer des données — migrer le schéma des tables et les données d'une ou plusieurs tables d'un fournisseur vers un autre
• Glisser et déplacer des objets de schémas sur des fiches pour simplifier le développement des applications, glisser des tables
ou des procédures stockées sur la fiche de votre application pour le .NET Framework afin d'ajouter des composants de
connexion et de générer automatiquement des chaînes de connexion
L'explorateur de données fournit une connectivité à plusieurs bases de données standard et peut être étendu pour se
connecter à d'autres bases de données courantes. L'explorateur de données utilise l'interface ISQLDataSource pour obtenir
la liste des fournisseurs disponibles, des connexions de bases de données et des objets schéma qui sont pris en charge par
les divers fournisseurs. La liste des fournisseurs disponibles est persistante dans le fichier TAdoDbxDataSources.xml et
les connexions disponibles sont persistantes dans le fichier TAdoDbxConnections.xml. Lorsque vous avez choisi un 1
fournisseur, l'interface ISQLMetadata est utilisée pour récupérer les métadonnées et afficher une vue arborescente en lecture
seule des objets de bases de données. L'implémentation en cours fournit une liste des tables, vues et procédures stockées
pour toutes les bases de données prises en charge par AdoDbx Client.
L'explorateur de données vous permet de créer de nouvelles tables, de modifier ou déplacer des tables existantes, de migrer
des données à partir de plusieurs tables d'un fournisseur vers un autre et de copier et coller des tables individuelles dans les
bases de données ADO prises en charge. Pour toutes ces opérations, l'explorateur de données appelle l'implémentation
ISQLSchemaCreate du fournisseur.
De plus, l'explorateur de données peut être utilisé pour faire glisser des données depuis une source de données vers n'importe
quel projet RAD Studio pour le .NET Framework. Faire glisser une table sur une fiche ajoute les composants
TAdoDbxConnection et TAdoDbxDataAdapter à votre application et configure automatiquement le TAdoDbxDataAdapter pour
la table donnée. Faire glisser une procédure stockée sur une fiche ajoute les composants TAdoDbxConnection et
TAdoDbxCommand à votre application, et affecte la valeur StoredProcedure à la propriété CommandType de l'objet
TAdoDbxCommand.
Voir aussi
Présentation de ADO.NET

Types de données AdoDbx.NET

Utilisation du concepteur de texte de commande

Utilisation du concepteur éditeur de connexion

Utilisation du concepteur adaptateur de données

Utilisation de la prévisualisation d'adaptateur de données

Utilisation du concepteur d'ensemble de données

Migration de données entre des bases de données

Création de mappages de tables

1.2.8 Déploiement d'applications de bases de données pour

le .NET Framework
Pour déployer des applications de bases de données avec RAD Studio, copiez les assemblages d'exécution et les DLL de
pilotes pour le déploiement à un emplacement spécifié. Les sections suivantes indiquent le nom des assemblages et des DLL et
l'emplacement où chacun doit être placé.

Déploiement des applications ADO.NET 2.0

Pour de plus amples informations, voir le fichier source Borland.Data.AdoDbxClientProvider.pas.

Déploiement d'applications BDP.NET

Copiez les assemblages d'exécution de bases de données spécifiques à l'emplacement suivant :

33
 Déploiement d'applications de bases de RAD Studio 1.2 Développement d'applications de

Assemblages managés Fournisseur de données Emplacement

Borland.Data.Common.dll Tous GAC
Borland.Data.Provider.dll Tous GAC
Borland.Data.DB2.dll DB2 GAC
Borland.Data.Interbase.dll Interbase GAC

1 Borland.Data.Mssql.dll MS SQL/MSDE GAC

Borland.Data.Oracle.dll Oracle GAC
Borland.Data.Msacc.dll MS Access GAC
Borland.Data.Sybase.dll Sybase GAC

Remarque: Si vous déployez une application de base de données distribuée utilisant les composants distants BDP.NET, tels
que DataHub, DataSync, RemoteConnection et RemoteServer, vous devez installer Borland.Data.DataSync.dll

dans le GAC. Copiez les DLL des pilotes de bases de données non managées à l'emplacement suivant :

DLL Fournisseur de données Emplacement

bdpint20.dll Interbase chemin de recherche
bdpdb220.dll DB2 chemin de recherche
bdpmss20.dll MS SQL/MSDE chemin de recherche
bdpora20.dll Oracle chemin de recherche
bdpmsa20.dll MS Access chemin de recherche
bdpsyb20.dll Sybase chemin de recherche

Déploiement d'applications dbExpress pour .NET

Copiez les assemblages d'exécution de bases de données spécifiques à l'emplacement suivant :

Assemblages managés Fournisseur de données Emplacement

Borland.VclDbExpress.dll Tous GAC
Borland.VclDbCtrls.dll Tous GAC
Borland.VclDbxCds.dll Requis par les applications de bases de données qui GAC
utilisent des ensembles de données client
Borland.Common.Driver.dll Tous GAC

Vous pouvez déployer les pilotes dbExpress.NET et les DLL associés avec votre exécutable. Copiez les DLL des pilotes de
bases de données non managées à l'emplacement suivant :

DLL Fournisseur de données Emplacement

dbxINT30.dll InterBase 2007, 7.5.1, 7.1*, 7.0*, 6.5* chemin de recherche
dbxASA30.dll Adaptive Sybase Anywhere 9, 8* chemin de recherche
dbxDB230.dll DB2 UDB 8.x, 7.x* chemin de recherche
dbxINF30.dll Informix 9.x chemin de recherche
dbxMSS30.dll MSSQL 2005, 2000 chemin de recherche
dbxMYSA30.dll MySQL 4.0.24 chemin de recherche
dbxMYS30.dll MySQL 5.0.27, 4.1.22* chemin de recherche

34
1.2 Développement d'applications de RAD Studio Framework dbExpress

dbxora30.dll Oracle 10g, 9.2.0*, 9.1.0* chemin de recherche

dbxASE30.dll Sybase 12.5 chemin de recherche
Midas.dll Requis par les applications de bases de données qui chemin de recherche
utilisent des ensembles de données client

Remarque: * Le pilote n'est pas totalement certifié pour cette version de la base de données.

Déploiement d'applications dbGo pour .NET 1

Il n'est pas nécessaire de déployer des assemblages d'exécution ou des pilotes de base de données pour les composants dbGo
utilisés dans des applications VCL.NET. Microsoft Data Access Components (MDAC) version 2.1 ou une version ultérieure est
nécessaire pour exécuter des applications avec des composants dbGo en dehors de l'EDI. Cela s'applique aux applications VCL
Win32, ainsi qu'aux applications VCL.NET. RAD Studio prend en charge MDAC 2.8.

Déploiement d'applications BDE pour .NET

Durant son déploiement, vous devez inclure le BDE avec votre application. Bien que cela augmente la taille de l'application et la
complexité du déploiement, le BDE peut être partagé avec d'autres applications BDE et assurer un support plus large pour la
manipulation des bases de données. Même s'il est possible d'utiliser directement l'API du BDE dans votre application, les
composants de la section BDE de la palette d'outils regroupent la plupart de ces fonctionnalités.

Voir aussi
Présentation Borland du déploiement d'applications

Présentation Microsoft du déploiement d'applications

1.2.9 Framework dbExpress

Le framework dbExpress (framework DBX) est un ensemble de classes abstraites fournies dans l'unité DBXCommon. Les
applications peuvent s'interfacer avec le framework de différentes façons : en utilisant le framework directement pour les
applications natives et managées, et en utilisant les composants dbExpress VCL disposés en couches au sommet du framework
pour les applications natives et managées.

Bien que de nombreuses applications s'interfacent avec les pilotes dbExpress via les composants dbExpress VCL, le framework
DBX offre une option utile et légère pour communiquer avec un pilote de base de données. Vous pouvez également créer un
pilote de base de données pour dbExpress en étendant les classes de base abstraites DBXCommon du framework. Le
framework DBX fournit les fonctionnalités de pilote de base de données les plus courantes pour une application de base de
données orientée "ensemble", ainsi qu'une interface simple.

Voici quelques fonctionnalités clés du framework DBX :

• Le framework de pilote est écrit entièrement en langage Delphi et permet aux pilotes d'être écrits en Delphi.
• Il utilise l'accès aux données fortement typées au lieu des pointeurs. Par exemple, il utilise les types chaîne à la place des
pointeurs vers des chaînes.
• Le framework de pilote est à source unique. Cela signifie qu'une copie unique du source peut être compilée avec les
compilateurs DCC32 natif et DCCIL managés.
• Le framework a seulement des classes de base abstraites qui sont utilisées pour les pilotes, les connexions, les commandes,
les lecteurs, et ainsi de suite.
• Le framework utilise la gestion des erreurs basée sur les exceptions, plutôt que le renvoi de codes d'erreur.
Capacités
IL existe deux catégories de pilotes qui étendent les classes dans DBXCommon : DBXDynaLink et DBXDirect. Ces pilotes

35
 Framework dbExpress RAD Studio 1.2 Développement d'applications de

diffèrent les uns des autres dans la façon dont ils sont chargés et par les capacités qu'ils fournissent à une application. Ces
capacités sont détaillées par la suite.

Vous pouvez également étendre le framework DBX pour écrire des pilotes de délégation qui fournissent une couche
supplémentaire entre l'application et le pilote réel. Les pilotes délégués sont utiles pour le pooling de connexion, le profilage de
pilote, le traçage et l'audit. Une autre application possible de délégation de pilote est la création d'un délégué de pilote adapté
aux threads. Un tel délégué peut fournir un accès synchronisé de thread à toutes les méthodes publiques.

La sécurité de thread absolue est laissée aux applications utilisant dbExpress. Toutefois, certains problèmes de sécurité de
1 thread sont mieux gérés par le framework dbExpress. Les opérations de sécurité de thread dbExpress incluent le chargement et
le déchargement des pilotes, ainsi que la création de connexions. Comme mentionné plus tôt, un pilote délégué peut être créé
pour rendre l'interface publique entière de dbExpress adaptée aux threads si nécessaire.

Un pilote dbExpress 4 peut lier statiquement ou dynamiquement des pilotes construits en tant que packages Delphi. La meilleure
façon de lier un package de pilote est simplement de l'inclure la clause "uses". Le chargeur de pilote charge également les
packages spécifiés dans un fichier config ou ini à l'aide de la méthode LoadPackage. Cela permet un chargement dynamique
des pilotes qui ne sont jamais spécifiés dans une clause uses d'une des unités de l'application. Notez que l'approche
LoadPackage peut seulement être employée pour les applications construites pour utiliser des packages.

Les auteurs de pilotes dbExpress 4 doivent examiner les sections d'initialisation des unités DBXDynalink et DBXTrace dans le
code source fourni avec dbExpress. Ces sections se recensent elles-mêmes avec une unité singleton appelée le ClassRegistry.
Le ClassRegistry est utilisé par le chargeur de pilote dbExpress 4 pour instancier les classes chargeur de pilote par le nom (une
chaîne). Le ClassRegistry est un mécanisme léger et simple pour le recensement et l'instanciation d'une classe par le nom.

Pilotes DBXDynalink
DBXDynalink est utilisé pour les pilotes dbExpress 3 existants, ainsi que pour les nouveaux pilotes. Il est compilé comme un
package Delphi natif ou un assemblage .NET managé. DBXDynalink charge les pilotes dbExpress natifs qui implémentent une
interface "native" plus primitive appelée DBXExports. L'interface DBXExports est une petite collection de méthodes d'exportation
simples. Le source de DBXExports est inclus avec dbExpress. DBXExports fournit une API plus fortement typée que l'interface
COM de dbExpress 3. Cela permet l'ajout des méthodes dans les générations de produits futures sans casser la compatibilité
avec les anciennes implémentations de l'interface DBXExports.

DBXAdapter est un pilote compatible dbExpress 4 qui adapte l'interface DBXExports à l'ancienne interface COM dbExpress 3.
Les nouveaux pilotes natifs peuvent être écrits en implémentant directement DBXExports.

Puisque l'interface DBXExports a été conçue pour être implémentée au moyen d'un langage natif (Delphi ou C++), elle utilise
une gestion d'erreurs basée sur les exceptions plus primitive. DBXDynalink mappe les codes d'erreur en exception
DBXCommon.

L'unité DBXDynalink contient un pilote dbExpress 4. Ce pilote délègue les pilotes non-Delphi qui implémentent l'interface
d'exportation simple DBXDynalinkExport. DBXTrace est un pilote délégué utilisé pour le traçage. La bibliothèque VCL
DbExpress utilise DBXCommon, DBXDynalink et DbxTrace comme pilotes "par défaut". Toutefois, cela peut être changé pour
les applications liées statiquement sans modifier le code source dbExpress VCL (SQLExpr.pas). SQLExpr.pas utilise l'unité
DBXDefaultDrivers. L'unité DBXDefaultDrivers contient seulement une clause uses. La clause uses de DBXDefaultDrivers
contient DBXCommon, DBXDynalink et DBXTrace. DBXCommon doit toujours être utilisé. Toutefois, une application liée
statiquement peut retirer DBXTrace et remplacer DBXDynalink par un pilote différent.

Pilotes DBXDirect
Un pilote DBXDirect est un pilote implémenté en étendant les classes de base abstraites DBXCommon. Ces classes sont écrites
en Delphi pour les implémentations natives. Pour les implémentations managées, elles peuvent être écrites au moyen d'un
langage compatible CLR tel que Delphi, C# ou Visual Basic.NET.

Strictement parlant, tous les pilotes de framework DBX sont une forme de pilote DBXDirect. Toutefois, DBXDynalink et
DBXRemote fournissent une liaison plus "indirecte" aux implémentations de pilotes.

36
1.2 Développement d'applications de RAD Studio Compatibilité du framework dbExpress

Voir aussi
Compatibilité du framework de pilote de base de données dbExpress ( see page 37)

Déploiement d'applications de bases de données dbExpress ( see page 2007)

1.2.10 Compatibilité du framework dbExpress 1

Certains logiciels dbExpress développés avant le framework de pilote dbExpress (framework de pilote DBX) ont été modifiés
pour fonctionner avec le framework de pilote DBX. A cause de ces modifications, certains problèmes de compatibilité se
produisent.

Général
Les pilotes dbExpress 2.5 ne peuvent pas être utilisés avec le framework DBX.

Le framework dbExpress n'offre pas une compatibilité à 100% avec dbExpress 3.

Les pilotes dbExpress 3 peuvent être utilisés avec le framework DBX. Le chargeur du framework de pilote DBX détecte
automatiquement les pilotes dbExpress 3 et utilise le pilote DBXAdapter (dbxadapter30.dll) afin qu'un pilote dbExpress 3
ressemble à un pilote dbExpress 4.

Voici la liste des problèmes de compatibilité connus :

• Liaison de pilotes statique. Vous ne pouvez pas lier de façon statique des pilotes dbExpress dans un exécutable.
• SqlExpr.TSQLConnection fournissait un accès protégé au membre Connection qui était de type TISQLConnection seulement
dans la version native de SqlExpr.pas. Cela a été omis dans la version managée en raison de la complexité de l'utilisation de
PInvoke dans la version managée de la VCL dbExpress. SqlExpr.TSQLConnection fournit maintenant à la place un accès
protégé à un TDBXConnection. Cette connexion protégée est accessible aux applications natives et managées.
• L'événement du contrôle des traces est légèrement différent car il est basé sur le framework de pilote DBX.
• Le pilote DBXadapter peut adapter les pilotes dbExpress 3 à dbExpress 4, mais pas les pilotes dbExpress 2.5.
Problèmes VCL
La plupart des applications utilisant des composants VCL dbExpress devraient fonctionner sans modification. Toutefois, des
modifications localisées sont apportées aux composants VCL en raison de la VCL s'interfaçant maintenant sur le framework de
pilote DBX orienté objet au lieu de l'interface de pilote dbExpress 3 basée sur COM C-like.

En outre, l'API a été légèrement modifiée pour les deux composants VCL suivants : TSQLConnection et TSQLDataSet.
Certaines structures de données ont également été modifiées. Vous trouverez ci-après un résumé des changements de l'API.

Remarque: A cause des modifications apportées à l'API, vous devez recompiler SqlExpr.pas qui est livré avec le produit.
L'unité DBXpress a été dépréciée.

• TSQLConnection. La méthode Commit a été dépréciée en faveur de la nouvelle méthode CommitFreeAndNil. La méthode
Rollback a été dépréciée en faveur des nouvelles méthodes RollbackFreeAndNil et RollbackIncompleteFreeAndNil. La
méthode SetTraceCallbackEvent a été remplacée par SetTraceEvent. La méthode StartTransaction a été dépréciée en faveur
de la nouvelle méthode BeginTransaction. La propriété MetaData contient une instance de la nouvelle classe
TDBXDatabaseMetaData au lieu de TISQLMetaData. La propriété SQLConnection a été remplacée par DBXConnection, qui
contient une instance de la nouvelle classe TDBXConnection. La propriété TraceCallbackEvent contient maintenant un
TDBXTraceEvent.
• TSQLDataSet. La nouvelle propriété DbxCommandType a été ajoutée. Elle contient une des chaînes constante de la classe
TDBXCommandTypes.
• Structures de données. TTransactionItem a été dépréciée et remplacée par la nouvelle classe TDBXTransaction.
TSQLDriverOption, TSQLConnectionOption, TSQLCommandOption, TSQLCursorOption, TSQLMetaDataOption et
TSQLObjectType sont obsolètes. TSTMTParamType a été remplacée par la classe TDBXParameterDirections.

37
 Compatibilité du framework dbExpress RAD Studio 1.2 Développement d'applications de

TSQLTraceFlag a été remplacée par TDBXTraceFlags. SQLTRACEDesc a été remplacée par TDBXTraceInfo.
Voir aussi
Framework dbExpress

Déploiement du framework dbExpress

38
1.3 Développement des applications RAD Studio Développement d'applications COM

1.3 Développement des applications

interopérables
RAD Studio fournit des experts et des classes qui facilitent l'implémentation d'applications basées sur le modèle COM
1
(Component Object Model) de Microsoft. Grâce à ces experts, vous pouvez créer des classes et des composants basés sur
COM que vous utiliserez dans des applications, ou vous pouvez créer des clients ou des serveurs COM complètement
fonctionnels qui implémentent des objets COM sophistiqués, des serveurs Automation (y compris, des objets Active Server), des
contrôles ActiveX ou des fiches ActiveForms.

Rubriques
Nom Description
Développement d'applications COM ( see page 39) Delphi fournit des experts et des classes qui facilitent l'implémentation
d'applications basées sur COM (Component Object Model) de Microsoft. Grâce à
ces experts, vous pouvez créer des classes et des composants basés sur COM
que vous utiliserez dans des applications, ou vous pouvez créer des clients et
des serveurs COM complètement fonctionnels qui implémentent des objets COM
sophistiqués, des serveurs Automation (y compris, des objets Active Server), des
contrôles ActiveX ou des fiches ActiveForms.
Cette rubrique aborde les thèmes suivants :

• Présentation des technologies COM

• Interfaces COM
• Serveurs COM
• Clients COM

1.3.1 Développement d'applications COM

Delphi fournit des experts et des classes qui facilitent l'implémentation d'applications basées sur COM (Component Object
Model) de Microsoft. Grâce à ces experts, vous pouvez créer des classes et des composants basés sur COM que vous utiliserez
dans des applications, ou vous pouvez créer des clients et des serveurs COM complètement fonctionnels qui implémentent des
objets COM sophistiqués, des serveurs Automation (y compris, des objets Active Server), des contrôles ActiveX ou des fiches
ActiveForms.

Cette rubrique aborde les thèmes suivants :

• Présentation des technologies COM

• Interfaces COM
• Serveurs COM
• Clients COM
Présentation des technologies COM
COM est un modèle de composant logiciel indépendant du langage qui permet l'interaction entre des composants logiciels et
des applications s'exécutant sous Windows. L'aspect le plus important de COM est de permettre la communication entre
composants, entre applications et entre clients et serveurs, par le biais d'interfaces clairement définies. Les interfaces offrent aux
clients un moyen de demander à un composant COM quelles fonctionnalités il supporte à l'exécution. Pour fournir d'autres
fonctionnalités à votre composant, il suffit d'ajouter une autre interface pour ces fonctionnalités.

39
 Développement d'applications COM RAD Studio 1.3 Développement des applications

Les applications peuvent accéder aux interfaces des composants COM se trouvant sur le même ordinateur que l'application ou
sur un autre ordinateur du réseau, en utilisant un mécanisme nommé DCOM (Distributed COM).

COM est à la fois une spécification et une implémentation. La spécification COM définit comment des objets sont créés et
comment ils communiquent entre eux. Selon cette spécification, les objets COM peuvent être écrits dans différents langages,
exécutés dans différents espaces de processus et sur différentes plates-formes. Tant que les objets se conforment à la
spécification, ils peuvent communiquer. Cela vous permet d'intégrer le code de composants existants à de nouveaux
composants implémentés dans des langages orientés objet.
1 L'implémentation COM est construite dans le sous-système Win32, qui fournit de nombreux services intégrés supportant la
spécification. La bibliothèque COM contient un ensemble d'interfaces standard définissant la fonctionnalité interne d'un objet
COM et un petit ensemble de fonctions API pour la création et la gestion des objets COM.

Lorsque vous utilisez dans votre application les experts de Delphi et les objets de la VCL, vous utilisez l'implémentation Delphi
de la spécification COM. En outre, Delphi fournit quelques enveloppes pour les services COM dont les fonctionnalités ne sont
pas implémentées directement, comme les documents Active. Ces enveloppes sont définies dans l'unité ComObj, et les
définitions d'API se trouvent dans l'unité AxCtrls.

Remarque: Les objets et les langages des interfaces Delphi sont conformes à la spécification COM. L'implémentation Delphi de
la spécification COM utilise un ensemble de classes appelé cadre de travail Delphi ActiveX (DAX). Ces classes se trouvent dans
les unités AxCtrls, OleCtrls et OleServer. En outre, l'interface Delphi avec l'API COM se trouve dans ActiveX.pas et
ComSvcs.pas.

Interfaces COM
Les clients COM communiquent avec des objets par le biais d'interfaces COM. Les interfaces sont des groupes de routines,
liées par la logique ou par la sémantique, qui assurent la communication entre le fournisseur d'un service (objet serveur) et ses
clients.

Par exemple, tout objet COM doit implémenter l'interface de base, IUnknown. Via une routine appelée QueryInterface de
IUnknown, les clients peut demander les autres interfaces implémentées par le serveur.

Les objets peuvent avoir plusieurs interfaces, où chacune implémente une fonctionnalité. L'interface est le moyen d'indiquer au
client le service fourni par l'objet, sans lui donner les détails de l'implémentation sur la façon dont ce service est fourni.

Les aspects majeurs des interfaces COM sont les suivants :

• Une fois publiées, les interfaces ne changent pas. Une interface permet d'accéder à un ensemble précis de fonctions. Les
fonctionnalités supplémentaires sont fournies par le biais d'interfaces supplémentaires.
• Par convention, les identificateurs d'interfaces COM commencent par un I majuscule suivi d'un nom symbolique définissant
l'interface, comme IMalloc ou IPersist.
• L'identification unique des interfaces est garantie par un GUID (Globally Unique Identifier), qui est un nombre aléatoire de
128 bits. Les GUID utilisés pour identifier les interfaces sont appelés IID (Identificateurs d'interfaces). Ils permettent d'éliminer
les conflits de noms entre différentes versions d'un produit ou différents produits.
• Les interfaces sont indépendantes du langage. Vous pouvez utiliser n'importe quel langage pour implémenter une interface
COM, à condition que ce langage supporte les structures de pointeurs et puisse appeler une fonction via un pointeur, de
façon explicite ou implicite.
• Les interfaces ne sont pas elles-mêmes des objets ; elles fournissent l'accès à un objet. Donc, les clients n'ont pas accès
directement aux données ; ils accèdent aux données par le biais d'un pointeur d'interface. Windows 2000 ajoute une autre
couche d'indirection, connue sous le nom d'intercepteur, à partir duquel il fournit des fonctionnalités COM+ telles que
l'activation just-in-time et le regroupement d'objets.
• Les interfaces sont toujours héritées de l'interface de base, IUnknown.
• Les interfaces peuvent être redirigées par COM via des proxy pour permettre aux appels de méthodes de l'interface de
s'effectuer entre différents threads, processus et machines en réseau, sans que les objets client ou serveur ne soient jamais
informés de la redirection.

40
1.3 Développement des applications RAD Studio Développement d'applications COM

L'interface IUnknown
Les objets COM doivent tous supporter l'interface fondamentale, appelée IUnknown qui représente un typedef sur le type
d'interface de base IInterface. IUnknown contient les routines suivantes :

• QueryInterface : Fournit des pointeurs sur d'autres interfaces supportées par l'objet.
• AddRef et Release : Méthodes simples de décompte de références qui permettent à un objet de contrôler sa durée de vie et
de se supprimer lui-même lorsque le client n'a plus besoin de son service.
1
Les clients obtiennent des pointeurs sur d'autres interfaces via la méthode QueryInterface de IUnknown. QueryInterface
connaît chaque interface de l'objet serveur et peut donner au client un pointeur vers l'interface demandée. Lorsqu'il reçoit un
pointeur vers une interface, le client est assuré de pouvoir appeler n'importe quelle méthode de l'interface.
Les objets contrôlent leur propre durée de vie grâce aux méthodes AddRef et Release de IUnknown, qui sont de simples
méthodes de décompte de références. Tant que le décompte de références d'un objet est différent de zéro, l'objet reste en
mémoire. Dès qu'il atteint zéro, l'implémentation de l'interface peut en toute sécurité disposer des objets sous-jacents.

Pointeurs d'interface COM

Un pointeur d'interface est un pointeur vers une instance d'objet qui pointe, à son tour, vers l'implémentation de chaque méthode
de l'interface. L'implémentation est accédée via un tableau de pointeurs vers ces méthodes, appelé vtable. Les vtables sont
similaires au mécanisme utilisé pour gérer les fonctions virtuelles sous Delphi. A cause de cette similitude, le compilateur peut
résoudre les appels de méthode de l'interface de la même manière qu'il résout les appels des méthodes de classes Delphi.

La vtable est partagée par toutes les instances d'une classe objet, et pour chaque instance de l'objet, le code de l'objet alloue
une deuxième structure contenant ses données privées. Le pointeur d'interface du client est alors un pointeur sur le pointeur sur
la vtable.

Dans Windows 2000 et toutes les versions ultérieures de Windows, quand un objet s'exécute sous COM+, un autre niveau
d'indirection est fourni entre le pointeur d'interface et le pointeur vtable. Le pointeur d'interface disponible sur le client pointe sur
un intercepteur, qui à son tour pointe sur la vtable. Cela permet à COM+ de fournir des services comme l'activation just-in-time,
par lequel le serveur peut être désactivé et réactivé dynamiquement d'une façon opaque pour le client. COM+ garantit que
l'intercepteur se comporte comme s'il était un pointeur vtable ordinaire.

Serveurs COM
Un serveur COM est une application ou une bibliothèque qui fournit des services à une application ou bibliothèque client. Un
serveur COM est constitué d'un ou de plusieurs objets COM, un objet COM étant un ensemble de propriétés (données membre
ou contenu) et de méthodes (fonctions membre).

Les clients ne savent pas comment l'objet COM effectue son service ; l'implémentation de l'objet reste cachée. Un objet met ses
services à disposition par le biais de ses interfaces comme décrit précédemment.

En outre, les clients n'ont pas besoin de savoir où réside l'objet COM. COM offre un accès transparent, quel que soit
l'emplacement de l'objet.

Quand il demande un service à un objet COM, le client transmet un identificateur de classe (CLSID) à COM. Un CLSID est juste
un GUID qui référence un objet COM. COM utilise ce CLSID, recensé dans le registre système, pour localiser l'implémentation
appropriée du serveur. Une fois le serveur localisé, COM amène le code en mémoire, et fait créer par le serveur une instance de
l'objet pour le client. Ce processus est géré indirectement par un objet spécial appelé une factory (basé sur les interfaces) qui
crée sur demande des instances d'objet.

Au minimum, un serveur COM doit effectuer ceci :

• Recenser des entrées dans le registre système pour associer le module serveur à l'identificateur de classe (CLSID).
• Implémenter un objet factory de classe, qui crée un autre objet à partir d'un CLSID particulier.
• Exposer la factory d'objet à COM.
• Fournir un mécanisme de déchargement grâce auquel un serveur qui ne sert pas de client pourra être supprimé de la

41
 Développement d'applications COM RAD Studio 1.3 Développement des applications

mémoire.
Clients COM
Les clients COM sont des applications qui utilisent un objet COM implémenté par une autre application ou bibliothèque. Les
types les plus courants sont les contrôleurs Automation, qui contrôlent un serveur Automation et les conteneurs ActiveX, qui
accueillent un contrôle ActiveX.

Il y a deux types de clients COM : les contrôleurs et les conteneurs. Un contrôleur lance le serveur et interagit avec lui via son
interface. Il demande des services de l'objet COM ou il le pilote comme processus distinct. Les conteneurs accueillent des
1
contrôles visuels ou des objets qui apparaissent dans l'interface utilisateur du conteneur. Ils utilisent des interfaces prédéfinies
pour négocier les problèmes d'affichage avec les objets serveur. Il est impossible d'avoir une relation conteneur sur DCOM ; par
exemple, les contrôles visuels qui apparaissent dans l'interface utilisateur du conteneur doivent être localisés localement. En
effet, les contrôles sont supposés se dessiner eux-mêmes, ce qui nécessite qu'ils puissent accéder aux ressources GDI locales.

La réalisation de ces deux types de clients COM est étonnamment similaire : l'application client obtient une interface pour l'objet
serveur et en utilise les propriétés et méthodes. Delphi facilite le développement d'un contrôleur Automation en permettant
d'importer la bibliothèque de types ou un contrôle ActiveX dans un composant enveloppe de telle manière que les objets serveur
apparaissent comme les autres composants VCL. Delphi vous permet d'envelopper la CoClasse serveur dans un composant
du client que vous pouvez même installer sur la palette des composants. Vous trouverez des exemples de ces enveloppes de
composants sur deux pages de la palette des composants, des exemples d'enveloppes ActiveX sur la page ActiveX et des
exemples d'objets Automation sur la page Serveurs.

Même si vous ne choisissez pas d'envelopper un objet serveur et de l'installer dans la palette des composants, vous devez
rendre sa définition d'interface accessible à votre application. Pour ce faire, vous pouvez importer les informations de la
bibliothèque de types du serveur.

Les clients peuvent toujours interroger les interfaces d'un objet COM pour déterminer ce qu'il est capable de faire. Tous les
objets COM permettent aux clients de demander les interfaces connues. De plus, si le serveur gère l'interface IDispatch, les
clients peuvent demander au serveur des informations sur les méthodes gérées par le serveur. Les objets serveurs n'ont pas
d'attentes concernant l'utilisation de ses objets par le client. De même, les clients n'ont pas besoin de savoir comment un objet
fournit les services ; ils s'en remettent simplement sur les objets serveurs pour fournir les services qu'ils décrivent dans leurs
interfaces.

Extensions de COM
COM a évolué et a été étendu au-delà des services COM de base. COM sert de fondement à d'autres technologies, comme
l'Automation, les contrôles ActiveX, les documents Active et les annuaires Active. En outre, si vous travaillez dans un
environnement distribué important, vous pouvez créer des objets COM transactionnels. Avant Windows 2000, ces objets ne
faisaient pas partie de COM, mais s'exécutaient dans l'environnement Microsoft Transaction Server (MTS). Avec l'arrivée de
Windows 2000, cette gestion est intégrée dans COM+. Delphi fournit des experts permettant d'implémenter facilement des
applications qui utilisent toutes ces technologies dans l'environnement Delphi.

Serveurs Automation
L'Automation désigne la capacité d'une application à contrôler par programme les objets d'une autre application, comme une
macro qui peut manipuler plusieurs applications à la fois. Le client d'un objet Automation est appelé contrôleur Automation, et
l'objet serveur manipulé est appelé objet Automation. L'Automation peut être utilisée sur des serveurs en processus, locaux ou
distants.

L'Automation présente deux caractéristiques principales :

• L'objet Automation définit un ensemble de propriétés et de commandes, et décrit ses capacités via les descriptions de type.
Pour ce faire, il doit disposer d'un moyen de fournir des informations sur les interfaces de l'objet, les méthodes des interfaces
et les arguments de ces méthodes. Généralement, ces informations se trouvent dans des bibliothèques de types. Le serveur
Automation peut aussi générer dynamiquement des informations de types lorsqu'elles lui sont demandées via son interface
IDispatch.
• Les objets Automation rendent ces méthodes accessibles pour que d'autres applications puissent les utiliser. Pour cela, ils

42
1.3 Développement des applications RAD Studio Développement d'applications COM

implémentent l'interface IDispatch. C'est par le biais de cette interface qu'un objet peut exposer toutes ses méthodes et
propriétés. Et c'est par le biais de la méthode primaire de cette interface que les méthodes de l'objet peuvent être appelées,
une fois qu'elles ont été identifiées grâce aux informations de type.
Les développeurs utilisent souvent l'Automation pour créer et utiliser des objets OLE non visuels qui s'exécutent dans n'importe
quel espace processus, car l'interface Automation IDispatch automatise le processus de marshaling. En revanche,
l'Automation limite les types que vous pouvez utiliser.

Contrôles Active X
Les experts de Delphi facilitent la création des contrôles ActiveX. ActiveX est une technologie qui permet aux composants COM, 1
particulièrement aux contrôles, d'être plus compacts et efficaces. Cela est particulièrement important pour les contrôles conçus
pour des applications Intranet qui nécessitent leur téléchargement par le client avant de les utiliser.

Les contrôles ActiveX sont des contrôles visuels qui s'exécutent uniquement comme des serveurs en processus et qui peuvent
s'intégrer dans une application conteneur ActiveX. Ce ne sont pas des applications complètes par eux-mêmes, vous pouvez les
voir comme des contrôles OLE déjà écrits qui sont réutilisables dans diverses applications. Les contrôles ActiveX ont une
interface utilisateur apparente et reposent sur l'utilisation d'interfaces prédéfinies pour négocier les entrées/sorties et les
questions d'affichage avec le conteneur hôte.

Les contrôles ActiveX utilisent l'Automation pour exposer leurs propriétés, méthodes et événements. Leurs fonctionnalités
incluent la capacité à déclencher des événements, la liaison aux sources de données et la gestion de licence.

Les contrôles ActiveX s'utilisent parfois dans un site Web comme objets interactifs placés dans une page Web. Ainsi, ActiveX est
devenu un standard particulièrement destiné à des contenus interactifs pour le Web, y compris l'utilisation de documents ActiveX
employés pour visualiser des documents non HTML via un navigateur Web. Pour plus d'informations sur la technologie ActiveX,
voir le site Web de Microsoft.

Documents Active
Les Documents Active (préalablement appelés documents OLE) constituent un ensemble de services COM prenant en charge la
liaison et l'incorporation, le glisser-déplacer, ainsi que l'édition visuelle. Les documents Active intègrent de façon transparente
des données ou des objets de différents formats, par exemple des clips sonores, des feuilles de calcul, du texte et des images.

Au contraire des contrôles ActiveX, les Documents Active ne sont pas limités aux serveurs en processus; ils peuvent être utilisés
dans des applications inter-processus.

Au contraire des objets Automation, qui ne sont presque jamais visuels, les objets Document Active peuvent être visuellement
actifs dans une autre application. De ce fait, les objets Document Active sont associés à deux types de données : les données
de présentation, utilisées pour afficher visuellement l'objet sur un écran ou un autre périphérique de sortie, et les données
natives, utilisées pour modifier un objet.

Les objets document Active peuvent être des conteneurs ou des serveurs de documents. Bien que Delphi ne fournisse pas
d'expert pour créer automatiquement des documents Active, vous pouvez utiliser la classe TOleContainer de la VCL pour
supporter la liaison et l'incorporation dans les documents Active existants.

Vous pouvez aussi utiliser TOleContainer comme base d'un conteneur de document Active. Pour créer des objets pour les
serveurs de documents Active, utilisez une des classes de base COM de la VCL et implémentez les interfaces appropriées à ce
type d'objet, en fonction des services que l'objet doit gérer. Pour plus d'informations sur la création et l'utilisation de serveurs de
documents Active, voir le site Web Microsoft.

Remarque: Bien que la spécification des documents Active contienne une gestion intégrée du marshaling des applications à
processus croisé, les documents Active ne s'exécutent pas sur des serveurs distants car les types qu'ils utilisent (handles de
fenêtre, de menu, etc.) sont spécifiques à un système sur une machine donnée.

Objets transactionnels
Delphi utilise le terme "objets transactionnels" pour désigner des objets qui exploitent les services de transaction, la sécurité et la
gestion des ressources proposées par MTS (pour les versions de Windows antérieures à Windows 2000) ou COM+ (pour

43
 Développement d'applications COM RAD Studio 1.3 Développement des applications

Windows 2000 et plus). Ces objets sont conçus pour travailler dans des environnements distribués importants.

Les services de transaction garantissent la fiabilité assurant que des activités sont toujours achevées ou annulées. Le serveur
ne s'arrête jamais en ayant fait la moitié d'une activité. Les services de sécurité vous permettent d'exposer différents niveaux de
services à différentes classes de clients. La gestion des ressources permet à un objet de répondre à davantage de clients en
regroupant les ressources et en ne gardant des objets actifs que s'ils sont utilisés. Pour permettre au système de proposer ces
services, l'objet doit implémenter l'interface IObjectControl. Pour accéder aux services, les objets transactionnels utilisent
une interface appelée IObjectContext qui est créée pour eux par MTS ou COM+.
1 Avec MTS, l'objet serveur doit être conçu dans une bibliothèque DLL qui est installée dans l'environnement d'exécution MTS.
C'est-à-dire que l'objet serveur est un serveur en processus qui s'exécute dans l'espace de processus d'exécution MTS. Avec
COM+, cette restriction ne s'applique plus car tous les appels COM sont redirigés par un intercepteur. Pour les clients, les
différences entre MTS et COM+ sont transparentes.

Les serveurs MTS ou COM+ rassemblent les objets transactionnels dans le même espace de processus. Dans MTS, ce groupe
est appelé un package MTS, alors que dans COM+ il est appelé application COM+. Une même machine peut exécuter plusieurs
packages MTS (ou applications COM+), chacun s'exécutant dans son propre espace de processus.

Pour les clients, les objets transactionnels apparaissent semblables aux autres objets serveur COM. Le client n'a pas besoin de
savoir quoi que ce soit sur les transactions, la sécurité ou l'activation just-in-time, sauf s'il démarre lui-même une transaction.

MTS et COM+ proposent un outil distinct pour administrer les objets transactionnels. Cet outil vous permet de configurer les
objets des packages ou des applications COM+, de visualiser les packages ou les applications COM+ installés dans une
machine ou de modifier les attributs des objets, surveiller et gérer les transactions, mettre des objets à la disposition des clients,
etc. Dans MTS, cet outil s'appelle explorateur MTS. Dans COM+ c'est le gestionnaire de composants COM+.

Bibliothèques de types
Les bibliothèques de types offrent un moyen d'obtenir davantage d'informations de type sur un objet que les interfaces de l'objet.
Les bibliothèques de types contiennent les informations nécessaires sur les objets et leurs interfaces, comme les interfaces
associées à tels objets (étant donné le CLSID), les fonctions membre de chaque interface et les arguments requis par ces
fonctions.

Vous pouvez obtenir les informations de type en interrogeant une instance d'un objet pendant qu'elle s'exécute ou, en chargeant
et en lisant les bibliothèques de types. Grâce à ces informations, vous pouvez implémenter un client qui utilise un objet souhaité,
en sachant exactement les fonctions membre dont vous avez besoin, et ce qu'il faut passer à ces fonctions.

Les clients des serveurs Automation, les contrôles ActiveX et les objets transactionnels ont besoin des informations de type.
Tous les experts Delphi génèrent automatiquement une bibliothèque de types (même si c'est facultatif avec l'expert objet COM).
Vous pouvez visualiser et modifier ces informations de types en utilisant l'éditeur de bibliothèque de types.

Voir aussi
Utilisation des experts COM ( see page 86)

44
1.4 Développement d'états pour vos RAD Studio Utilisation de Rave Reports dans RAD

1.4 Développement d'états pour vos applications

Win32
RAD Studio est livré avec Rave Reports de Nevrona. A l'aide des composants d'états, vous pouvez construire des états
1
complets pour vos applications. Vous pouvez construire des solutions incluant des fonctionnalités de génération d'états, qui
pourront être utilisées et personnalisées par vos clients. De plus, les outils ComponentOne livrés avec RAD Studio incluent des
composants permettant de créer et de générer des états.

Rubriques
Nom Description
Utilisation de Rave Reports dans RAD Studio ( see page 45) L'environnement RAD Studio gère l'intégration d'objets états dans vos
applications. Cette intégration vous permet de créer un état en utilisant le
concepteur Rave Reports directement dans l'EDI de RAD Studio. Les utilisateurs
de votre application peuvent créer et afficher leurs propres états ou afficher des
états existants.

1.4.1 Utilisation de Rave Reports dans RAD Studio

L'environnement RAD Studio gère l'intégration d'objets états dans vos applications. Cette intégration vous permet de créer un
état en utilisant le concepteur Rave Reports directement dans l'EDI de RAD Studio. Les utilisateurs de votre application peuvent
créer et afficher leurs propres états ou afficher des états existants.

Création de nouveaux états dans RAD Studio

Vous pouvez inclure des états dans RAD Studio comme vous le feriez avec d'autres composants tiers. L'état est stocké comme
objet Rave Report distinct. Vous pouvez référencer l'état dans d'autres applications ayant besoin d'appeler ou de générer cet
état. Lorsque vous créez une nouvelle application, vous pouvez inclure l'objet état en y ajoutant une référence dans le
gestionnaire de projet. Rave Reports offre aussi la capacité de connecter votre objet état à une source de données, ce qui
permet à votre application de construire l'état dynamiquement sur la base d'informations de base de données actuelles.

Voir aussi
Ajout de Rave Reports à RAD Studio ( see page 88)

45
 Présentation de la VCL RAD Studio 1.5 Développement d'applications avec

1.5 Développement d'applications avec des

composants VCL
1 La VCL (Visual Component Library) est un ensemble de composants visuels permettant le développement rapide d'applications
Windows dans le langage Delphi.

La VCL contient une gamme étendue de classes utilitaires visuelles ou non visuelles pour des tâches telles que la construction
d'applications Windows, d'applications web, d'applications de bases de données et d'applications de consoles.

Rubriques
Nom Description
Présentation de la VCL ( see page 46) Cette section présente :

• Architecture de la VCL
• VCL et VCL.NET
• Composants VCL
• Utilisation des composants
Utilisation de TEncoding pour les fichiers Unicode ( see page 48)

1.5.1 Présentation de la VCL

Cette section présente :

• Architecture de la VCL
• VCL et VCL.NET
• Composants VCL
• Utilisation des composants
Architecture de la VCL
VCL est l'abréviation de Visual Component Library, un ensemble de composants visuels pour le développement rapide
d'applications Windows en langage Delphi. La VCL contient une gamme étendue de classes utilitaires visuelles ou non visuelles
pour des tâches comme la construction d'applications Windows, d'applications web, d'applications de bases de données et
d'applications de consoles. Toutes les classes dérivent de System::TObject. System::TObject introduit des méthodes qui
implémentent un comportement fondamental comme la construction, la destruction et la gestion des messages.

VCL et VCL.NET
VCL.Net contient uniquement un sous-ensemble des fonctionnalités complètes disponibles dans la VCL pour Win32. Le .NET
Framework a été architecturé pour s'adapter à n'importe quel langage compatible .NET. Dans de nombreux cas, le code source
Delphi qui fonctionne sur des classes et des fonctions VCL Win32 se recompile avec un minimum de modifications sur .NET. Il
peut même arriver qu'il se recompile sans aucune modification. Puisque VCL.NET est un sous-ensemble étendu de la VCL, il
prend en charge de nombreuses classes VCL existantes. Toutefois, le code source qui appelle directement l'API Win32
nécessite des modifications.

Composants VCL
Les composants forment un sous-ensemble de la bibliothèque de composants qui dérive de la classe TComponent. Vous

46
1.5 Développement d'applications avec RAD Studio Présentation de la VCL

pouvez placer les composants dans une fiche ou un module de données et les manipuler pendant la conception. En utilisant
l'inspecteur d'objets, vous pouvez affecter les valeurs de propriétés sans écrire de code. La plupart des composants sont
visuels ou non, selon qu'ils apparaissent ou non à l'exécution. Certains des composants apparaissent sur la palette des
composants.

Composants visuels
Les composants visuels, comme TForm ou TSpeedButton, sont appelés des contrôles et dérivent de TControl. Les contrôles
sont utilisés dans des applications à interface utilisateur graphique et ils apparaissent à l'utilisateur lors de l'exécution. TControl 1
fournit des propriétés qui spécifient les attributs visuels des contrôles, comme leur hauteur et leur largeur.

Composants non visuels

Les composants non visuels sont utilisés pour diverses tâches. Si, par exemple, vous écrivez une application qui se connecte à
une base de données, vous pouvez placer un composant TDataSource sur une fiche pour connecter un contrôle et un ensemble
de données utilisé par ce contrôle. Cette connexion étant invisible pour l'utilisateur, TDataSource est donc non visuel. A la
conception, les composants non visuels sont représentés par une icône. Cela vous permet de manipuler leurs propriétés et
événements comme un contrôle visuel.

Autres classes VCL

Les classes qui ne sont pas des composants (c'est-à-dire les classes qui dérivent de System::TObject mais pas de
TComponent) sont également utilisées pour plusieurs tâches. Généralement, ces classes sont utilisées pour l'accès aux objets
système (tels qu'un fichier ou le Presse-papiers) ou pour les tâches transitoires (telles que le stockage des données dans une
liste). Vous ne pouvez pas créer d'instances de ces classes lors de la conception, bien qu'elles soient quelquefois créées par les
composants que vous ajoutez dans le concepteur de fiche.

Utilisation des composants

De nombreux composants sont fournis par l'EDI dans la palette de composants. Vous sélectionnez des composants dans la
palette de composants et les placez sur une fiche ou un module de données. Vous concevez l'interface utilisateur d'une
application en disposant des composants visuels, boutons ou listes, sur une fiche. Vous pouvez également placer des
composants non visuels, comme les composants d'accès aux données, dans une fiche ou un module de données. A première
vue, les composants de Delphi ressemblent aux autres classes. Mais, il existe des différences entre les composants de Delphi et
les hiérarchies de classes standard avec lesquelles travaillent de nombreux programmeurs. Voici certaines de ces différences :

• Tous les composants Delphi dérivent de TComponent.

• Les composants sont la plupart du temps utilisés tels quels. Ils sont modifiés par le biais de leurs propriétés, au lieu de servir
de classes de base à sous-classer pour ajouter des fonctionnalités ou modifier celles qui existent. Quand un composant est
dérivé, on ajoute généralement du code spécifique aux fonctions membres de gestion des événements existants.
• Les composants sont alloués uniquement sur le tas et non sur la pile.
• Les propriétés des composants contiennent des informations de type à l'exécution.
• Des composants peuvent être ajoutés à la palette de composants de l'EDI et manipulés sur une fiche.
Les composants offrent souvent un meilleur degré d'encapsulation que les classes standard. Considérez, par exemple, une
boîte de dialogue contenant un bouton. Dans un programme Windows développé en utilisant les composants de la VCL,
lorsqu'un utilisateur clique sur le bouton, le système génère un message WM_LBUTTONDOWN. Le programme doit intercepter
ce message (généralement dans une instruction switch, une carte de messages ou une table de réponses) et l'envoyer à une
routine qui s'exécutera en réponse au message. La plupart des messages Windows (applications VCL) sont gérés par les
composants Delphi. Quand vous voulez répondre à un message ou événement système, il vous suffit de fournir un
gestionnaire d'événement.

Utilisation des événements

L'essentiel du code que vous écrivez est exécuté, directement ou indirectement, en réponse à des événements. Un événement
est un type particulier de propriété qui représente une situation à l'exécution, généralement une action de l'utilisateur. Le code

47
 Utilisation de TEncoding pour les fichiers RAD Studio 1.5 Développement d'applications avec

qui répond directement à un événement, que l'on appelle un gestionnaire d'événement, est une procédure Delphi.

La page Evénements de l'inspecteur d'objets affiche tous les événements définis pour un composant donné. Un double-clic
sur un événement dans l'inspecteur d'objets génère un squelette de la procédure de gestion de l'événement, que vous pouvez
remplir de code pour répondre à cet événement. Certains composants n'ont pas d'événements définis.

Certains composants ont un événement par défaut, celui que le composant a le plus souvent besoin de gérer. Par exemple,
l'événement par défaut d'un bouton est OnClick. Un double-clic sur un composant avec un événement par défaut dans le
concepteur de fiches générera un squelette de la procédure de gestion de l'événement pour l'événement par défaut.
1
Vous pouvez réutiliser le code en écrivant des gestionnaires d'événements qui gèrent plusieurs événements de composants. Par
exemple, de nombreuses applications proposent des turboboutons qui sont l'équivalent de commandes de la barre des menus.
Lorsqu'un bouton effectue la même action qu'une commande de menu, vous pouvez écrire un seul gestionnaire d'événement et
l'affecter ensuite à l'événement OnClick du bouton et de l'élément de menu, en définissant dans l'inspecteur d'objets le
gestionnaire pour les événements auxquels vous voulez répondre.

Il s'agit de la méthode la plus simple pour réutiliser les gestionnaires d'événements. Toutefois, les listes d'actions et, dans la
VCL, les bandes d'actions, sont des outils puissants pour centraliser l'organisation du code répondant à des commandes
utilisateur. Les listes d'actions peuvent être utilisées dans les applications multiplates-formes ; les bandes d'actions ne le
peuvent pas.

Initialisation des propriétés d'un composant

Les propriétés publiées peuvent être initialisées à la conception avec l'inspecteur d'objets ou, dans certains cas, avec des
éditeurs de propriétés. Pour spécifier des propriétés à l'exécution, il suffit d'initialiser leur valeur dans le code source de votre
application.

A la conception, quand vous sélectionnez un composant d'une fiche, l'inspecteur d'objets affiche ses propriétés publiées et
vous permet, si c'est approprié, de les modifier.

Si plusieurs composants sont sélectionnés, l'inspecteur d'objets affiche toutes les propriétés, sauf Name, communes aux
composants sélectionnés. Si la valeur d'une propriété partagée n'est pas la même pour tous les composants sélectionnés,
l'inspecteur d'objets affiche soit la valeur par défaut, soit la valeur de la propriété pour le premier composant sélectionné.
Quand vous modifiez une propriété partagée, la modification s'applique à tous les composants sélectionnés.

La modification de propriétés liées au code dans l'inspecteur d'objets, comme le nom d'un gestionnaire d'événement, modifie
automatiquement le code source correspondant. De plus, les modifications du code source, comme le changement de nom
d'une méthode de gestionnaire d'événement dans la déclaration de classe d'une fiche, se reflètent immédiatement dans
l'inspecteur d'objets.

Voir aussi
Construction d'une application Fiches VCL ( see page 108)

Construction d'une application Fiches VCL "Hello world" ( see page 109)

Organisation des actions pour les barres d'outils et les menus ( see page 2060)

1.5.2 Utilisation de TEncoding pour les fichiers Unicode

Lecture et écriture à l'ancien format
De nombreuses applications Delphi auront toujours besoin d'interagir avec d'autres applications ou sources de données,
beaucoup d'entre elles peuvent seulement gérer les données au format ANSI ou ASCII. Pour cette raison, les valeurs par défaut
des méthodes TStrings écriront les fichiers codés ANSI selon la page de code active et liront les fichiers selon que le fichier

48
1.5 Développement d'applications avec RAD Studio Utilisation de TEncoding pour les fichiers

contient ou ne contient pas un BOM (Byte Order Mark).

Si un BOM est trouvé, les données seront lues comme l'indique le BOM. Si aucun BOM n'est trouvé, les données seront lues en
ANSI et converties selon la page de code active.

Tous les fichiers écrits avec les versions de Delphi antérieures à Tiburon pourront toujours être lus sans problème, avec la
garantie que vous lirez avec la page de code active exactement ce qui a été écrit. De même, tout fichier écrit avec Tiburón avec
un codage ASCII devrait être lisible avec une version antérieure à Tiburón.

Tout fichier écrit avec Tiburón avec un autre codage génèrera un BOM et ne sera pas lisible avec une version antérieure à 1
Tiburón. A ce stade, seuls sont détectés les formats BOM les plus courants (UTF16 Little-Endian, UTF16 Big-Endian et UTF8).

Utilisation des nouveaux codages

Beaucoup d'entre vous voudront lire/écrire les données texte à l'aide de la classe TStrings, un format Unicode à moindre perte,
comme Little-Endian UTF16, Big-Endian UTF16, UTF8, UTF7, etc… La classe TEncoding est très similaire dans les méthodes
et les fonctionnalités à la classe System.Text.Encoding de .NET Framework.
var
S:Stringlist
begin
S: Tstringlist.Create;
-
S.SaveFile('config.txt', TEncoding UTF8);
Sans paramètre supplémentaire, 'config.txt' serait simplement converti et écrit en ANSI codé selon la page de code active. La
chose intéressante à noter ici est que vous n'avez pas besoin de changer le code de lecture puisque TStrings détectera
automatiquement le codage basé sur le BOM et prendra la bonne décision.

Si vous voulez forcer la lecture et l'écriture du fichier en utilisant une page de code spécifique, vous pouvez créer une instance
de TMBCSEncoding et passer la page de code à utiliser dans le constructeur. Utilisez ensuite cette instance pour lire et écrire le
fichier puisque la page de code spécifique peut ne pas correspondre à la page de code active de l'utilisateur.

La même chose tient pour ces classes dans le fait que les données seront lues et écrites comme des données ANSI. Puisque
les fichiers INI ont toujours été traditionnellement codés en ANSI (ASCII), cela peut n'avoir aucun sens de les convertir. Cela
dépendra des besoins de votre application. Si vous préférez utiliser un format Unicode, nous vous offriront des façons d'utiliser
les classes TEncoding pour ce faire.

Dans tous les cas ci-dessus, le stockage interne sera Unicode et toute manipulation de données effectuée avec les chaînes
continuera à fonctionner comme prévu. Les conversions se produiront automatiquement lors de la lecture et de l'écriture des
données. Ceux qui sont familiers avec VCL pour .NET savent déjà comment tout ce qui est au-dessus fonctionne puisque les
nouvelles surcharges ajoutées à TStrings ont été introduites avec VCL pour .NET et utilisent la classe System.Text.Encoding
pour toutes ces opérations.

Voici la liste des identificateurs de page de code (MSDN).

Voici la liste des méthodes de surcharge qui acceptent un paramètre TEncoding :

ComCtrls.TOutlineNode.WriteNode

Outline.TOutlineNode.LoadFromFile

Outline.TOutlineNode.LoadFromStream

Outline.TOutlineNode.SaveToFile

Outline.TOutlineNode.SaveToStream

ComCtrls.TOutlineNode.WriteNode

Classes.TStrings.LoadFromFile

Classes.TStrings.LoadFromStream

49
 Utilisation de TEncoding pour les fichiers RAD Studio 1.5 Développement d'applications avec

Classes.TStrings.SaveToFile

Classes.TStrings.SaveToStream

Classes.TStringStream.Create

Classes.TStreamReader.Create

Classes.TStreamWriter.Create

50
1.6 Développement d'applications Web RAD Studio Présentation des applications Web Win32

1.6 Développement d'applications Web avec

WebSnap
Cette section fournit l'arrière-plan conceptuel de construction des applications WebSnap avec RAD Studio. WebSnap facilite la
1
construction d'applications serveur Web fournissant des pages Web complexes orientées données. La prise en charge par
WebSnap des modules multiples et des scripts côté serveur facilite le développement et la maintenance pour les équipes de
développeurs et de concepteurs Web.

Veuillez noter que WebSnap est en cours de dépréciation dans RAD Studio. Bien que WebSnap soit toujours documenté dans
l'aide en ligne, le produit WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser IntraWeb (VCL pour le
Web). IntraWeb ( see page 2330) est documenté dans cette aide en ligne. Pour obtenir davantage de documentation sur la
VCL pour le Web, visitez http://www.atozed.com/intraweb/docs/.

Rubriques
Nom Description
Présentation des applications Web Win32 ( see page 51) Cette section couvre :

• Prise en charge des applications Web

• Présentation de Web Broker
• Présentation de Web Snap
• Débogage à l'aide du débogueur d'applications Web
Pour des informations plus détaillées sur les applications
web, consultez le guide du développeur Win32, à la
section Référence de ce système d'aide.

1.6.1 Présentation des applications Web Win32

Cette section couvre :

• Prise en charge des applications Web

• Présentation de Web Broker
• Présentation de Web Snap
• Débogage à l'aide du débogueur d'applications Web
Pour des informations plus détaillées sur les applications web, consultez le guide du développeur Win32, à la section Référence
de ce système d'aide.
Prise en charge des applications Web Win32
Les types d'applications web pris en charge dans RAD Studio sont les suivants.

• ISAPI
• CGI
• Débogueur d'applications Web
Les applications web Apache ne sont pas prises en charge pour cette version.

51
 Présentation des applications Web Win32 RAD Studio 1.6 Développement d'applications Web

ISAPI
La sélection de ce type d'application configure votre projet comme une DLL proposant les méthodes exportées attendues par le
serveur Web. Il ajoute l'en-tête de bibliothèque au fichier projet et les entrées nécessaires à la liste uses et à la clause exports
du fichier projet.

CGI
1 La sélection de ce type d'application configure votre projet comme application console et ajoute les entrées nécessaires à la
clause uses du fichier projet.

Débogueur d'applications Web

La sélection de ce type d'application configure un environnement pour développer et tester des applications serveur Web. Ce
type d'application n'est pas destiné au déploiement.

Présentation de Web Broker

Les composants WebBroker (situés sur l'onglet Internet de la palette de composants) vous permettent de créer des
gestionnaires d'événements associés à un identificateur de ressource uniforme (URI) spécifique. Lorsque le traitement est
terminé, vous pouvez construire des documents HTML ou XML dans votre programme et les transférer au client. Vous pouvez
utiliser les composants WebBroker pour le développement d'applications multiplates-formes.

En règle générale, le contenu des pages Web est issu de bases de données. Vous pouvez utiliser les composants Internet pour
gérer automatiquement les connexions aux bases de données, ce qui permet à une seule DLL de gérer plusieurs connexions
simultanées aux bases de données sans problèmes de thread.

Présentation de Web Snap

Remarque: WebSnap est en cours de dépréciation dans RAD Studio. Bien que WebSnap soit toujours documenté dans l'aide
en ligne, le produit WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser IntraWeb (VCL pour le Web).
IntraWeb ( see page 2330) est documenté dans cette aide en ligne. Pour obtenir davantage de documentation sur la VCL pour
le Web, visitez http://www.atozed.com/intraweb/docs/.

WebSnap ajoute à WebBroker des composants, des experts et des vues, ce qui facilite la construction d'applications de serveur
Web présentant des pages Web complexes orientées données. La prise en charge par WebSnap des modules multiples et des
scripts côté serveur facilite le développement et la maintenance pour les équipes de développeurs et de concepteurs Web.
WebSnap permet aux experts en conception HTML de votre équipe d'apporter une contribution plus efficace au développement
et à la maintenance des serveurs Web.

Le produit final du processus de développement WebSnap inclut une série de templates de page HTML à scripts. Ces pages
peuvent être modifiées au moyen d'éditeurs HTML prenant en charge les balises de script incorporées, comme Microsoft
FrontPage, ou même un éditeur de texte. Des modifications peuvent être apportées aux templates selon les besoins, même
après le déploiement de l'application. Il n'est pas nécessaire de modifier le code source du projet, ce qui économise du temps de
développement précieux. La prise en charge de modules multiples par WebSnap peut être utilisée pour diviser votre application
en plus petites parties pendant les phases de codage de votre projet, de sorte que les développeurs puissent travailler de façon
plus indépendante.

Débogage à l'aide du débogueur d'applications Web

Le débogueur d'application Web est un moyen facile de contrôler les demandes et les réponses http, comme de surveiller les
temps de réponse. Le débogueur d'application Web remplace le serveur Web. Une fois l'application déboguée, vous pouvez la
convertir en l'un des types d'applications Web supportés et l'installer sur un serveur Web du commerce.

Pour utiliser le débogueur d'application Web, vous devez commencer par créer votre application Web comme exécutable
débogueur d'application Web. Que vous utilisiez WebBroker ou WebSnap, l'expert qui crée votre application serveur Web le
propose comme option au début de l'application. Cette opération crée une application serveur Web qui est également un serveur
COM. A sa première exécution, votre application recense votre serveur COM afin que le débogueur d'application Web puisse y

52
1.6 Développement d'applications Web RAD Studio Présentation des applications Web Win32

accéder. Avant de pouvoir exécuter le débogueur d'application Web, vous devez exécuter une fois bin\serverinfo.exe afin
de recenser l'application ServerInfo.

Démarrage de l'application avec le débogueur d'application Web

Une fois votre application serveur Web développée, vous pouvez l'exécuter et la déboguer en utilisant le débogueur d'application
Web. Vous pouvez définir des points d'arrêt comme pour déboguer n'importe quel autre exécutable. Lorsque vous exécutez
votre application, elle affiche la fenêtre de console du serveur COM qui constitue votre application serveur Web. Après le
démarrage de votre application et l'exécution du débogueur d'application Web, la page ServerInfo s'affiche dans votre navigateur 1
par défaut et vous pouvez sélectionner votre application à partir d'une liste déroulante. Lorsque vous avez sélectionné votre
application, cliquez sur le bouton de démarrage. Cela démarre votre application dans le débogueur d'application Web, qui vous
donne des détails sur les messages de requête et de réponse échangés entre votre application et le débogueur d'application
Web.

Conversion de votre application en un autre type d'application de serveur Web après le débogage
Une fois la mise au point de votre application serveur Web avec le débogueur d'application Web achevée, vous devez la
convertir en un autre type d'application Web susceptible d'être installé sur un serveur Web commercial.

Voir aussi
Construction d'une application WebSnap ( see page 157)

Construction d'une application "Hello world" WebSnap ( see page 158)

Débogage d'une application WebSnap à l'aide du débogueur d'application Web ( see page 160)

Conversion de votre application en un autre type d'application de serveur Web ( see page 2321)

Utilisation d'IntraWeb ( see page 2330)

53
 Présentation des services Web RAD Studio 1.7 Développement de services Web avec

1.7 Développement de services Web avec des

applications Win32
1 Les services Web sont des applications modulaires indépendantes qui peuvent être publiées ou invoquées sur Internet. Les
services Web fournissent des interfaces bien définies qui décrivent les services fournis. A la différence des applications de
serveur Web qui génèrent des pages Web pour les navigateurs client, les services Web ne sont pas conçus pour une interaction
humaine directe. Ils sont plutôt destinés à être appelés par programme de la part d'applications client. Cette section contient une
présentation des services web et de leur prise en charge.

Rubriques
Nom Description
Présentation des services Web ( see page 54) Les applications de services Web sont des implémentations de serveur
n'imposent pas au client l'utilisation d'une plate-forme ou d'un langage de
programmation spécifique. Ces applications définissent des interfaces dans un
document indépendant du langage et elles autorisent de nombreux mécanismes
de communication.
Les services web sont conçus pour fonctionner avec SOAP (Simple Object
Access Protocol). SOAP est un protocole standard allégé définissant l'échange
d'informations dans un environnement décentralisé et distribué. SOAP utilise
XML pour coder les appels de procédures distantes et, habituellement, HTTP
comme protocole de communication.
Les applications de services web publient des informations sur les interfaces
disponibles et... suite ( see page 54)

1.7.1 Présentation des services Web

Les applications de services Web sont des implémentations de serveur n'imposent pas au client l'utilisation d'une plate-forme ou
d'un langage de programmation spécifique. Ces applications définissent des interfaces dans un document indépendant du
langage et elles autorisent de nombreux mécanismes de communication.

Les services web sont conçus pour fonctionner avec SOAP (Simple Object Access Protocol). SOAP est un protocole standard
allégé définissant l'échange d'informations dans un environnement décentralisé et distribué. SOAP utilise XML pour coder les
appels de procédures distantes et, habituellement, HTTP comme protocole de communication.

Les applications de services web publient des informations sur les interfaces disponibles et sur la manière de les appeler à l'aide
d'un document WSDL (Web Service Definition Language). Côté serveur, votre application peut publier un document WSDL
décrivant votre service Web. Côté client, un expert ou un utilitaire en ligne de commande peut importer un document WSDL
publié afin de vous proposer les définitions d'interfaces et les informations de connexion dont vous avez besoin. Si vous
possédez déjà un document WSDL qui décrit le service Web que vous voulez implémenter, vous pouvez aussi générer le code
côté serveur lors de l'importation du document WSDL.

Voir aussi
Utilisation de services Web ( see page 2388)

54
1.8 Développement d'applications Windows RAD Studio Présentation de Windows

1.8 Développement d'applications Windows

Windows propose une approche traditionnelle du développement d'interfaces utilisateur, d'applications client/serveur, de
contrôles et de la logique applicative. Cette section propose une présentation du développement d'applications Windows utilisant
RAD Studio pour Win32 et décrit les étapes de construction d'un projet Windows simple. 1
Rubriques
Nom Description
Présentation de Windows ( see page 55) La plate-forme Windows vous aide à créer et construire des applications de
différentes manières. Les types d'applications Windows les plus courants sont
les suivants :

• Applications GUI
• Applications console
• Applications de service
• Packages et DLL

1.8.1 Présentation de Windows

La plate-forme Windows vous aide à créer et construire des applications de différentes manières. Les types d'applications
Windows les plus courants sont les suivants :

• Applications GUI
• Applications console
• Applications de service
• Packages et DLL
Applications GUI
Une application à interface utilisateur graphique (GUI) utilise des fonctionnalités graphiques telles que les fenêtres, les menus et
les boîtes de dialogue, ainsi que des fonctionnalités qui facilitent l'utilisation de l'application. Quand vous compilez une
application GUI, un fichier exécutable contenant du code de démarrage est créé à partir de vos fichiers source. Généralement,
l'exécutable fournit les fonctionnalités de base de votre programme. Les programmes simples se composent souvent d'un seul
fichier exécutable. Vous pouvez aussi étendre une application en appelant des DLL, des packages ou d'autres bibliothèques
complétant un exécutable.

L'EDI de RAD Studio offre deux modèles d'interface utilisateur d'application :

• L'interface de document unique (Single Document Interface, SDI)

• L'interface de document multiple (Multiple Document Interface, MDI)

L'interface de document unique

Une application SDI ne contient normalement qu'une seule vue de document.

L'interface de document multiple

Dans une application MDI, plusieurs documents ou fenêtres enfant peuvent être ouverts dans une seule fenêtre parent. Cela est

55
 Présentation de Windows RAD Studio 1.8 Développement d'applications Windows

courant dans les applications comme les tableurs ou les traitements de texte.

Les applications MDI nécessitent plus de réflexion et sont plus complexes à concevoir que les applications SDI. Les applications
MDI contiennent des fenêtres enfant qui se trouvent dans la fenêtre client ; la fiche principale contient des fiches enfant. Par
exemple, définissez la propriété FormStyle de l'objet TForm pour spécifier si la fiche est un enfant (fsMDIChild) ou la fiche
principale (fsMDIForm). Il est recommandé de définir une classe de base pour les fiches enfant et de dériver chaque fiche enfant
de cette classe. Sinon, vous risqueriez d'avoir à réinitialiser les propriétés de fiche de l'enfant. Les applications MDI proposent
souvent des options du menu principal comme Cascade et Mosaïque pour afficher plusieurs fenêtres de diverses manières.
1 Quand une fenêtre enfant est réduite, son icône est placée dans la fenêtre parent MDI.

Applications console
Les applications console sont des programmes 32-bits exécutés sans interface graphique, dans une fenêtre console.
Habituellement, ces applications ne nécessitent pas une saisie utilisateur importante et accomplissent un jeu limité de fonctions.
Toute application contenant {$APPTYPE CONSOLE} dans son code ouvre une fenêtre console qui lui est propre.

Applications de service
Les applications de service reçoivent les requêtes des applications client, traitent ces requêtes et renvoient les informations aux
applications client. Habituellement, les applications de service s'exécutent en arrière-plan, sans nécessiter de saisie utilisateur
importante. Un serveur Web, FTP ou de messagerie électronique est un exemple d'application de service.

Création de packages et de DLL

Les bibliothèques de liaison dynamique (DLL) sont des modules de code compilés qui fonctionnent en conjonction avec un
exécutable pour proposer des fonctionnalités à une application. Vous pouvez créer des DLL dans des programmes
multiplates-formes.

Les packages sont des DLL spéciales utilisées par les applications Delphi, par l'EDI ou les deux à la fois. Il existe deux types de
packages, d'exécution et de conception. Les packages d'exécution fournissent des fonctionnalités à un programme lors de son
exécution. Les packages de conception permettent d'étendre les fonctionnalités de l'EDI.

Pour la plupart des applications, les packages offrent une plus grande flexibilité et sont plus simples à créer que les DLL.
Cependant, dans quelques cas, les DLL fonctionnent mieux que les packages :

• Votre module de code est appelé par une application qui n'a pas été conçue avec Delphi.
• Vous étendez les fonctionnalités d'un serveur Web.
• Vous créez un module de code qui doit être utilisé par des développeurs extérieurs.
• Votre projet est un conteneur OLE.
Vous ne pouvez pas transmettre des informations de type à l'exécution (RTTI) Delphi entre DLL ou d'une DLL à un exécutable.
Si vous transmettez un objet d'une DLL vers une autre ou vers un exécutable, vous ne pouvez pas utiliser les opérateurs is
ou as avec l'objet transmis. En effet, les opérateurs is et as doivent comparer les informations RTTI. Si vous devez
transmettre des objets à partir d'une bibliothèque, utilisez des packages de préférence aux DLL, car ils peuvent partager les
informations RTTI. De même, vous devez utiliser des packages au lieu de DLL dans les services Web car ils reposent sur des
informations RTTI Delphi.
Voir aussi
Construction d'une application Windows ( see page 97)

56
2 RAD Studio

2 Procédures
Cette section présente les procédures relatives aux diverses zones de développement de RAD Studio.

Rubriques
Nom Description
Procédures CodeGuard ( see page 58) Utilisez ces procédures pour déboguer vos applications C++ avec CodeGuard.
Procédures de bases de données ( see page 60) Cette rubrique décrit la manière d'utiliser les composants de base de données de
la palette d'outils, tels que les composants dbGo, dbExpress, BDE et
DataSnap.
Procédures d'applications interopérables ( see page 86) Delphi fournit des experts et des classes qui facilitent l'implémentation
2
d'applications basées sur COM (Component Object Model) de Microsoft. Les
objets COM les plus simples sont des serveurs qui exposent des propriétés et
des méthodes (et éventuellement des événements) via une interface par défaut
que leurs clients peuvent appeler. L'expert d'objet COM construit un objet COM
léger dont l'interface par défaut descend de IUnknown ou qui implémente une
interface déjà recensée dans votre système. Cet expert offre la plus grande
flexibilité dans les types d'objets COM qu'il est possible de créer.
Procédures de génération d'états ( see page 88) Cette rubrique propose des informations relatives à l'utilisation de solutions de
génération d'états.
Procédures VCL ( see page 89) Cette section propose des informations relatives au développement
d'applications VCL pour Win32.
Procédures WebSnap ( see page 157) Cette section propose des informations relatives au développement
d'applications WebSnap.
Veuillez noter que WebSnap est en cours de dépréciation dans RAD Studio.
Bien que WebSnap soit toujours documenté dans l'aide en ligne, le produit
WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser
IntraWeb (VCL pour le Web). IntraWeb ( see page 2330) est documenté dans
cette aide en ligne. Pour obtenir davantage de documentation sur la VCL pour le
Web, visitez http://www.atozed.com/intraweb/docs/.
Procédures de services Web ( see page 162) Cette section propose des informations relatives au développement et à
l'utilisation de services web.

57
 Utilisation de CodeGuard RAD Studio 2.1 Procédures CodeGuard

2.1 Procédures CodeGuard

Utilisez ces procédures pour déboguer vos applications C++ avec CodeGuard.

Rubriques
Nom Description
Utilisation de CodeGuard ( see page 58) Cette procédure décrit comment utiliser CodeGuard lors du débogage d'une
application C++.

2.1.1 Utilisation de CodeGuard

Cette procédure décrit comment utiliser CodeGuard lors du débogage d'une application C++.

Pour exécuter une application C++ en profitant du signalement des erreurs effectué par CodeGuard
1. Activez l'outil de reporting CodeGuard.
2. Activez les options CodeGuard du compilateur pour votre projet.
3. Choisissez Exécuter Exécuter pour lancer l'application.
Au cours de l'exécution de votre application, les erreurs d'exécution détectées par CodeGuard apparaissent dans la vue
Message.
2
CodeGuard génère également un journal d'erreurs nommé <nom_projet>.cgl qui liste toutes les erreurs qu'il trouve. Le
journal d'erreurs est situé dans le même répertoire que votre exécutable.
Remarque: Si vous pensez que votre programme accède à un bloc mémoire libéré mais que CodeGuard ne signale pas
d'erreur, essayez d'augmenter la valeur de Taille de bloc mémoire maximum
ou de Longueur de queue de retard sur la page Options de ressources de la boîte de dialogue de configuration de
CodeGuard.

Activez l'outil de reporting CodeGuard.

1. Choisissez Outils Configuration CodeGuard pour afficher la boîte de dialogue Configuration CodeGuard.
2. Vérifiez que CodeGuard est activé.
3. Cliquez sur OK.
Remarque: Si vous modifiez un des paramètres CodeGuard dans la boîte de dialogue Configuration CodeGuard
, CodeGuard génère un fichier de configuration .cgi portant le même nom et situé dans le même répertoire que le fichier de
votre projet.

Pour activer les options CodeGuard du compilateur pour votre projet

1. Choisissez Projet Options Compilateur C++ Débogage pour afficher les options CodeGuard du compilateur.
2. Cochez Activer toutes les options Codeguard pour activer une couverture CodeGuard complète.
3. Cliquez sur OK.
4. Reconstruisez votre projet.
Remarque: Si vous effectuez la compilation et la liaison séparément, n'oubliez pas d'inclure la bibliothèque CodeGuard
(cg32.lib

58
2.1 Procédures CodeGuard RAD Studio Utilisation de CodeGuard

) avant toutes les autres bibliothèques.

Voir aussi
Présentation de CodeGuard ( see page 9)

Boîte de dialogue Configuration CodeGuard

59
 RAD Studio 2.2 Procédures de bases de données

2.2 Procédures de bases de données

Cette rubrique décrit la manière d'utiliser les composants de base de données de la palette d'outils, tels que les composants
dbGo, dbExpress, BDE et DataSnap.

Rubriques
Nom Description
Accès aux informations de schéma ( see page 61) Ces informations de schéma ou métadonnées indiquent quelles tables et quelles
procédures stockées sont accessibles sur le serveur et donnent des précisions
sur ces tables et ces procédures stockées (comme les champs d'une table, les
index définis et les paramètres utilisés par une procédure stockée).
Configuration d'une connexion TSQL ( see page 62) La première étape du travail avec un ensemble de données unidirectionnel est
de se connecter à un serveur de base de données. A la conception, une fois
qu'un ensemble de données dispose d'une connexion active à un serveur de
base de données, l'inspecteur d'objets peut fournir des listes déroulantes de
valeurs pour les autres propriétés. Par exemple, s'il s'agit d'une procédure
stockée, il faut qu'une connexion soit active pour que l'inspecteur d'objets
puisse indiquer les procédures stockées disponibles sur le serveur. La connexion
à un serveur de base de données est représentée par un composant
TSQLConnection distinct. Vous utilisez TSQLConnection... suite ( see page
62)
Connexion au serveur d'applications à l'aide de composants DataSnap ( see Une application client utilise un ou plusieurs composants connexion appartenant
page 64) à la catégorie DataSnap de la palette d'outils pour établir et maintenir une
connexion à un serveur d'applications.
Débogage d'applications dbExpress à l'aide de TSQLMonitor ( see page 65) Lors du débogage de votre application de base de données, vous pouvez
contrôler les messages SQL envoyés à la base de données et reçus de celle-ci
par le biais de votre composant connexion, y compris ceux automatiquement
générés (par exemple, par un composant fournisseur ou par le pilote dbExpress).
2 Exécution des commandes à l'aide de TSQLDataSet ( see page 65) Vous pouvez utiliser un ensemble de données unidirectionnel même si la requête
ou la procédure stockée qu'il représente ne renvoie pas d'enregistrement. Parmi
ces commandes, on trouve des instructions utilisant le langage de définition de
données (DDL) ou le langage de manipulation de données (DML), mais pas des
instructions SELECT. Le langage utilisé dans les commandes est spécifique au
serveur mais généralement conforme au standard SQL-92 du langage SQL. La
commande SQL que vous exécutez doit être acceptable pour le serveur que
vous utilisez. Les ensembles de données unidirectionnels n'évaluent pas la
commande SQL et ne l'exécutent pas : ils transmettent... suite ( see page 65)
Récupération des données à l'aide de TSQLDataSet ( see page 67)
Spécification des données à afficher à l'aide de TSQLDataSet ( see page 68)
Spécification du fournisseur à l'aide d'un composant TLocalConnection ou Les ensembles de données client sont des ensembles de données spécialisés
TConnectionBroker ( see page 69) qui stockent toutes les données en mémoire. Ils utilisent un fournisseur pour
obtenir les données et appliquer les mises à jour lorsqu'ils stockent en mémoire
cache des mises à jour d'un serveur de base de données ou d'un autre ensemble
de données, représentent les données dans un document XML et les stockent
dans la partie client d'une application multiniveau.
Utilisation du BDE ( see page 70)
Utilisation de DataSnap ( see page 70) Une application client/serveur multiniveau est partitionnée en unités logiques,
appelées niveaux, dont les différentes unités fonctionnent en coordination les
unes avec les autres sur des machines séparées. Les applications multiniveaux
partagent des données et communiquent par un réseau local voire même par
Internet. Elles offrent de nombreux avantages, comme les applications clients
simples et la logique d'entreprise centralisée.
Les applications multiniveaux utilisent les composants de la catégorie DataSnap
de la palette d'outils. DataSnap fournit des fonctionnalités de bases de données
multiniveaux aux applications Delphi en permettant aux applications client de se
connecter aux fournisseurs d'un serveur d'applications.
Utilisation de TBatchMove ( see page 71) TBatchMove copie une structure de table et ses données. Il peut être utilisé pour
transformer des tables entières d'un format de base de données dans un autre.

60
2.2 Procédures de bases de données RAD Studio Accès aux informations de schéma

Connexion aux bases de données avec TDatabase ( see page 72) TDatabase met en place une connexion persistante à une base de données, en
particulier à une base de données distante nécessitant un nom de connexion
utilisateur et un mot de passe. TDatabase est particulièrement utile car il permet
de contrôler le traitement des transactions par le BDE lors d'une connexion à un
serveur SQL distant. Utilisez TDatabase quand une application de base de
données basée sur le BDE nécessite les opérations suivantes :

• Connexions persistantes avec la base de données

• Accès personnalisés à un serveur de bases de données
• Contrôle des transactions
• Alias BDE spécifiques à l'application
Utilisation de TQuery ( see page 73) TQuery est un ensemble de données de type requête qui encapsule une
instruction SQL et permet aux applications d'accéder aux enregistrements
éventuellement obtenus.
Utilisation de TSQLQuery ( see page 75) TSQLQuery représente une requête exécutée en utilisant dbExpress.
TSQLQuery peut représenter les résultats d'une instruction SELECT ou réaliser
des actions sur le serveur de bases de données en utilisant des instructions
telles que INSERT, DELETE, UPDATE, ALTER TABLE, etc. Vous pouvez
ajouter un composant TSQLQuery à une fiche lors de la conception, ou en créer
un dynamiquement à l'exécution.
Utilisation de TSQLStoredProc ( see page 76) TSQLStoredProc représente une procédure stockée exécutée en utilisant
dbExpress. TSQLStoredProc peut représenter l'ensemble de résultats si la
procédure stockée renvoie un curseur. Vous pouvez ajouter un composant
TSQLStoredProc à une fiche lors de la conception, ou en créer un
dynamiquement à l'exécution.
Utilisation de TSQLTable ( see page 77) TSQLTable représente une table de base de données à laquelle on accède en
utilisant dbExpress. TSQLTable génère une requête permettant de récupérer
toutes les lignes et colonnes d'une table spécifiée. Vous pouvez ajouter un
composant TSQLTable à une fiche lors de la conception, ou en créer un
dynamiquement à l'exécution.
Gestion des sessions de bases de données avec TSession ( see page 78) Une session fournit une connexion globale sur un groupe de composants base
de données. Un composant TSession par défaut est créé automatiquement pour
chaque application base de données. Vous ne devez utiliser le composant 2
TSession que si vous créez une application de base de données multithread.
Chaque thread de la base de données doit avoir ses propres composants
Session.
Utilisation de TSimpleDataSet ( see page 78) TSimpleDataSet est un type spécial d'ensemble de données client conçu pour
les applications à deux niveaux simples. A l'image d'un ensemble de données
unidirectionnel, il peut utiliser un composant connexion SQL pour se connecter à
un serveur de bases de données et spécifier une instruction SQL à exécuter sur
ce serveur. Comme les autres ensembles de données client, il place les données
en mémoire tampon afin d'offrir une totale liberté de navigation et d'édition.
Utilisation de TSimpleObjectBroker ( see page 79) Si votre application client peut choisir parmi plusieurs serveurs basés sur COM,
vous pouvez utiliser un courtier d'objets pour localiser un système serveur
disponible.
Utilisation de TStoredProc ( see page 80) TStoredProc est un ensemble de données de type procédure stockée qui
exécute une procédure stockée définie sur un serveur de base de données.
Utilisation de TTable ( see page 81) TTable est un ensemble de données de type table qui représente toutes les
lignes et colonnes d'une seule table de base de données.
Utilisation de TUpdateSQL pour mettre à jour un ensemble de données ( see Quand l'ensemble de données BDE représente une procédure stockée ou une
page 83) requête non "dynamique", il n'est pas possible d'appliquer les mises à jour
directement depuis l'ensemble de données. De tels ensembles de données
peuvent aussi provoquer un problème quand vous utilisez un ensemble de
données client pour placer les mises à jour en mémoire cache.
Utilisation de dbExpress ( see page 83)
Utilisation de l'explorateur de données pour obtenir des informations de Avant d'avoir une connexion, vous pouvez utiliser l'explorateur de données
connexion ( see page 84) pour assembler les chaînes de connexion.

2.2.1 Accès aux informations de schéma

Ces informations de schéma ou métadonnées indiquent quelles tables et quelles procédures stockées sont accessibles sur le
serveur et donnent des précisions sur ces tables et ces procédures stockées (comme les champs d'une table, les index définis

61
 Configuration d'une connexion TSQL RAD Studio 2.2 Procédures de bases de données

et les paramètres utilisés par une procédure stockée).

Pour accéder aux informations de schéma

1. Pour remplir un ensemble de données unidirectionnel avec des métadonnées du serveur de base de données, appelez la
méthode SetSchemaInfo pour indiquer quelles sont les données que vous souhaitez voir.
2. Définissez le type d'informations de schéma de la méthode SetSchemaInfo.
3. Définissez le nom du paramètre de la table ou de la procédure stockée de la méthode SetSchemaInfo.
4. Pour récupérer les données après l'utilisation de l'ensemble des données pour les métadonnées, effectuez l'une des
opérations suivantes :
• Définissez la propriété CommandText pour spécifier la requête, la table ou la procédure stockée à partir de laquelle vous
souhaitez lire des données.
• Définissez le type d'informations de schéma par stNoSchema et appelez la méthode SetSchemaInfo.
Remarque: Si vous choisissez la deuxième option, l'ensemble de données récupère les données spécifiées par la propriété
CommandText.

Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

2
Débogage d'applications dbExpress ( see page 65)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSQLQuery ( see page 75)

Utilisation de TSimpleDataSet ( see page 78)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.2 Configuration d'une connexion TSQL

La première étape du travail avec un ensemble de données unidirectionnel est de se connecter à un serveur de base de
données. A la conception, une fois qu'un ensemble de données dispose d'une connexion active à un serveur de base de
données, l'inspecteur d'objets peut fournir des listes déroulantes de valeurs pour les autres propriétés. Par exemple, s'il s'agit
d'une procédure stockée, il faut qu'une connexion soit active pour que l'inspecteur d'objets puisse indiquer les procédures
stockées disponibles sur le serveur. La connexion à un serveur de base de données est représentée par un composant
TSQLConnection distinct. Vous utilisez TSQLConnection comme tout autre composant connexion de base de données.

Pour configurer une connexion TSQL

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.

62
2.2 Procédures de bases de données RAD Studio Configuration d'une connexion TSQL

3. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSQLConnection sur la fiche.
4. Identifiez le pilote.
5. Spécifiez les paramètres de connexion.
6. Identifiez une connexion de base de données.
7. Affichez et utilisez l'éditeur de connexion dbExpress.

Pour identifier le pilote

1. Sélectionnez le composant TSQLConnection.
2. Dans l'inspecteur d'objets, définissez la propriété DriverName sur un pilote dbExpress installé.
3. Identifiez les fichiers associés au nom du pilote. Sélectionnez un des éléments suivants :
• Le pilote dbExpress
• La bibliothèque de liaison dynamique
Remarque: La relation entre le pilote dbExpress ou la bibliothèque de liaison dynamique et le nom de la base de données
est stockée dans un fichier appelé dbxdrivers.ini
, qui est mis à jour lorsque vous installez un pilote dbExpress. Le composant connexion SQL recherche le pilote dbExpress et
la bibliothèque de liaison dynamique dans dbxdrivers.ini lorsqu'il reçoit la valeur de DriverName. Lorsque vous
définissez la propriété DriverName, TSQLConnection attribue automatiquement aux propriétés LibraryName et VendorLib
les noms des dll associées. Une fois LibraryName et VendorLib définies, votre application n'est plus dépendante de
dbxdrivers.ini.

Pour spécifier un paramètre de connexion

1. Double-cliquez sur la propriété Params dans l'inspecteur d'objets pour modifier les paramètres en utilisant l'éditeur de liste
de valeurs au moment de la conception.
2
2. Utilisez la propriété Params.Values pour affecter des valeurs à des paramètres individuels au moment de l'exécution.

Pour identifier une connexion de base de données

1. Initialisez la propriété ConnectionName avec un nom de connexion valide. Cela initialise automatiquement les propriétés
DriverName et Params.
2. Modifiez la propriété Params pour modifier l'ensemble de valeurs de paramètres enregistré.
3. Initialisez la propriété LoadParamsOnConnect à True pour développer votre application en utilisant une base de données et
la déployer en utilisant une autre. Cela provoque l'initialisation automatique par TSQLConnection de DriverName et Params
aux valeurs associées à ConnectionName dans dbxconnections.ini lorsque la connexion est ouverte.
4. Appelez la méthode LoadParamsFromIniFile. Cette méthode initialise DriverName et Params aux valeurs associées à
ConnectionName dans dbxconnections.ini (ou dans un autre fichier que vous spécifiez). Vous pouvez opter pour cette
méthode si vous souhaitez remplacer certaines valeurs de paramètres avant d'ouvrir la connexion.

Pour afficher l'éditeur de connexion

1. Double-cliquez sur le composant TSQLConnection. L'éditeur de connexion dbExpress apparaît, avec une liste déroulante
des pilotes, une liste de noms de connexion pour le pilote sélectionné et un tableau des paramètres de connexion pour le
nom de connexion sélectionné.
2. Dans la liste déroulante Nom du pilote, sélectionnez un pilote pour indiquer la connexion à utiliser.
3. Dans la liste Nom de connexion, sélectionnez nom de connexion.
4. Choisissez la configuration voulue.
5. Cliquez sur le bouton Tester la connexion pour vérifier si la configuration est valide.

Pour définir et modifier des connexions en utilisant l'éditeur de connexion

1. Pour modifier les connexions nommées actuellement sélectionnées dans dbxconnections.ini, modifiez les valeurs des

63
 Débogage d'applications dbExpress à RAD Studio 2.2 Procédures de bases de données

paramètres dans la table des paramètres.

2. Cliquez sur OK. Les nouvelles valeurs de paramètres sont enregistrées dans dbxconnections.ini.
3. Cliquez sur le bouton Ajouter une connexion pour définir une nouvelle connexion. La boîte de dialogue Nouvelle
connexion apparaît.
4. Dans la boîte de dialogue Nouvelle connexion, définissez Nom de pilote et Nom de connexion.
5. Cliquez sur OK.
6. Cliquez sur le bouton Supprimer la connexion pour supprimer la connexion nommée actuellement sélectionnée de
dbxconnections.ini.
7. Cliquez sur le bouton Renommer la connexion pour modifier le nom de la connexion nommée sélectionnée.
Voir aussi
Composants dbExpress ( see page 16)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Débogage d'applications dbExpress ( see page 65)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSQLQuery ( see page 75)

2 Utilisation de TSimpleDataSet ( see page 78)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.3 Connexion au serveur d'applications à l'aide de

composants DataSnap
Une application client utilise un ou plusieurs composants connexion appartenant à la catégorie DataSnap de la palette d'outils
pour établir et maintenir une connexion à un serveur d'applications.

Pour se connecter au serveur d'applications à l'aide de composants DataSnap

1. Identifiez le protocole utilisé pour communiquer avec le serveur d'applications.
2. Localisez la machine serveur.
3. Identifiez le serveur d'applications sur la machine serveur.
4. Si vous n'utilisez pas SOAP, identifiez le serveur à l'aide de la propriété ServerName ou ServerGUID.
5. Gérez les connexions serveur.
Voir aussi
Connexion au serveur d'applications ( see page 1547)

Utilisation de TLocalConnection ou de TConnectionBroker ( see page 69)

Utilisation de TSimpleObjectBroker ( see page 79)

64
2.2 Procédures de bases de données RAD Studio Exécution des commandes à l'aide de

2.2.4 Débogage d'applications dbExpress à l'aide de

TSQLMonitor
Lors du débogage de votre application de base de données, vous pouvez contrôler les messages SQL envoyés à la base de
données et reçus de celle-ci par le biais de votre composant connexion, y compris ceux automatiquement générés (par exemple,
par un composant fournisseur ou par le pilote dbExpress).

Pour déboguer des applications dbExpress

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. Pour surveiller les commandes SQL, à partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant
TSQLMonitor sur la fiche.
4. Définissez la propriété SQLConnection du TSQLMonitor sur le composant TSQLConnection.
5. Définissez la propriété Active du TSQLMonitor sur True.

Pour utiliser un callback afin de surveiller les commandes SQL

1. Utilisez la méthode SetTraceEvent du composant TSQLConnection.
2. Définissez le paramètre d'événement TDBXTraceEvent.
Le pilote dbExpress déclenche l'événement chaque fois que le composant connexion SQL transmet une commande au serveur
ou que celui-ci renvoie un message d'erreur.
2
Avertissement: N'appelez pas SetTraceEvent si l'objet TSQLConnection
a un composant associé TSQLMonitor. TSQLMonitor utilise le mécanisme de callback pour fonctionner et
TSQLConnection ne peut prendre en charge qu'un callback à la fois.
Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.5 Exécution des commandes à l'aide de TSQLDataSet

Vous pouvez utiliser un ensemble de données unidirectionnel même si la requête ou la procédure stockée qu'il représente ne
renvoie pas d'enregistrement. Parmi ces commandes, on trouve des instructions utilisant le langage de définition de données
(DDL) ou le langage de manipulation de données (DML), mais pas des instructions SELECT. Le langage utilisé dans les
commandes est spécifique au serveur mais généralement conforme au standard SQL-92 du langage SQL. La commande SQL

65
 Exécution des commandes à l'aide de RAD Studio 2.2 Procédures de bases de données

que vous exécutez doit être acceptable pour le serveur que vous utilisez. Les ensembles de données unidirectionnels n'évaluent
pas la commande SQL et ne l'exécutent pas : ils transmettent la commande au serveur pour exécution.

Pour exécuter des commandes

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSQLDataSet sur la fiche.
4. Spécifiez la commande à exécuter.
5. Exécutez la commande.
6. Créez et modifiez les métadonnées du serveur.

Pour spécifier la commande à exécuter

1. Définissez les propriétés CommandType et CommandText dans l'inspecteur d'objets pour spécifier la commande pour un
TSQLDataSet.
2. Définissez la propriété SQL dans l'inspecteur d'objets pour spécifier l'instruction SQL à transmettre au serveur pour un
TSQLQuery.
3. Définissez la propriété StoredProcName dans l'inspecteur d'objets pour spécifier le nom de la procédure stockée à exécuter
pour un TSQLStoredProc.

Pour exécuter la commande

1. Si l'ensemble de données est une instance d'un TSQLDataSet ou d'un TSQLQuery, appelez la méthode ExecSQL.
2. Si l'ensemble de données est une instance d'un TSQLStoredProc, appelez la méthode ExecProc.
2
Conseil: Si vous exécutez la requête ou la procédure stockée plusieurs fois, il est souhaitable de définir la propriété
Prepared par True.

Pour créer et modifier des métadonnées de serveur

1. Pour créer des tables dans une base de données, utilisez l'instruction CREATE TABLE.
2. Pour créer de nouveaux index pour ces tables, utilisez l'instruction CREATE INDEX.
3. Pour ajouter différents objets de métadonnées, utilisez les instructions CREATE DOMAIN, CREATE VIEW, CREATE
SCHEMA et CREATE PROCEDURE.
4. Pour supprimer l'un des objets de métadonnées ci-dessus, utilisez DROP TABLE, DROP VIEW, DROP DOMAIN, DROP
SCHEMA et DROP PROCEDURE.
5. Pour modifier la structure d'une table, utilisez une instruction ALTER TABLE.
Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Accès aux informations de schéma ( see page 61)

Débogage d'applications dbExpress ( see page 65)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLStoredProc ( see page 76)

66
2.2 Procédures de bases de données RAD Studio Spécification des données à afficher à

Utilisation de TSQLQuery ( see page 75)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.6 Récupération des données à l'aide de TSQLDataSet

Pour récupérer les données
1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSQLDataSet sur la fiche.
4. Pour récupérer les données d'un ensemble de données unidirectionnel, effectuez l'une des opérations suivantes :
• Dans l'inspecteur d'objets, définissez la propriété Active sur la valeur True.
• Appelez la méthode Open lors de l'exécution.
Conseil: Utilisez la propriété GetMetadata pour récupérer, de façon sélective, les métadonnées sur un objet base de
données. Affectez la valeur False à GetMetadata si vous récupérez un ensemble de données à des fins de lecture seule.

5. Définissez sa propriété Prepared sur True pour préparer l'ensemble de données explicitement.
6. Appelez la méthode NextRecordSet pour récupérer plusieurs ensembles ou enregistrements.
Remarque: NextRecordSet renvoie un composant TCustomSQLDataSet récemment créé qui permet d'accéder à l'ensemble
d'enregistrements suivant. Ainsi, la première fois que vous appelez NextRecordSet, elle renvoie un ensemble de données 2
pour le second ensemble d'enregistrements. Appeler NextRecordSet renvoie un troisième ensemble de données, et ainsi de
suite jusqu'à ce qu'il n'y ait plus d'ensemble d'enregistrements. Lorsque qu'il n'y a pas d'ensemble de données
supplémentaire, NextRecordSet ne renvoie rien.
Voir aussi
Composants dbExpress ( see page 16)

Spécification des données à afficher ( see page 68)

Récupération des données

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Débogage d'applications dbExpress ( see page 65)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSQLQuery ( see page 75)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

67
 Spécification des données à afficher à RAD Studio 2.2 Procédures de bases de données

2.2.7 Spécification des données à afficher à l'aide de

TSQLDataSet
Pour spécifier les données à afficher
1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSQLDataSet sur la fiche.
4. Pour TSQLDataSet, spécifiez le type d'ensemble de données unidirectionnel en définissant la propriété CommandType dans
l'inspecteur d'objets.
5. Spécifiez si les informations proviennent des résultats d'une requête, d'une table de base de données ou d'une procédure
stockée.

Pour afficher les résultats d'une requête

1. Initialisez la propriété CommandType à ctQuery pour un TSQLDataSet.
2. Pour TSQLQuery, déposez un composant TSQLQuery sur la fiche depuis la palette d'outils.
3. Affectez à la propriété SQL la requête que vous souhaitez affecter.
4. Sélectionnez TSQLDataSet.
5. Cliquez sur la propriété CommandText. L'éditeur CommandText s'ouvre.
2
6. Dans l'éditeur CommandText, définissez la propriété SQL sur le texte de l'instruction de requête.
Remarque: Lorsque vous spécifiez la requête, elle peut inclure des paramètres, ou variables, dont les valeurs peuvent être
modifiées pendant la conception ou pendant l'exécution. Les paramètres peuvent remplacer les valeurs des données qui
apparaissent dans l'instruction SQL. SQL définit des requêtes comme UPDATE qui exécutent des actions sur le serveur mais
ne renvoient pas un ensemble d'enregistrements.

Pour afficher les enregistrements d'une table

1. Dans l'inspecteur d'objets, initialisez la propriété CommandType à la valeur ctTable. TSQLDataSet génère une requête à
partir des valeurs de deux propriétés : CommandText qui spécifie le nom de la table de base de données que l'objet
TSQLDataSet devrait représenter et SortFieldNames qui énumère les noms des champs à utiliser pour trier les données,
dans l'ordre de leur prépondérance.
2. Déposez un composant TSQLTable sur la fiche.
3. Dans l'inspecteur d'objets, définissez la propriété TableName sur la table souhaitée.
4. Affectez à la propriété IndexName le nom d'un index défini sur le serveur ou affectez à la propriété IndexFieldNames une liste
de noms de champs séparés par des points-virgules pour spécifier l'ordre des champs dans l'ensemble de données.

Pour afficher les résultats d'une procédure stockée

1. Dans l'inspecteur d'objets, initialisez la propriété CommandType à la valeur ctStoredProc.
2. Spécifiez le nom de la procédure stockée comme valeur de la propriété CommandText.
3. Initialisez la propriété StoredProcName au nom de la procédure stockée pour TSQLStoredProc.
Remarque: Une fois que vous avez identifié une procédure stockée, il se peut que votre application ait besoin de fournir les
valeurs des paramètres d'entrée de la procédure stockée ou d'extraire les valeurs des paramètres de sortie à la fin de
l'exécution de la procédure stockée.

68
2.2 Procédures de bases de données RAD Studio Utilisation du BDE

Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Débogage d'applications dbExpress ( see page 65)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSQLQuery ( see page 75)

Utilisation de TSimpleDataSet ( see page 78)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.8 Spécification du fournisseur à l'aide d'un composant

TLocalConnection ou TConnectionBroker
Les ensembles de données client sont des ensembles de données spécialisés qui stockent toutes les données en mémoire. Ils
2
utilisent un fournisseur pour obtenir les données et appliquer les mises à jour lorsqu'ils stockent en mémoire cache des mises à
jour d'un serveur de base de données ou d'un autre ensemble de données, représentent les données dans un document XML et
les stockent dans la partie client d'une application multiniveau.

Pour spécifier le fournisseur

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TConnectionBroker sur la fiche si le
fournisseur se trouve sur un serveur d'applications distant.
4. Dans l'inspecteur d'objets, affectez à la propriété ConnectionBroker de votre ensemble de données client le composant
TConnectionBroker sur la fiche.
5. Dans la catégorie DataSnap de la palette d'outils, faites glisser un composant TLocalConnection sur la fiche si le
fournisseur est dans la même application que l'ensemble de données client.
6. Affectez à la propriété RemoteServer de votre ensemble de données client le composant TLocalConnection sur la fiche.
Voir aussi
Utilisation de DataSnap ( see page 70)

Connexion au serveur d'applications ( see page 64)

Utilisation de TSimpleObjectBroker ( see page 79)

69
 Utilisation de DataSnap RAD Studio 2.2 Procédures de bases de données

2.2.9 Utilisation du BDE

Pour utiliser le BDE
1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments s'ouvre.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TTable sur la fiche. Cela encapsulera toute la
structure des données dans une table de base de données sous-jacente.
4. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TQuery sur la fiche. Cela encapsulera une
instruction SQL et permettra aux applications d'accéder aux enregistrements résultants.
5. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TStoredProc sur la fiche. Cela exécutera une
procédure stockée définie sur un serveur de base de données.
6. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TBatchMove sur la fiche. Cela copiera une
structure de table ou ses données.
7. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TUpdateSQL sur la fiche. Cela fournira une
façon de mettre à jour les ensembles de données sous-jacents.
Voir aussi
Vue globale BDE ( see page 15)

Utilisation de TDatabase ( see page 72)

2 Utilisation de TSession ( see page 78)

Utilisation de TTable ( see page 81)

Utilisation de TQuery ( see page 73)

Utilisation de TStoredProc ( see page 80)

Utilisation de TBatchMove ( see page 71)

Utilisation de TupdateSQL ( see page 83)

2.2.10 Utilisation de DataSnap

Une application client/serveur multiniveau est partitionnée en unités logiques, appelées niveaux, dont les différentes unités
fonctionnent en coordination les unes avec les autres sur des machines séparées. Les applications multiniveaux partagent des
données et communiquent par un réseau local voire même par Internet. Elles offrent de nombreux avantages, comme les
applications clients simples et la logique d'entreprise centralisée.

Les applications multiniveaux utilisent les composants de la catégorie DataSnap de la palette d'outils. DataSnap fournit des
fonctionnalités de bases de données multiniveaux aux applications Delphi en permettant aux applications client de se connecter
aux fournisseurs d'un serveur d'applications.

Pour construire des applications de bases de données multiniveaux à l'aide de DataSnap

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches

70
2.2 Procédures de bases de données RAD Studio Utilisation de TBatchMove

VCL. Le concepteur Windows s'affiche.

3. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TDCOMConnection sur la fiche. Cela
établira une connexion DCOM avec un serveur distant dans une application de base de données multiniveau.
4. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TSocketConnection sur la fiche. Cela
établira une connexion TCP/IP à un serveur distant dans une application de base de données multiniveau.
5. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TSimpleObjectBroker sur la fiche. Cela
localisera un serveur pour un composant connexion à partir d'une liste des serveurs d'applications disponibles.
6. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TWebConnection sur la fiche. Cela
établira une connexion HTTP à un serveur distant dans une application de base de données multiniveau.
7. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TConnectionBroker sur la fiche. Cela
centralisera toutes les connexions au serveur d'applications afin que les applications ne nécessitent pas de réécriture majeure
lors de la modification du protocole de connexion.
8. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TSharedConnection sur la fiche. Cela
provoquera une connexion à un module de données distant enfant lors de la construction du serveur d'applications au moyen
de plusieurs modules de données distants.
9. A partir de la catégorie DataSnap de la palette d'outils, faites glisser un composant TLocalConnection sur la fiche. Cela
fournira un accès aux méthodes IAppServer qui seraient sinon inaccessibles, et facilitera l'évolution ultérieure vers une
application multiniveau. Il agit comme un composant connexion pour les fournisseurs résidant dans la même application.
Voir aussi
Connexion au serveur d'applications ( see page 64)

Déploiement d'applications de bases de données multiniveaux (DataSnap). ( see page 2017)

Utilisation de TLocalConnection ou de TConnectionBroker ( see page 69)

Utilisation de TSimpleObjectBroker ( see page 79) 2

2.2.11 Utilisation de TBatchMove

TBatchMove copie une structure de table et ses données. Il peut être utilisé pour transformer des tables entières d'un format de
base de données dans un autre.

Pour utiliser TBatchMove

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. Créez un composant action groupée.
4. Spécifiez un mode d'action groupée.
5. Etablissez un mappage des types de données.
6. Exécutez une action groupée.
7. Gérez les erreurs relatives aux actions groupées.
Voir aussi
Utilisation de TBatchMove ( see page 1724)

Utilisation de TTable ( see page 81)

Utilisation de TQuery ( see page 73)

71
 Connexion aux bases de données avec RAD Studio 2.2 Procédures de bases de données

Utilisation de TStoredProc ( see page 80)

Utilisation d'objets mise à jour pour mettre à jour un ensemble de données ( see page 1735)

Utilisation de TSession ( see page 78)

2.2.12 Connexion aux bases de données avec TDatabase

TDatabase met en place une connexion persistante à une base de données, en particulier à une base de données distante
nécessitant un nom de connexion utilisateur et un mot de passe. TDatabase est particulièrement utile car il permet de contrôler
le traitement des transactions par le BDE lors d'une connexion à un serveur SQL distant. Utilisez TDatabase quand une
application de base de données basée sur le BDE nécessite les opérations suivantes :

• Connexions persistantes avec la base de données

• Accès personnalisés à un serveur de bases de données
• Contrôle des transactions
• Alias BDE spécifiques à l'application

Pour se connecter aux bases de données avec TDatabase

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. Associez un composant base de données à une session.
2
4. Identifiez la base de données.
5. Ouvrez une connexion avec TDatabase.

Pour associer un composant base de données à une session

1. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TDatabase sur la fiche.
2. Déposez un composant TSession sur la fiche.
3. Dans l'inspecteur d'objets, définissez la propriété SessionName du composant TSession. SessionName a la valeur
"Default", ce qui signifie qu'elle est associée au composant session par défaut qui est référencé par la variable globale
Session.
4. Si vous utilisez plusieurs sessions, ajoutez un composant TSession pour chaque session.
5. Définissez la propriété SessionName du composant TDatabase sur la propriété SessionName du composant TSession pour
associer votre ensemble de données à un composant session.
6. Lisez la propriété Session pour accéder au composant session avec lequel la base de données est associée pendant
l'exécution. Si SessionName est vide ou a pour valeur "Default", la propriété Session référence la même instance de
TSession référencée par la variable globale Session.
Session permet aux applications d'accéder aux propriétés, méthodes et événements d'un composant session parent d'un
composant de base de données sans connaître le nom réel de la session. Si vous utilisez un composant base de données
implicite, la session de ce composant base de données est celle spécifiée par la propriété SessionName de l'ensemble de
données.

Pour identifier la base de données

1. Dans les listes déroulantes des composants ensembles de données, spécifiez le nom de l'alias ou le nom d'un alias BDE
existant pour un composant base de données.
Remarque: Cette action efface toutes les valeurs déjà affectées à DriverName. Quand vous créez un alias BDE local pour

72
2.2 Procédures de bases de données RAD Studio Utilisation de TQuery

un composant base de données, vous pouvez aussi spécifier un nom de pilote à la place d'un alias en utilisant la propriété
DatabaseName. Si vous spécifiez un nom de pilote, toutes les valeurs déjà affectées à AliasName sont effacées. Pour fournir
votre propre nom pour une connexion de base de données, définissez la propriété DatabaseName. Pour spécifier un alias
BDE au moment de la conception, affectez un pilote BDE.

2. Créez un alias BDE local.

3. Double-cliquez sur un composant base de données. L'éditeur de base de données s'ouvre.
4. Dans la zone de saisie Nom de l'éditeur de propriétés, entrez le même nom que celui spécifié par la propriété
DatabaseName.
5. Dans la boîte à options Nom d'alias entrez un nom d'alias BDE existant ou choisissez un alias existant dans la liste
déroulante.
6. Pour créer ou modifier des paramètres de connexion au moment de la conception, effectuez l'une des opérations suivantes :
• Utilisez l'explorateur de base de données ou l'utilitaire d'administration BDE.
• Double-cliquez sur la propriété Params dans l'inspecteur d'objets pour appeler l'éditeur de liste de valeurs.
• Double-cliquez sur un composant base de données dans un module de données ou une fiche pour appeler l'éditeur de base
de données.
Remarque: Toutes ces méthodes éditent la propriété Params du composant base de données. Quand vous appelez l'éditeur
de propriétés de bases de données
pour la première fois, les paramètres de l'alias BDE ne sont pas visibles. Pour afficher les paramètres en cours, cliquez sur
Défaut. Les paramètres en cours s'affichent dans la zone mémo Paramètres de connexion. Vous pouvez éditer les entrées
existantes ou en ajouter de nouvelles. Pour effacer les paramètres existants, cliquez sur Effacer. Les modifications ne
prennent effet que lorsque vous cliquez sur OK.

Pour ouvrir une connexion avec TDatabase 2

1. Dans la propriété Params d'un composant TDatabase, configurez le pilote ODBC de votre application.
2. Pour vous connecter à une base de données à l'aide de TDatabase, définissez la propriété Connected à True ou appelez la
méthode Open.
Remarque: Le fait d'appeler TDatabase.Rollback n'appelle pas TDataSet.Cancel pour les ensembles de données associés à
la base de données.
Voir aussi
Vue globale BDE ( see page 15)

Utilisation de TSession ( see page 78)

Utilisation de TTable ( see page 81)

Utilisation de TQuery ( see page 73)

Utilisation de TStoredProc ( see page 80)

Utilisation de TBatchMove ( see page 71)

Utilisation de TUpdateSQL ( see page 83)

2.2.13 Utilisation de TQuery

TQuery est un ensemble de données de type requête qui encapsule une instruction SQL et permet aux applications d'accéder
aux enregistrements éventuellement obtenus.

73
 Utilisation de TQuery RAD Studio 2.2 Procédures de bases de données

Pour utiliser TQuery

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. Associez l'ensemble de données avec les connexions de bases de données et de session.
4. Créez des requêtes hétérogènes.
5. Obtenez un ensemble de résultats modifiable.
6. Mettez à jour les ensembles de résultats en lecture seule.

Pour associer un ensemble de données aux connexions de bases de données et de sessions

1. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TDatabase sur la fiche.
2. Déposez un composant TSession sur la fiche.
3. Définissez la propriété DatabaseName du composant TDatabase pour associer un ensemble de données orienté BDE à une
base de données. Pour le composant TDatabase, le nom de la base de données est la valeur de la propriété DatabaseName
du composant base de données.
4. Spécifiez un alias BDE comme valeur de DatabaseName si vous désirez utiliser un composant base de données implicite et
si la base de données possède un alias BDE.
Remarque: Un alias BDE représente une base de données et ses informations de configuration. Les informations de
configuration associées avec les alias diffèrent avec le type de la base de données (Oracle, Sybase, InterBase, Paradox,
dBASE, etc.).

2 5. Dans l'inspecteur d'objets, définissez la propriété DatabaseName pour spécifier simplement le répertoire contenant les
tables de la base de données si vous souhaitez utiliser un composant base de données implicite pour une base de données
Paradox ou dBASE.
6. Utilisez la session par défaut pour contrôler toutes les connexions aux bases de données de votre application.
7. Définissez la propriété SessionName du composant TSession pour associer votre ensemble de données à un composant
session créé de manière explicite.
Remarque: Que vous ayez utilisé la session par défaut ou spécifié une session explicite avec la propriété SessionName,
vous pouvez accéder à la session associée à un ensemble de données en lisant la propriété DBSession. Si vous utilisez un
composant session, la propriété SessionName d'un ensemble de données doit concorder avec la propriété SessionName du
composant base de données auquel l'ensemble de données est associé.

Pour créer des requêtes hétérogènes

1. Définissez des alias BDE distincts pour chaque base de données concernée dans la requête, en utilisant l'outil
d'administration BDE ou l'explorateur SQL.
2. Laissez vide la propriété DatabaseName du composant TQuery. Les noms des bases de données utilisées sont spécifiés
dans l'instruction SQL.
3. Affectez à la propriété SQL l'instruction SQL que vous souhaitez exécuter.
4. Faites-y précéder le nom de chaque table par l'alias BDE de la base de données de cette table, encadré par des caractères
deux-points. La référence entière est elle-même encadrée de guillemets.
5. Affectez à la propriété Params tout paramètre de la requête.
6. Ecrivez une méthode Prepare pour préparer la requête avant sa première exécution.
7. Ecrivez une méthode Open ou ExecSQL selon le type de requête que vous exécutez.
8. Utilisez un composant TDatabase au lieu d'utiliser un alias BDE pour spécifier la base de données dans une requête
hétérogène.

74
2.2 Procédures de bases de données RAD Studio Utilisation de TSQLQuery

9. Configurez le TDatabase pour la base de données, affectez à la propriété TDatabase. DatabaseName une valeur unique et
utilisez cette valeur dans l'instruction SQL à la place d'un nom d'alias BDE.

Pour obtenir un ensemble de résultats modifiable

1. Initialisez la valeur True à la propriété RequestLive du composant TQuery.
2. Si la requête contient des champs liés, vous devez considérer l'ensemble de résultats comme étant en lecture seule, et le
mettre à jour.
Si une application demande un ensemble de résultats dynamique mais que la syntaxe de l'instruction SELECT ne le permet pas,
le BDE renvoie un ensemble de résultats en lecture seule pour les requêtes effectuées sur Paradox ou dBASE, ou un code
d'erreur pour les requêtes SQL effectuées sur un serveur distant.

Pour mettre à jour des ensembles de résultats en lecture seule

1. Si toutes les mises à jour sont appliquées à une table de base de données unique, indiquez la table sous-jacente à mettre à
jour dans un gestionnaire d'événement OnGetTableName.
2. Affectez à la propriété UpdateObject de la requête l'objet TUpdateSQL que vous utilisez pour mieux contrôler l'application
des mises à jour.
3. Affectez aux propriétés DeleteSQL, InsertSQL et ModifySQL de l'objet de mise à jour les instructions SQL qui effectuent les
mises à jour adaptées aux données de votre requête.
Si vous utilisez le BDE pour mettre en mémoire cache les mises à jour, vous devez utiliser un objet de mise à jour.
Voir aussi
Vue globale BDE ( see page 15)

Utilisation de TDatabase ( see page 72)

Utilisation de TSession ( see page 78)

2
Utilisation de TTable ( see page 81)

Utilisation de TStoredProc ( see page 80)

Utilisation de TBatchMove ( see page 71)

Utilisation de TUpdateSQL ( see page 83)

2.2.14 Utilisation de TSQLQuery

TSQLQuery représente une requête exécutée en utilisant dbExpress. TSQLQuery peut représenter les résultats d'une
instruction SELECT ou réaliser des actions sur le serveur de bases de données en utilisant des instructions telles que INSERT,
DELETE, UPDATE, ALTER TABLE, etc. Vous pouvez ajouter un composant TSQLQuery à une fiche lors de la conception, ou
en créer un dynamiquement à l'exécution.

Pour utiliser TSQLQuery

1. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSQLQuery sur la fiche.
2. Dans l'inspecteur d'objets, attribuez à sa propriété Name une valeur unique appropriée à votre application.
3. Initialisez la propriété SQLConnection.
4. Cliquez sur le bouton points de suspension à côté de la propriété SQL du composant TSQLQuery. L'éditeur de liste de
chaînes s'ouvre.
5. Dans l'éditeur de liste de chaînes, tapez l'instruction de requête à exécuter.
6. Si les données de la requête doivent être utilisées avec des contrôles de données visuels, ajoutez un composant source de

75
 Utilisation de TSQLStoredProc RAD Studio 2.2 Procédures de bases de données

données à la fiche.
7. Affectez l'ensemble de données de type requête à la propriété DataSet du composant source de données.
8. Pour activer le composant requête, attribuez la valeur True à la propriété Active ou appelez la méthode Open à l'exécution.
Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSimpleDataSet ( see page 78)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.15 Utilisation de TSQLStoredProc

2 TSQLStoredProc représente une procédure stockée exécutée en utilisant dbExpress. TSQLStoredProc peut représenter
l'ensemble de résultats si la procédure stockée renvoie un curseur. Vous pouvez ajouter un composant TSQLStoredProc à une
fiche lors de la conception, ou en créer un dynamiquement à l'exécution.

Pour utiliser TSQLStoredProc

1. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSQLStoredProc sur la fiche.
2. Dans l'inspecteur d'objets, attribuez à sa propriété Name une valeur unique appropriée à votre application.
3. Initialisez la propriété SQLConnection.
4. Définissez la propriété StoredProcName pour spécifier la procédure stockée à exécuter.
5. Si la procédure stockée renvoie un curseur à utiliser avec des contrôles de données visuels, ajoutez un composant source de
données à la fiche.
6. Affectez l'ensemble de données de type procédure stockée à la propriété DataSet du composant source de données.
7. Fournissez les valeurs des éventuels paramètres de la procédure stockée.
8. Pour exécuter la procédure stockée qui renvoie un curseur, utilisez la propriété Active ou appelez la méthode Open.
9. Traitez les éventuels résultats.
Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

76
2.2 Procédures de bases de données RAD Studio Gestion des sessions de bases de

Accès aux informations de schéma ( see page 61)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLQuery ( see page 75)

Utilisation de TSimpleDataSet ( see page 78)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.16 Utilisation de TSQLTable

TSQLTable représente une table de base de données à laquelle on accède en utilisant dbExpress. TSQLTable génère une
requête permettant de récupérer toutes les lignes et colonnes d'une table spécifiée. Vous pouvez ajouter un composant
TSQLTable à une fiche lors de la conception, ou en créer un dynamiquement à l'exécution.

Pour utiliser TSQLTable

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSQLTable sur la fiche.
4. Dans l'inspecteur d'objets, attribuez à sa propriété Name une valeur unique appropriée à votre application.
5. Initialisez la propriété SQLConnection.
6. Définissez la propriété TableName par le nom de la table de la base de données. 2
7. Ajoutez un composant source de données à la fiche.
8. Affectez le nom de l'ensemble de données à la propriété DataSet du composant source de données.
Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSQLQuery ( see page 75)

Utilisation de TSimpleDataSet ( see page 78)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

77
 Utilisation de TSimpleDataSet RAD Studio 2.2 Procédures de bases de données

2.2.17 Gestion des sessions de bases de données avec

TSession
Une session fournit une connexion globale sur un groupe de composants base de données. Un composant TSession par défaut
est créé automatiquement pour chaque application base de données. Vous ne devez utiliser le composant TSession que si
vous créez une application de base de données multithread. Chaque thread de la base de données doit avoir ses propres
composants Session.

Pour gérer des sessions de bases de données

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. Activez une session.
4. Spécifiez le comportement de la connexion de base de données par défaut.
5. Gérez les connexions aux bases de données.
6. Manipulez les tables Paradox et dBASE protégées par mot de passe.
7. Manipulez les alias BDE.
8. Récupérez les informations d'une session.
9. Créez, nommez et gérez des sessions supplémentaires.
2
Voir aussi
Gestion des sessions de bases de données ( see page 1704)

Utilisation de TTable ( see page 81)

Utilisation de TQuery ( see page 73)

Utilisation de TStoredProc ( see page 80)

Utilisation de TDatabase ( see page 72)

Utilisation de TBatchMove ( see page 71)

Utilisation de TUpdateSQL ( see page 83)

2.2.18 Utilisation de TSimpleDataSet

TSimpleDataSet est un type spécial d'ensemble de données client conçu pour les applications à deux niveaux simples. A
l'image d'un ensemble de données unidirectionnel, il peut utiliser un composant connexion SQL pour se connecter à un serveur
de bases de données et spécifier une instruction SQL à exécuter sur ce serveur. Comme les autres ensembles de données
client, il place les données en mémoire tampon afin d'offrir une totale liberté de navigation et d'édition.

Pour utiliser TSQLStoredProc

1. A partir de la catégorie dbExpress de la palette d'outils, faites glisser un composant TSimpleDataSet sur la fiche.
2. Attribuez à sa propriété Name une valeur unique adaptée à votre application.

78
2.2 Procédures de bases de données RAD Studio Utilisation de TSimpleObjectBroker

3. A partir de la section dbExpress de la palette d'outils, faites glisser un composant TSQLConnection sur la fiche.
4. Sélectionnez le composant TSimpleDataSet. Affectez à la propriété Connection le composant TSQLConnection.
5. Pour récupérer des données du serveur, effectuez l'une des actions suivantes :
• Attribuez à CommandType la valeur ctQuery et à CommandText une instruction SQL à exécuter sur le serveur.
• Attribuez à CommandType la valeur ctStoredProc et à CommandText le nom de la procédure stockée à exécuter.
• Attribuez à CommandType la valeur ctTable et à CommandText le nom des tables de base de données dont vous souhaitez
utiliser les enregistrements.
6. Si la procédure stockée renvoie un curseur à utiliser avec des contrôles de données visuels, ajoutez un composant source de
données à la fiche.
7. Affectez à la propriété DataSet du composant source de données l'objet TSimpleDataSet.
8. Pour activer l'ensemble de données, utilisez la propriété Active ou appelez la méthode Open.
9. Si vous avez exécuté une procédure stockée, utilisez la propriété Params pour extraire les paramètres de sortie.
Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Utilisation de TSQLTable ( see page 77) 2

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSQLQuery ( see page 75)

Utilisation d'ensembles de données unidirectionnels ( see page 1879)

2.2.19 Utilisation de TSimpleObjectBroker

Si votre application client peut choisir parmi plusieurs serveurs basés sur COM, vous pouvez utiliser un courtier d'objets pour
localiser un système serveur disponible.

Pour utiliser TSimpleObjectBroker

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. A partir de la catégorie DataSnap de la palette d'outils, choisissez le composant connexion en fonction du type de
connexion souhaité.
4. A partir de la palette d'outils, faites glisser un composant TSimpleObjectBroker sur la fiche.
5. Dans l'inspecteur d'objets, attribuez à la propriété ObjectBroker le composant connexion choisi à l'étape 3 pour utiliser ce
courtier.
Avertissement: N'utilisez pas la propriété ObjectBroker avec des connexions SOAP.

79
 Utilisation de TStoredProc RAD Studio 2.2 Procédures de bases de données

Voir aussi
Utilisation de DataSnap ( see page 70)

Connexion au serveur d'applications ( see page 64)

Utilisation de TLocalConnection ou de TConnectionBroker ( see page 69)

2.2.20 Utilisation de TStoredProc

TStoredProc est un ensemble de données de type procédure stockée qui exécute une procédure stockée définie sur un serveur
de base de données.

Pour utiliser TStoredProc

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. Associez un ensemble de données aux connexions de bases de données et de sessions.
4. Liez les paramètres.

Pour associer un ensemble de données aux connexions de bases de données et de sessions

1. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TDatabase sur la fiche.
2. Pour associer un ensemble de données BDE à une base de données, définissez la propriété DatabaseName. Pour le
2 composant TDatabase, le nom de la base de données est la valeur de la propriété DatabaseName du composant base de
données.
3. Déposez un composant TSession sur la fiche.
4. Pour contrôler toutes les connexions de bases de données dans votre application, utilisez la session par défaut.
5. Pour associer votre ensemble de données à un composant session explicitement créé, dans l'inspecteur d'objets,
définissez la propriété SessionName du composant TSession.
Remarque: Si vous utilisez un composant session, la propriété SessionName d'un ensemble de données doit concorder
avec la propriété SessionName du composant base de données auquel l'ensemble de données est associé.

Pour lier les paramètres

1. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TStoredProc sur la fiche.
2. Attribuez à la propriété ParamBindMode la valeur par défaut pbByName pour spécifier comment les paramètres doivent être
liés aux paramètres sur le serveur.
3. Examinez le code source de la procédure stockée d'un serveur dans l'explorateur SQL si vous souhaitez initialiser
ParamBindMode à pbByNumber.
4. Déterminez l'ordre de tri et le type corrects des paramètres.
5. Spécifiez les types de paramètres corrects dans l'ordre correct.
Remarque: Certains serveurs supportent aussi la liaison des paramètres par valeur ordinale, c'est-à-dire l'ordre dans lequel
ils apparaissent dans la procédure stockée. Dans ce cas, l'ordre dans lequel vous spécifiez les paramètres dans l'éditeur de
collection de paramètres est important. Le premier paramètre spécifié correspond au premier paramètre d'entrée sur le
serveur, et ainsi de suite. Si votre serveur supporte la liaison de paramètres par valeur ordinale, vous pouvez initialiser
ParamBindMode à pbByNumber
.

80
2.2 Procédures de bases de données RAD Studio Utilisation de TTable

Voir aussi
Vue globale BDE ( see page 15)

Utilisation de TTable ( see page 81)

Utilisation de TQuery ( see page 73)

Utilisation de TBatchMove ( see page 71)

Utilisation de TUpdateSQL ( see page 83)

2.2.21 Utilisation de TTable

TTable est un ensemble de données de type table qui représente toutes les lignes et colonnes d'une seule table de base de
données.

Pour utiliser TTable

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application Fiches
VCL. Le concepteur Windows s'affiche.
3. Associez l'ensemble de données aux connexions de bases de données et de sessions.
4. Spécifiez le type de table pour les tables locales et contrôlez l'accès en lecture/écriture aux tables locales.
5. Spécifiez un fichier d'index dBASE.
2
6. Renommez les tables locales.
7. Importez les données d'une autre table.

Pour associer un ensemble de données aux connexions de bases de données et de sessions

1. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TDatabase sur la fiche.
2. Déposez un composant TSession sur la fiche.
3. Pour associer un ensemble de données BDE à une base de données, dans l'inspecteur d'objets, définissez la
propriétéDatabaseName du composant TDatabase. Pour un composant TDatabase, le nom de la base de données est la
valeur de la propriété DatabaseName du composant base de données.
4. Utilisez la session par défaut pour contrôler toutes les connexions aux bases de données de votre application.
5. Définissez la propriété SessionName du composant TSession pour associer votre ensemble de données à un composant
session créé de manière explicite.
Si vous utilisez un composant session, la propriété SessionName d'un ensemble de données doit concorder avec la propriété
SessionName du composant base de données auquel l'ensemble de données est associé.

Pour spécifier le TableType et contrôler l'accès en lecture/écriture

1. A partir de la catégorie BDE de la palette d'outils, faites glisser un composant TTable sur la fiche.
2. Si une application accède à une table Paradox, dBASE, FoxPro ou ASCII délimité par des virgules, dans l'inspecteur
d'objets, définissez la propriété TableType. BDE utilise la propriété TableType pour déterminer le type de la table.
3. Affectez la valeur ttDefault à TableType si vos tables locales Paradox, dBASE et texte ASCII utilisent des extensions de
fichiers telles que .DB, .DBF et .TXT.
4. Pour les autres extensions, initialisez respectivement la propriété TableType à ttParadox pour Paradox, à ttDBase pour
dBASE, à ttFoxPro pour FoxPro et à ttASCII pour du texte ASCII délimité par des virgules.

81
 Utilisation de TUpdateSQL pour mettre à RAD Studio 2.2 Procédures de bases de données

5. Initialisez la propriété Exclusive du composant table à la valeur True avant d'ouvrir la table pour obtenir l'accès exclusif en
lecture/écriture.
Remarque: Si la table est déjà en cours d'utilisation lorsque vous essayez de l'ouvrir, la requête d'accès exclusif ne peut être
honorée. Vous pouvez essayer d'appliquer Exclusive aux tables SQL, mais certains serveurs ne supportent pas le
verrouillage exclusif au niveau des tables. D'autres peuvent admettre le verrouillage exclusif, mais permettre tout de même à
d'autres applications de lire des données dans la table.

Pour spécifier un fichier d'index dBASE

1. Affectez à la propriété IndexFiles le nom d'un fichier d'index autonome ou listez les fichiers d'extension .NDX.
2. Spécifiez ensuite un index dans la propriété IndexName pour qu'il trie effectivement l'ensemble de données.
3. Au moment de la conception, cliquez sur le bouton Points de suspension dans la propriété IndexFiles. L'éditeur de fichiers
d'index s'ouvre.
4. Pour ajouter un fichier index autonome ou un fichier .NDX, cliquez sur le bouton Ajouter dans la boîte de dialogue Fichiers
index et sélectionnez le fichier dans la boîte de dialogue d'ouverture.
Remarque: Pour chaque fichier d'index autonome ou fichier d'index .NDX., répétez une fois les étapes 3 et 4.

5. Après avoir ajouté tous les index voulus, cliquez sur le bouton OK de l'éditeur de fichiers d'index.
Remarque: Pour effectuer les étapes 3 à 5 lors de l'exécution, accédez à la propriété IndexFiles en utilisant les propriétés et
méthodes des listes de chaînes.

Pour renommer les tables locales

1. Pour renommer une table Paradox ou dBASE au moment de la conception, cliquez avec le bouton droit sur le composant
2 table. Un menu contextuel déroulant apparaît.
2. Dans le menu contextuel, sélectionnez Renommer la table.
3. Pour renommer une table Paradox ou dBASE à l'exécution, appelez la méthode RenameTable de la table.

Pour importer des données d'une autre table

1. Utilisez la méthode BatchMove d'un composant table pour importer des données, copier, mettre à jour, ajouter à cette table
des enregistrements d'une autre table ou supprimer des enregistrements d'une table.
2. Spécifiez le nom de la table depuis laquelle importer les données, ainsi que le mode qui détermine quelle opération
d'importation effectuer.
Voir aussi
Vue globale BDE ( see page 15)

Utilisation de TDatabase ( see page 72)

Utilisation de TSession ( see page 78)

Utilisation de TQuery ( see page 73)

Utilisation de TStoredProc ( see page 80)

Utilisation de TBatchMove ( see page 71)

Utilisation de TUpdateSQL ( see page 83)

82
2.2 Procédures de bases de données RAD Studio Utilisation de dbExpress

2.2.22 Utilisation de TUpdateSQL pour mettre à jour un

ensemble de données
Quand l'ensemble de données BDE représente une procédure stockée ou une requête non "dynamique", il n'est pas possible
d'appliquer les mises à jour directement depuis l'ensemble de données. De tels ensembles de données peuvent aussi provoquer
un problème quand vous utilisez un ensemble de données client pour placer les mises à jour en mémoire cache.

Pour mettre à jour un ensemble de données à l'aide d'un objet mise à jour
1. A partir de la palette d'outils, ajoutez un composant TUpdateSQL à la même fiche de données que celui de l'ensemble de
données BDE.
2. Dans l'inspecteur d'objets, affectez à la propriété UpdateObject du composant ensemble de données BDE le composant
TUpdateSQL dans la fiche.
3. Définissez les propriétés ModifySQL, InsertSQL et DeleteSQL de l'objet de mise à jour pour spécifier les instructions SQL
nécessaires à l'exécution des mises à jour.
4. Fermez l'ensemble de données.
5. Affectez à la propriété CachedUpdates du composant ensemble de données la valeur True ou liez l'ensemble de données à
l'ensemble de données client à l'aide d'un fournisseur d'ensemble de données.
6. Rouvrez l'ensemble de données.
7. Créez les instructions SQL pour les composants de mise à jour.
8. Utilisez plusieurs objets mise à jour.
2
9. Exécutez les instructions SQL.
Voir aussi
Utilisation d'objets mise à jour pour mettre à jour un ensemble de données ( see page 1735)

Utilisation de TTable ( see page 81)

Utilisation de TQuery ( see page 73)

Utilisation de TStoredProc ( see page 80)

Utilisation de TbatchMove ( see page 71)

Utilisation de TSession ( see page 78)

2.2.23 Utilisation de dbExpress

Pour construire une application de base de données à l'aide de dbExpress
1. Connectez-vous au serveur de base de données puis configurez une connexion TSQL.
2. Spécifiez les données à afficher.
3. Récupérez les données.
4. Exécutez les commandes.
5. Accédez aux informations de schéma.
6. Déboguez l'application dbExpress à l'aide de TSQLMonitor.

83
 Utilisation de l'explorateur de données pour RAD Studio 2.2 Procédures de bases de données

7. Utilisez TSQLTable pour représenter une table sur un serveur de bases de données accédé via TSQLConnection.
8. Utilisez TSQLQuery pour exécuter une commande SQL sur un serveur de bases de données accédé via TSQLConnection.
9. Utilisez TSQLStoredProc pour exécuter une procédure stockée sur un serveur de bases de données accédé via
TSQLConnection.
Voir aussi
Composants dbExpress ( see page 16)

Configuration de TSQLConnection ( see page 62)

Spécification des données à afficher ( see page 68)

Récupération des données ( see page 67)

Exécution des commandes ( see page 65)

Accès aux informations de schéma ( see page 61)

Débogage d'applications dbExpress ( see page 65)

Utilisation de TSQLTable ( see page 77)

Utilisation de TSQLStoredProc ( see page 76)

Utilisation de TSQLQuery ( see page 75)

Utilisation de TSimpleDataSet ( see page 78)

Utilisation des ensembles de données dbExpress ( see page 1879)

2
2.2.24 Utilisation de l'explorateur de données pour obtenir
des informations de connexion
Avant d'avoir une connexion, vous pouvez utiliser l'explorateur de données pour assembler les chaînes de connexion.

Pour parcourir les fournisseurs de bases de données

1. Choisissez Voir Explorateur de données ou cliquez sur l'onglet Explorateur de données dans le Gestionnaire de
projets.
2. Développez un noeud fournisseur sous dbExpress ou Ado.Net pour exposer la liste des fournisseurs de bases de données
disponibles.
3. Développez le noeud fournisseur de second niveau pour visualiser la liste des connexions potentielles.

Pour obtenir les informations de connexion

1. Dans la liste des fournisseurs de l'explorateur de données, cliquez avec le bouton droit sur un fournisseur de second
niveau.
2. Dans le menu contextuel, cliquez sur Modifier la connexion. Le dialogue Ajouter une connexion s'affiche.
3. Dans le dialogue Ajouter une connexion, cliquez sur Avancées. Le dialogue Propriétés avancées s'affiche, avec une liste
déroulante de propriétés de connexion. La colonne de gauche contient les clés des chaînes de connexion ; la colonne de
droite contient leurs valeurs.

Pour formater une chaîne de connexion

1. Dans le dialogue Propriétés avancées, entrez dans la colonne de droite les valeurs des propriétés de connexion nommées
dans la colonne de gauche. Le champ texte situé en bas du dialogue Propriétés avancées contient le texte de la chaîne de

84
2.2 Procédures de bases de données RAD Studio Utilisation de l'explorateur de données pour

connexion résultante.
2. Déplacez le curseur sur le texte de la chaîne de connexion pour sélectionner ce texte. Copiez le texte. Vous pouvez alors
coller cette chaîne de connexion là où vous le souhaitez.
Voir aussi
Exploration d'une base de données dans l'explorateur de données

Ajout d'une nouvelle connexion

Modification des connexions

85
 Utilisation des experts COM RAD Studio 2.3 Procédures d'applications

2.3 Procédures d'applications interopérables

Delphi fournit des experts et des classes qui facilitent l'implémentation d'applications basées sur COM (Component Object
Model) de Microsoft. Les objets COM les plus simples sont des serveurs qui exposent des propriétés et des méthodes (et
éventuellement des événements) via une interface par défaut que leurs clients peuvent appeler. L'expert d'objet COM construit
un objet COM léger dont l'interface par défaut descend de IUnknown ou qui implémente une interface déjà recensée dans votre
système. Cet expert offre la plus grande flexibilité dans les types d'objets COM qu'il est possible de créer.

Rubriques
Nom Description
Utilisation des experts COM ( see page 86) RAD Studio dispose d'experts pour vous aider à créer des projets COM et des
objets COM. Ces experts sont disponibles pour les projets Delphi et C++. Les
experts COM proposés sont les suivants :

• Bibliothèque ActiveX
• Objet COM
• Bibliothèque de types
• ActiveForm
• Objet Active Server
• Objet Automation
• Objet événement COM+
2 • Objet Abonnement COM+
• Page propriétés

2.3.1 Utilisation des experts COM

RAD Studio dispose d'experts pour vous aider à créer des projets COM et des objets COM. Ces experts sont disponibles pour
les projets Delphi et C++. Les experts COM proposés sont les suivants :

• Bibliothèque ActiveX
• Objet COM
• Bibliothèque de types
• ActiveForm
• Objet Active Server
• Objet Automation
• Objet événement COM+
• Objet Abonnement COM+
• Page propriétés

Pour utiliser un expert COM

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments s'affiche.
2. Dans l'arborescence Catégories d'éléments, cliquez sur le dossier ActiveX. Les experts disponibles sont affichés dans le

86
2.3 Procédures d'applications RAD Studio Utilisation des experts COM

volet droit da la boîte de dialogue Nouveaux éléments. Ces experts COM sont disponibles pour les projets Delphi et C++.
3. Double-cliquez sur l'expert que vous souhaitez utiliser.
Remarque: Si votre application implémente plusieurs objets COM, vous devez utiliser la même méthode d'instanciation pour
tous.
Voir aussi
Présentation des technologies COM ( see page 1404)

87
 Ajout de Rave Reports à RAD Studio RAD Studio 2.4 Procédures de génération d'états

2.4 Procédures de génération d'états

Cette rubrique propose des informations relatives à l'utilisation de solutions de génération d'états.

Rubriques
Nom Description
Ajout de Rave Reports à RAD Studio ( see page 88) Rave Reports offre un ensemble d'outils puissant pour créer des états et les
intégrer à vos applications. Les outils Rave Reports sont installés dans le
sous-répertoire \RaveReports de votre répertoire d'installation. Pour y accéder
plus facilement, ajoutez l'exécutable de la commande au menu Outils.

2.4.1 Ajout de Rave Reports à RAD Studio

Rave Reports offre un ensemble d'outils puissant pour créer des états et les intégrer à vos applications. Les outils Rave Reports
sont installés dans le sous-répertoire \RaveReports de votre répertoire d'installation. Pour y accéder plus facilement, ajoutez
l'exécutable de la commande au menu Outils.

Pour ajouter une commande Rave Reports au menu Outils

1. Choisissez Outils Configurer les outils. Cette opération affiche la boîte de dialogue Options des outils.
2. Cliquez sur Ajouter. Cette opération affiche la boîte de dialogue Propriétés des outils.
2
3. Tapez Rave Reports dans la zone de saisie Titre.
4. Cliquez sur le bouton Parcourir.
5. Naviguez vers le sous-répertoire \RaveReports de votre répertoire d'installation de RAD Studio.
6. Sélectionnez l'icône Rave.exe.
7. Cliquez sur OK. Cette action ajoute le chemin d'accès au programme et le répertoire de travail à la boîte de dialogue
Propriétés des outils.
8. Cliquez sur OK.
9. Cliquez sur Fermer. Cette action ajoute au menu Outils la commande qui lancera une session Rave Reports. Reportez-vous
à l'aide en ligne de Rave Reports pour de plus amples informations sur la construction et l'intégration d'objets état.
Voir aussi
Présentation de Rave Reports ( see page 45)

88
2.5 Procédures VCL RAD Studio

2.5 Procédures VCL

Cette section propose des informations relatives au développement d'applications VCL pour Win32.

Rubriques
Nom Description
Construction d'une application console "Hello World" Windows ( see page 96) Cette application console "Hello World" Windows illustre les étapes essentielles
de la création d'une application Windows dans Delphi ou C++. L'application
utilise Windows, une fenêtre console et un événement, et affiche une boîte de
dialogue en réponse à une action de l'utilisateur.
Développement d'une application Windows ( see page 97) La procédure suivante illustre les étapes essentielles de la construction d'une
application Windows.
Construction des menus d'applications ( see page 97) Les menus constituent pour les utilisateurs un moyen commode d'exécuter des
commandes regroupées logiquement. Vous pouvez ajouter ou supprimer des
éléments de menu ou les déplacer pour réorganiser les éléments lors de la
conception. Outre les composants TMainMenu et TPopupMenu, la palette
d'outils contient aussi TActionMainMenuBar, TActionManager et
TActionToolBar.
Construction d'une application Fiches VCL avec des composants d'aide à la La création d'une fiche avec des tableaux et des graphes de données
décision ( see page 99) multidimensionnelles se compose des étapes majeures suivantes :

1. Création d'une fiche VCL.

2. Ajout d'une requête de décision et d'un ensemble de
données.
3. Ajout d'un cube de décision.
4. Ajout d'une source de décision. 2
5. Ajout éventuel d'un pivot de décision.
6. Ajout d'un ou plusieurs graphes de décision ou d'une ou
plusieurs grilles de décision.
7. Initialisation de la propriété Active de la requête de
décision (ou d'un autre composant ensemble de données)
à True.
Construction d'applications Fiches VCL avec graphiques ( see page 101) Chacune des procédures ci-dessous permet de construire une application Fiche
VCL qui utilise des graphiques. Construisez un ou plusieurs exemples puis
ajoutez d'autres fonctionnalités graphiques à ces applications Fiches VCL de
base. *

1. Dessin de lignes droites.

2. Dessin de rectangles et d'ellipses.
3. Dessin d'un polygone.
4. Affichage d'une image bitmap.
5. Ajout d'un bitmap dans une boîte à options.
Construction d'une application MDI Fiches VCL à l'aide d'un expert ( see page L'expert Application MDI Fiches VCL crée automatiquement un projet qui inclut
101) les fichiers de base pour une application MDI. En plus du fichier source principal,
l'expert crée des fichiers d'unités pour des fenêtres enfants et de boîte de
dialogue A propos, avec les fichiers de fiches et les ressources.
Construction d'une application MDI Fiches VCL sans utiliser d'expert ( see
page 102)
Construction d'une application SDI Fiches VCL ( see page 104)
Création d'un nouveau composant VCL ( see page 105) Vous pouvez utiliser l'expert Nouveau composant VCL pour créer un nouveau
composant VCL pour votre application. Il détecte la personnalité du produit que
vous utilisez et crée le type de composant approprié.

89
 RAD Studio 2.5 Procédures VCL

Conception d'une application Fiches VCL de base de données ADO ( see page La procédure suivante indique comment construire une application de base de
106) données ADO.
La construction d'une application VCL ADO comprend les étapes principales
suivantes :

1. Définition de la connexion à la base de données.

2. Définition de l'ensemble de données.
3. Installation du fournisseur de données, de l'ensemble de
données client et de la source de données.
4. Connexion d'une grille de données aux composants
connexion.
5. Exécution de l'application.
Construction d'une application Fiches VCL ( see page 108) La procédure suivante illustre les étapes essentielles de la construction d'une
application Fiches VCL avec RAD Studio.
Création d'actions dans une application Fiches VCL ( see page 108) Dans RAD Studio, la procédure suivante illustre comment créer des actions avec
l'outil ActionList. Elle configure une application simple et explique comment créer
un élément de menu fichier avec une action d'ouverture de fichier.
La construction d'une application VCL avec ActionList comprend les étapes
principales suivantes :

1. Créez une fenêtre principale et ajoutez des outils pour

créer un menu principal et une action d'ouverture de
fichier.
2. Ajoutez la catégorie Fichier au menu principal.
3. Ajoutez l'action d'ouverture de fichier à la catégorie
Fichier.
4. Construction et exécution de l'application.
2 Construction d'une application Fiches VCL "Hello World" ( see page 109) Cette procédure montre comment construire une simple application Fiches VCL
"Hello world" avec Delphi ou C++. Malgré sa simplicité, l'application Fiches VCL
"Hello world" illustre les étapes essentielles de la création d'une application
Fiches VCL. L'application utilise une fiche VCL, un contrôle et un événement, et
affiche une boîte de dialogue en réponse à une action de l'utilisateur.
La création de l'application "Hello world" comprend les étapes suivantes :

1. Création d'une fiche VCL avec un contrôle bouton.

2. Ecriture du code pour afficher "Hello Word" quand
l'utilisateur clique sur le bouton.
3. Exécution de l'application.
Utilisation de ActionManager pour créer des actions dans une application Fiches Dans RAD Studio, la procédure suivante illustre comment créer des actions avec
VCL ( see page 110) ActionManager. Elle configure une interface utilisateur simple avec une zone de
texte, adaptée à une application d'édition de texte, et explique comment créer un
élément de menu fichier avec une action d'ouverture de fichier.
La construction d'une application VCL avec ActionManager comprend les étapes
principales suivantes :

1. Création d'une fenêtre principale.

2. Ajout d'une action d'ouverture de fichier à ActionManager.
3. Création du menu principal.
4. Ajout de l'action au menu.
5. Construction et exécution de l'application.

90
2.5 Procédures VCL RAD Studio

Conception d'une application Fiches VCL de base de données dbExpress ( La procédure suivante indique comment construire une application de base de
see page 111) données dbExpress.
La construction d'une application Fiches VCL dbExpress comprend les étapes
principales suivantes :

1. Définition de la connexion à la base de données.

2. Installation de l'ensemble de données unidirectionnel.
3. Installation du fournisseur de données, de l'ensemble de
données client et de la source de données.
4. Connexion d'une grille de données aux composants
connexion.
5. Exécution de l'application.
Construction d'une application avec des composants XML ( see page 113) Cet exemple crée une application Fiches VCL qui utilise un composant
XMLDocument pour afficher le contenu d'un fichier XML.
Copie de données d'un flux vers un autre ( see page 115) La création de cette application VCL comprend les étapes suivantes :

1. Création d'un répertoire projet contenant un fichier texte à

copier.
2. Création d'une fiche VCL avec un contrôle bouton.
3. Ecriture du code pour lire la chaîne et l'écrire dans un
fichier.
4. Exécution de l'application.
Copie de la totalité d'une liste de chaînes ( see page 116) La copie d'une liste de chaînes peut avoir l'effet d'ajouter un élément ou
d'écraser une liste de chaînes existante. Cette application VCL ajoute un élément
à une liste de chaînes. Avec une simple modification, elle peut écraser une liste
de chaînes. La création de cette application VCL comprend les étapes suivantes :

1. Création d'une fiche VCL avec des contrôles TButtons,

TComboBox et TMemo.
2
2. Ecriture du code de création d'une liste de chaînes dans
le gestionnaire OnClick de Button1.
3. Ecriture du code de copie de la liste de chaînes dans le
gestionnaire OnClick de Button2.
4. Exécution de l'application.
Création de chaînes ( see page 118) La création de cette application VCL comprend les étapes suivantes :

1. Créer une fiche VCL avec des contrôles TButton et

TComboBox.
2. Ecrire le code de création des chaînes dans le
gestionnaire OnClick de TButton.
3. Exécuter l'application.
Création d'une instance de fiche VCL en utilisant une variable locale ( see Un moyen fiable de créer une instance unique d'une fiche VCL modale consiste
page 119) à utiliser une variable locale d'un gestionnaire d'événement comme référence à
une nouvelle instance. Si vous utilisez une variable locale, peu importe que la
fiche soit créée automatiquement ou non. Le code du gestionnaire d'événement
ne fait pas référence à la variable fiche globale. En utilisant RAD Studio, la
procédure suivante crée une instance de fiche modale dynamiquement. Elle
retire (facultativement) l'appel de la deuxième fiche au démarrage.
La construction de cette application VCL comprend les étapes suivantes :

1. Créer le répertoire projet.

2. Créer deux fiches pour le... suite ( see page 119)

91
 RAD Studio 2.5 Procédures VCL

Suppression de chaînes ( see page 121) La création de cette application VCL comprend les étapes suivantes :

1. Créer une fiche VCL avec des contrôles de boutons et de

boîtes liste.
2. Ecrire du code afin d'ajouter des chaînes à une liste.
3. Ecrire du code pour supprimer une chaîne de la liste.
4. Exécuter l'application.
Affichage d'une fiche VCL créée automatiquement ( see page 122) Avec RAD Studio, la procédure suivante crée au moment de la conception une
fiche modale qui est affichée ultérieurement au moment de l'exécution du
programme.
La construction de cette application VCL comprend les étapes suivantes :

1. Créer le répertoire projet.

2. Créer deux fiches pour le projet.
3. Lier les fiches.
4. Créer un contrôle sur la fiche principale pour afficher la
fiche modale, puis écrire le gestionnaire d'événement.
5. Construire et exécuter l'application.
Affichage d'une image bitmap dans une application Fiches VCL ( see page 124) Cette procédure charge une image bitmap à partir d'un fichier et l'affiche sur une
fiche VCL.

1. Créer une fiche VCL avec un contrôle bouton.

2. Fournir une image bitmap.
3. Coder le gestionnaire d'événement onClick du bouton
pour charger et afficher une image bitmap.

2 4. Construire et exécuter l'application.

Affichage d'une image bitmap plein écran dans une application Fiches VCL ( Cette procédure charge une image bitmap à partir d'un fichier et l'affiche dans
see page 125) son intégralité sur une fiche VCL. Elle utilise les propriétés Height et Width de
l'objet Bitmap pour afficher une vue complète de l'image.

1. Créer une fiche VCL avec un contrôle bouton.

2. Fournir une image bitmap.
3. Coder le gestionnaire d'événement onClick du bouton
pour charger et afficher une image bitmap.
4. Construire et exécuter l'application.
Dessin d'un polygone dans une application Fiches VCL ( see page 126) Cette procédure dessine un polygone dans une fiche VCL.

1. Créer une fiche VCL.

2. Coder le gestionnaire d'événement OnPaint de la fiche
pour dessiner un polygone.
3. Construire et exécuter l'application.
Dessin de rectangles et d'ellipses dans une application Fiches VCL ( see page Cette procédure dessine un rectangle et une ellipse dans une fiche VCL.
127)
1. Créer une fiche VCL.
2. Coder le gestionnaire d'événement OnPaint de la fiche
pour dessiner un rectangle et une ellipse.
3. Construire et exécuter l'application.

92
2.5 Procédures VCL RAD Studio

Dessin d'un rectangle arrondi dans une application Fiches VCL ( see page 128) Cette procédure dessine un rectangle arrondi dans une fiche VCL.

1. Créer une fiche VCL et coder le gestionnaire d'événement

OnPaint de la fiche.
2. Construire et exécuter l'application.
Dessin de lignes droites dans une application Fiches VCL ( see page 128) Cette procédure dessine deux diagonales droites sur une image dans une fiche
VCL.

1. Créer une fiche VCL.

2. Coder le gestionnaire d'événement OnPaint de la fiche
pour dessiner les lignes droites.
3. Construire et exécuter l'application.
Création dynamique d'une fiche VCL modale ( see page 129) Toutes les fiches de votre application n'ont pas besoin d'être en mémoire
simultanément. Pour réduire la quantité de mémoire requise au moment du
chargement, votre application peut créer des fiches uniquement lorsqu'elles
doivent être disponibles pour être utilisées. Une boîte de dialogue, par exemple,
n'a besoin d'être en mémoire que pendant le temps où l'utilisateur interagit avec
elle. En utilisant RAD Studio, la procédure suivante crée une instance de fiche
modale dynamiquement. La principale différence entre la création dynamique
d'une fiche et l'affichage d'une fiche VCL créée automatiquement réside dans le
fait que vous supprimez l'appel de la deuxième fiche... suite ( see page 129)
Création dynamique d'une fiche VCL non modale ( see page 131) Une fiche non modale est une fenêtre qui s'affiche jusqu'à ce qu'elle soit
masquée par une autre fenêtre ou jusqu'à sa fermeture ou sa réduction par
l'utilisateur. Avec RAD Studio, la procédure suivante crée une fiche non modale
dynamiquement.
La construction de cette application VCL comprend les étapes suivantes :

1. Créer le répertoire projet.

2. Créer deux fiches pour le projet.
3. Retirer l'appel de la deuxième fiche au démarrage.
2
4. Lier les fiches.
5. Créer un contrôle sur la fiche principale pour créer et
afficher la fiche modale, puis écrire le gestionnaire
d'événement.
6. Construire et exécuter l'application.
Parcours des chaînes d'une liste ( see page 132) Cette application VCL crée d'abord une liste de chaînes. Elle parcourt ensuite les
chaînes, en transformant tous les caractères de chaînes en majuscule. Elle est
constituée des étapes suivantes :

1. Créer une fiche VCL avec des boutons et des contrôles

TListBox.
2. Ecrire du code pour créer une liste de chaînes et ajouter
des chaînes à cette liste.
3. Ecrire du code pour parcourir la liste de chaînes afin de
traiter les caractères des chaînes.
4. Exécuter l'application.
Construction d'une application multithread ( see page 134) Voici les étapes essentielles de construction d'une application Fiches VCL
multithread avec un objet thread en utilisant RAD Studio.
Ecriture du code de nettoyage ( see page 134)
Eviter les accès de threads simultanés dans la même mémoire ( see page 134) Utilisez ces techniques de base pour empêcher les autres threads d'accéder à la
même mémoire que votre thread :

1. Verrouiller les objets.

2. Utiliser les sections critiques.
3. Utiliser le synchronisateur à écriture exclusive et lecture
multiple.

93
 RAD Studio 2.5 Procédures VCL

Définition de l'objet thread ( see page 136)

Gestion des exceptions ( see page 139)
Initialisation d'un thread ( see page 139)
Utilisation du thread VCL principal ( see page 140) L'utilisation du thread VCL principal comprend les étapes suivantes :

1. Créer une routine distincte pour gérer les messages

Windows reçus par les composants de votre application.
2. Appeler régulièrement CheckSynchronize.
3. Déclarer, si nécessaire, des variables locales aux threads
pour une utilisation exclusive par votre thread.
Attente des threads ( see page 142) Voici les procédures qui peuvent être utilisées pour attendre les threads.

• Attendre la fin d'exécution d'un thread

• Attendre l'achèvement d'une tâche
• Vérifier si un autre thread attend la fin de votre thread
Ecriture de la fonction Thread ( see page 144) La méthode Execute constitue la fonction thread. Vous pouvez la concevoir
comme un programme qui est exécuté par l'application, à cette différence près
qu'il partage le même espace de processus. L'écriture d'une fonction thread est
plus délicate que celle d'un programme distinct car il faut prendre garde à ne pas
écraser la mémoire utilisée par d'autres processus de l'application. D'un autre
côté, comme le thread partage le même espace de processus que les autres
threads, il est possible d'utiliser la mémoire partagée pour faire communiquer les
threads.
Insertion d'une image bitmap dans un contrôle d'une application Fiches VCL ( Cette procédure ajoute une image bitmap à une boîte à options d'une application
see page 144) Fiches VCL.

1. Créer une fiche VCL.

2. Ajouter des composants à la fiche.
2 3. Définir des propriétés des composants dans l'inspecteur
d'objets.
4. Ecrire des gestionnaires d'événements pour l'action de
dessin des composants.
5. Construire et exécuter l'application.
Lecture d'une chaîne et écriture de cette chaîne dans un fichier ( see page 145) La création de cette application VCL comprend les étapes suivantes :

1. Création d'une fiche VCL avec un contrôle bouton.

2. Ecriture du code pour lire la chaîne et l'écrire dans un
fichier.
3. Exécuter l'application.
Renommage de fichiers ( see page 146) La création de cette application VCL comprend les étapes suivantes :

1. Créer un répertoire projet contenant un fichier à

renommer.
2. Créer une fiche VCL avec des contrôles de boutons et de
libellés.
3. Ecrire du code pour renommer le fichier.
4. Exécuter l'application.
Ajout et tri de chaînes ( see page 147) La création de cette application VCL comprend les étapes suivantes :

1. Créer une fiche VCL avec des contrôles Button, Label et

TListBox.
2. Ecrire du code pour ajouter et trier des chaînes.
3. Exécuter l'application.

94
2.5 Procédures VCL RAD Studio Construction d'une application console

Création d'un bouton ActiveX Fiches VCL ( see page 148) Comme un contrôle Delphi, un contrôle ActiveX génère du code de programme
lorsque vous placez le composant sur une fiche ou un autre conteneur logique
dans l'EDI. La principale différence entre un contrôle ActiveX et un contrôle
Delphi réside dans le fait qu'un contrôle ActiveX est indépendant du langage.
Vous pouvez créer des contrôles ActiveX pour le déploiement vers plusieurs
environnements de programmation sous Windows, pas seulement Delphi ou
C++Builder.
Cette procédure utilise l'expert ActiveX Fiches VCL pour créer un contrôle
ActiveX. Pour tester le contrôle, vous pouvez l'installer sur votre machine comme
un composant VCL dans l'EDI. Pour installer... suite ( see page 148)
Création d'une fiche active VCL ActiveX ( see page 150) Comme un contrôle Delphi, un contrôle ActiveX génère du code de programme
lorsque vous placez le composant sur une fiche ou un autre conteneur logique
dans l'EDI. La principale différence entre un contrôle ActiveX et un contrôle
Delphi réside dans le fait qu'un contrôle ActiveX est indépendant du langage.
Vous pouvez créer des contrôles ActiveX pour le déploiement vers plusieurs
environnements de programmation sous Windows, pas seulement Delphi ou
C++Builder, par exemple.
Cette procédure utilise l'expert de fiche active ActiveX Fiches VCL pour créer
une fiche active contenant deux composants. Pour tester le contrôle, vous
pouvez le déployer sur le... suite ( see page 150)
Construction d'une application de navigateur Web Fiches VCL ( see page 151) La création de l'application de navigateur Web comprend les étapes suivantes :

1. Créer une fiche VCL avec un contrôle bouton.

2. Ajouter un composant TWebBrowser à la fiche.
3. Ajouter des contrôles pour entrer une URL et lancer le
navigateur.
4. Ecrire du code pour lancer le navigateur lorsque
l'utilisateur clique sur un bouton.
5. Exécuter l'application.
Création d'une application qui utilise les contrôles ruban ( see page 152) Cette procédure décrit la création d'une application qui utilise les contrôles ruban.
La fonctionnalité ruban est dérivée du composant TRibbon. Lorsque le ruban
utilise d'autres composants, aucun composant fondamental n'est recensé sur la
palette d'outils.
2
Composants :

1. TRibbon : Composant visuel principal qui fournit le plus

de fonctionnalités.
2. TRibbonApplicationMenuBar : Composant qui fournit la
fonctionnalité du menu d'application.
3. TRibbonQuickAccessToolbar : Composant qui fournit la
fonctionnalité de la barre d'outils d'accès rapide.
4. TRibbonPage : Composant qui représente la page du
ruban actuellement visible
5. TRibbonGroup : Composant dans lequel sont affichées
toutes les commandes de pages. Les commandes doivent
être placées dans un groupe.
Ajout de commandes au ruban ( see page 153) Cette rubrique suit en séquence la création d'une application ruban à l'aide de
l'expert Application Ruban ou des étapes manuelles décrites dans Création d'une
application qui utilise les contrôles ruban ( see page 152).
Cette rubrique suppose que vous êtes familier avec le composant
TActionManager et les composants associés à son utilisation. De nombreuses
nouvelles propriétés ont été ajoutées afin de prendre en charge les exigences de
ruban. La plupart des propriétés existantes sont sans effet quand elles sont
modifiées sur une commande qui est affichée sur le ruban.
Par exemple :

• Les petits boutons affichent toujours leur glyphe sur la

gauche du... suite ( see page 153)

95
 Développement d'une application Windows RAD Studio 2.5 Procédures VCL

2.5.1 Construction d'une application console "Hello World"

Windows
Cette application console "Hello World" Windows illustre les étapes essentielles de la création d'une application Windows dans
Delphi ou C++. L'application utilise Windows, une fenêtre console et un événement, et affiche une boîte de dialogue en réponse
à une action de l'utilisateur.

Pour créer l'application console "Hello world"

1. Créez une application console Windows.
2. Créez la logique.
3. Exécutez l'application.

Pour créer une application console Windows

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi ou Projets C++Builder et double-cliquez sur
Application console.
3. Pour C++, dans la boîte de dialogue Nouvelle application console, assurez-vous que les cases Utiliser la VCL et
Multi-Thread ne sont pas cochées, et que la case Application console est cochée. Cliquez ensuite sur OK.

Pour associer du code à la fenêtre console

2 1. Dans le template de code affiché dans l'éditeur de code : Pour Delphi, entrez les instructions suivantes après le mot clé try
et devant le mot clé except :
Writeln('Bonjour!');

ReadLn;
Pour C++, entrez l'instruction suivante après #pragma hdrstop :
#include <iostream>
2. Pour C++, entrez le code suivant après l'accolade d'ouverture ({) :
std::cout<<"Bonjour!"<<std::endl;
std::cin.ignore();
3. Enregistrez l'application.

Pour exécuter l'application "Hello World"

1. Choisissez Exécuter Exécuter. L'application se compile et affiche une fenêtre console comportant le message "Bonjour!".
2. Appuyez sur la touche Entrée. La fenêtre console se ferme quand le programme se termine.
Voir aussi
Vue globale de Windows ( see page 55)

Construction d'une application Windows ( see page 97)

Construction des menus d'applications ( see page 97)

96
2.5 Procédures VCL RAD Studio Construction des menus d'applications

2.5.2 Développement d'une application Windows

La procédure suivante illustre les étapes essentielles de la construction d'une application Windows.

Pour créer un projet Windows

1. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Projets Delphi, puis double-cliquez sur Application. Le
concepteur Windows s'affiche.
2. Au besoin, sélectionnez la vue Conception.
3. A partir de la palette d'outils, faites glisser des composants dans le concepteur pour créer l'interface utilisateur.
4. Associez de la logique aux contrôles.

Pour associer du code à un contrôle

1. Dans le concepteur, double-cliquez sur le composant auquel vous souhaitez appliquer la logique. L'éditeur de code apparaît,
avec le curseur placé entre les mots réservés begin et end dans le gestionnaire d'événement.
2. Codez la logique de votre application.
3. Enregistrez et compilez l'application.
Voir aussi
Vue globale de Windows ( see page 55)

Construction d'une application "Hello world" Windows ( see page 96)

Construction de menus d'application Windows ( see page 97) 2

2.5.3 Construction des menus d'applications

Les menus constituent pour les utilisateurs un moyen commode d'exécuter des commandes regroupées logiquement. Vous
pouvez ajouter ou supprimer des éléments de menu ou les déplacer pour réorganiser les éléments lors de la conception. Outre
les composants TMainMenu et TPopupMenu, la palette d'outils contient aussi TActionMainMenuBar, TActionManager et
TActionToolBar.

Pour créer des menus d'applications

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Application Fiches VCl. Le concepteur Windows s'affiche.
3. Construisez les menus d'applications.
4. Utilisez le concepteur de menus.
5. Créez un gestionnaire d'événement pour chaque élément de menu.
6. Déplacez les éléments de menus.
7. Ajoutez des images aux éléments de menus.

Pour construire des menus d'applications

1. Dans la catégorie Standard de la palette d'outils, ajoutez un composant TMainMenu ou TPopupMenu à votre fiche. Une
représentation visuelle du menu apparaît sur le concepteur.

97
 Construction des menus d'applications RAD Studio 2.5 Procédures VCL

Remarque: Un composant TMainMenu

crée un menu attaché à la barre de titre de la fiche. Un composant TPopupMenu crée un menu qui apparaît lorsque
l'utilisateur clique avec le bouton droit de la souris sur la fiche.
2. Pour voir le menu, si la fiche est visible, cliquez sur la fiche. Le menu apparaît dans la fiche exactement tel qu'il apparaîtra à
l'exécution du programme.
3. Pour supprimer un élément de menu, sélectionnez l'élément de menu que vous voulez supprimer. Appuyez sur Suppr.
4. Pour modifier des éléments de menus, sélectionnez la fiche VCL, sélectionnez l'élément du menu que vous voulez modifier et
modifiez ses propriétés.
5. Pour que l'élément de menu soit une ligne de séparation, placez le curseur sur le menu où vous voulez voir apparaître un
séparateur et entrez un signe moins (-) comme libellé ou appuyez sur la touche moins (-).
6. Pour spécifier un raccourci clavier pour un élément de menu, dans l'inspecteur d'objets, définissez la propriété ShortCut.

Pour utiliser le concepteur de menus

1. Sélectionnez un composant menu sur la fiche.
2. Double-cliquez sur le composant menu. La fenêtre du concepteur de menus s'ouvre.
Remarque: Vous pouvez également ouvrir le concepteur de menus
en cliquant sur le bouton points de suspension (...) à côté de la propriété Items dans l'inspecteur d'objets.
3. Pour nommer un composant menu, dans l'inspecteur d'objets, définissez la propriété Caption.
Conseil: Delphi dérive la propriété Name du libellé, par exemple si vous affectez à la propriété Caption d'un élément de
menu la valeur File, Delphi affectera à la propriété Name de cet élément la valeur File1. Par contre, si vous renseignez
d'abord la propriété Name, avant de renseigner la propriété Caption, Delphi laissera la propriété Caption vide jusqu'à ce que
vous saisissiez une valeur.

2
4. Cliquez avec le bouton droit de la souris n'importe où dans le concepteur de menus pour utiliser le menu contextuel du
concepteur de menus. Une liste déroulante s'ouvre. Il s'agit du menu contextuel du concepteur de menus.
5. Pour insérer un emplacement en dessous ou à la droite du curseur, choisissez Insérer dans le menu contextuel.
6. Pour supprimer l'élément de menu sélectionné (et tous ses sous-éléments, s'il y a lieu), cliquez sur Supprimer dans le menu
contextuel.
7. Pour parcourir les menus d'une fiche, choisissez Sélectionner un menu dans le menu contextuel. La boîte de dialogue
Sélection de menu s'affiche. Elle énumère tous les menus associés à la fiche dont le menu est actuellement ouvert dans le
concepteur de menus.
8. Dans la liste de la boîte de dialogue Sélection de menu, choisissez le menu que vous souhaitez consulter ou modifier.

Pour créer un gestionnaire d'événement pour un élément de menu

1. Dans le concepteur, double-cliquez sur l'élément de menu auquel vous souhaitez ajouter un gestionnaire d'événement. Le
concepteur de code apparaît, avec le curseur placé entre des crochets de gestionnaire d'événement.
2. Codez la logique de l'élément de menu.
3. Enregistrez et compilez l'application.

Pour déplacer des éléments de menus

1. Pour déplacer un élément de menu dans la barre de menu souhaitée, déplacez l'élément jusqu'à ce que la pointe du curseur
de déplacement désigne la nouvelle position.
2. Relâchez le bouton de la souris.
3. Pour déplacer un élément de menu dans une liste de menus, déplacez l'élément jusqu'à ce que la pointe du curseur de
déplacement désigne le nouveau menu.
4. Relâchez le bouton de la souris.

98
2.5 Procédures VCL RAD Studio Construction d'une application Fiches VCL

Pour ajouter des images à des éléments de menus

1. Dans la palette d'outils, déposez un composant TMainMenu ou TPopupMenu sur la fiche.
2. A partir de la palette d'outils, déposez un composant TImageList sur la fiche.
3. Double-cliquez sur le composant TImageList. L'éditeur ImageList s'affiche.
4. Cliquez sur Ajouter pour sélectionner le bitmap ou le groupe de bitmaps que vous souhaitez utiliser dans le menu.
5. Sélectionnez le bitmap voulu et cliquez sur OK.
6. Dans l'inspecteur d'objets, affectez à la propriété Images du composant TMainMenu ou TPopupMenu l'image que vous
avez sélectionnée dans l'éditeur ImageList.
Voir aussi
Vue globale de Windows ( see page 55)

Construction d'une application Windows ( see page 97)

TActionMainMenuBar

TActionManager

TActionToolBar

2.5.4 Construction d'une application Fiches VCL avec des

composants d'aide à la décision
2
La création d'une fiche avec des tableaux et des graphes de données multidimensionnelles se compose des étapes majeures
suivantes :

1. Création d'une fiche VCL.

2. Ajout d'une requête de décision et d'un ensemble de données.
3. Ajout d'un cube de décision.
4. Ajout d'une source de décision.
5. Ajout éventuel d'un pivot de décision.
6. Ajout d'un ou plusieurs graphes de décision ou d'une ou plusieurs grilles de décision.
7. Initialisation de la propriété Active de la requête de décision (ou d'un autre composant ensemble de données) à True.

Pour créer une fiche VCL

1. Choisissez Fichier Nouveau Autre Projets Delphi, puis double-cliquez sur l'icône Application Fiches VCL. Le
concepteur de fiches VCL apparaît.
2. Si nécessaire, cliquez sur Form1 pour rendre la fenêtre active.

Pour ajouter un ensemble de données de décision

1. Sur la page Cube de décision de la palette d'outils, ajoutez un composant DecisionQuery en haut de la fiche.
Conseil: Placez les composants non visuels comme celui-ci dans le coin supérieur gauche de la fiche de manière à les
séparer des composants visuels que vous allez ajouter.

2. Cliquez avec le bouton droit de la souris sur le composant DecisionQuery, et sélectionnez Editeur de requête de décision....

99
 Construction d'une application Fiches VCL RAD Studio 2.5 Procédures VCL

La boîte de dialogue Editeur de requête de décision apparaît.

3. Sur l'onglet Dimensions/récapitulatifs, sélectionnez la base de données BCDEMOS dans la liste déroulante Base de
données : .
4. Dans la liste déroulante Table :, sélectionnez la table parts.db. La boîte liste Liste des champs disponibles : affiche les
champs de la table parts.db.
5. Utilisez CTRL+clic pour sélectionner les champs PartNo, OnOrder et Cost. Cliquez ensuite sur le bouton flèche droite à côté
de la boîte liste Dimensions : . PartNo, OnOrder et Cost s'affichent dans la boîte liste.
6. Sélectionnez le champ OnOrder ; cliquez ensuite sur le bouton flèche droite à côté de la boîte liste Récapitulatifs : et
sélectionnez nombre dans le menu déroulant qui s'affiche. COUNT(OnOrder) s'affiche dans la boîte liste Récapitulatifs : .
7. Sélectionnez le champ Cost dans la boîte liste Liste des champs disponibles :, puis cliquez sur le bouton flèche droite à
côté de la boîte liste Récapitulatifs : et sélectionnez somme dans le menu déroulant qui s'affiche. SUM(Cost) s'affiche dans
la boîte liste Récapitulatifs : .
8. Cliquez sur OK pour fermer l'éditeur de requête de décision.
Remarque: Lorsque vous utilisez l'éditeur de requête de décision, la requête est initialement gérée en utilisant la syntaxe
SQL ANSI-92 puis traduite (si nécessaire) dans le dialecte utilisé par le serveur. L'éditeur ne lit et n'affiche que du SQL ANSI
standard. La traduction dans le dialecte approprié est affectée automatiquement à la propriété SQL du TDecisionQuery. Pour
modifier une requête, éditez la version ANSI-92 dans l'éditeur de requête de décision et non celle de la propriété SQL.

Pour ajouter un cube de décision

1. Sur la page Cube de décision de la palette d'outils, ajoutez un composant cube de décision dans le coin supérieur gauche
de la fiche.
2. Dans l'inspecteur d'objets, sélectionnez DecisionQuery1 dans la liste déroulante à côté de la propriété DataSet du cube de
décision.

2 Pour ajouter une source de décision

1. Sur la page Cube de décision de la palette d'outils, ajoutez un composant source de décision dans le coin supérieur
gauche de la fiche.
2. Dans l'inspecteur d'objets, sélectionnez DecisionCube1 dans la liste déroulante à côté de la propriété DecisionCube de la
source de décision.

Pour ajouter un pivot de décision

1. Sur la page Cube de décision de la palette d'outils, ajoutez un composant DecisionPivot facultatif en haut de la fiche.
Conseil: Le pivot de décision s'affiche dans la fenêtre de l'application finale. Placez-le à droite des composants non visuels.

2. Dans l'inspecteur d'objets, sélectionnez DecisionSource1 dans la liste déroulante à côté de la propriété DecisionSource du
pivot de décision.

Pour créer une grille de décision

1. Sur la page Cube de décision de la palette d'outils, ajoutez un composant grille de décision à la fiche juste à côté du pivot
de décision.
2. Dans l'inspecteur d'objets, sélectionnez DecisionSource1 dans la liste déroulante à côté de la propriété DecisionSource de
la grille de décision.

Pour créer un graphe de décision

1. Sur la page Cube de décision de la palette d'outils, ajoutez un composant graphe de décision à la fiche juste à côté de la
grille de décision.
2. Dans l'inspecteur d'objets, sélectionnez DecisionSource1 dans la liste déroulante à côté de la propriété DecisionSource du
graphe de décision.

100
2.5 Procédures VCL RAD Studio Construction d'une application MDI Fiches

Pour exécuter l'application

1. Dans l'inspecteur d'objets, sélectionnez True dans le menu déroulant de la propriété Active. Les composants visuels
graphe, grille et pivot de décision affichent des données.
2. Choisissez Exécuter Exécuter pour lancer l'application. L'application exécute et affiche les composants d'aide à la
décision.
3. Utilisez le pivot de décision pour mettre à jour, comme vous le souhaitez, les données affichées dans la grille et dans le
graphe.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.5 Construction d'applications Fiches VCL avec

graphiques
Chacune des procédures ci-dessous permet de construire une application Fiche VCL qui utilise des graphiques. Construisez un
ou plusieurs exemples puis ajoutez d'autres fonctionnalités graphiques à ces applications Fiches VCL de base. *

1. Dessin de lignes droites.

2. Dessin de rectangles et d'ellipses.
3. Dessin d'un polygone.
4. Affichage d'une image bitmap.
2
5. Ajout d'un bitmap dans une boîte à options.
Voir aussi
Présentation de la programmation relative aux graphiques ( see page 2248)

Dessin de lignes droites dans une application VCL ( see page 128)

Dessin de rectangles et d'ellipses dans une application VCL ( see page 127)

Affichage d'une image bitmap dans une application VCL ( see page 124)

Insertion d'une image bitmap dans une boîte à options d'une application VCL ( see page 144)

2.5.6 Construction d'une application MDI Fiches VCL à l'aide

d'un expert
L'expert Application MDI Fiches VCL crée automatiquement un projet qui inclut les fichiers de base pour une application MDI. En
plus du fichier source principal, l'expert crée des fichiers d'unités pour des fenêtres enfants et de boîte de dialogue A propos,
avec les fichiers de fiches et les ressources.

Pour créer une nouvelle application MDI à l'aide d'un expert

1. Choisissez Fichier Nouveau Autre Projets Delphi, puis double-cliquez sur l'icône Application MDI. La boîte de
dialogue de recherche d'un dossier s'affiche.
2. Naviguez dans le dossier dans lequel vous souhaitez stocker les fichiers du projet.

101
 Construction d'une application MDI Fiches RAD Studio 2.5 Procédures VCL

3. Cliquez sur OK.

4. Choisissez Exécuter Exécuter pour compiler et lancer l'application.
5. Essayez les commandes configurées automatiquement par l'expert Application MDI.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.7 Construction d'une application MDI Fiches VCL sans

utiliser d'expert
Les étapes de base pour créer une nouvelle application MDI avec une fenêtre enfant sans utiliser d'expert sont les
suivantes :
1. Créez une fiche de fenêtre principale (fenêtre parent MDI).
2. Créez une fiche de fenêtre enfant.
3. La fenêtre principale crée la fenêtre enfant sous le contrôle de l'utilisateur.
4. Ecrivez le code du gestionnaire d'événement pour fermer la fenêtre enfant.
5. Créez le menu principal et les commandes.
6. Ajoutez les gestionnaires d'événements pour les commandes.
7. Compilez l'application et exécutez-la.

2 Pour créer la fiche de fenêtre principale

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Dans l'inspecteur d'objets, initialisez la propriété FormStyle à la valeur fsMDIForm.
3. Entrez un nom plus descriptif, tel que frMain, pour la propriété Name.
4. Enregistrez le fichier d'unité avec un nom plus descriptif, par exemple uMain.pas (Delphi) ou uMain.cpp (C++).

Pour créer une fenêtre enfant

1. Choisissez Fichier Nouveau Fiche.
2. Dans l'inspecteur d'objets, initialisez la propriété FormStyle à la valeur fsMDIChild.
3. Entrez un nom plus descriptif, tels que frChild, pour la propriété Name.
4. Enregistrez le fichier d'unité sous le nom uChild.pas (Delphi) ou uChild.cpp (C++).

Pour avoir la fenêtre principale, créez la fenêtre enfant

1. Choisissez Projet Options Fiches. La boîte de dialogue Options du projet s'affiche.
2. Sélectionnez la fiche frChild dans la liste Fiches créées automatiquement et cliquez sur [>] pour la placer dans la liste
Fiches disponibles, puis cliquez sur OK.
3. Sélectionnez la fiche frMain pour l'activer ; accédez ensuite à la vue Code.
4. Pour Delphi, faites défiler jusqu'à la section uses et ajoutez uChild à la liste. Pour C++, ajoutez #include "uChild.h" à
uMain.h.
5. Pour Delphi, faites défiler jusqu'à la section des déclarations private et entrez la déclaration de procédure suivante :
procedure CreateChildForm(const childName: string);

102
2.5 Procédures VCL RAD Studio Construction d'une application MDI Fiches

Pour C++, ajoutez la déclaration de fonction suivante aux déclarations private: de TfrMain.
void __fastcall CreateChildForm( const AnsiString childName );
6. Pour Delphi, faites défiler jusqu'à la section implementation et entrez le code suivant :
procedure TfrMain.CreateChildForm (const childName: string);
var Child: TfrChild;
begin
Child := TfrChild.Create(Application);
Child.Caption := childName;
end;
Pour C++, ajoutez la déclaration de fonction suivante à uMain.cpp :
void __fastcall TfrMain::CreateChildForm( const AnsiString childName )
{
TfrChild *Child = new TfrChild( Application );
Child->Caption = childName;
}

Pour écrire le code du gestionnaire d'événement pour la fermeture de la fenêtre enfant

1. Si nécessaire, activez la fiche frMain, puis sélectionnez l'onglet Evénements dans l'inspecteur d'objets.
2. Double-cliquez sur l'événement OnClose. L'éditeur de code s'affiche, avec le curseur placé dans le bloc du gestionnaire de
l'événement TfrMain.FormClose (Delphi) ou TfrMain::FormClose (C++).
3. Pour Delphi, entrez le code suivant :
Action := caFree;
Pour C++, entrez le code suivant :
Action = caFree;
2
Pour créer le menu principal et les commandes
1. A partir de la page Standard de la palette d'outils, placez un composant TMainMenu sur la fiche principale.
2. Double-cliquez sur le composant TMainMenu. Le concepteur de menus (frMain.MainMenu1) s'affiche avec le premier élément
de menu vide en surbrillance.
3. Dans l'inspecteur d'objets sur l'onglet Propriétés, entrez mnFile pour la propriété Name et &Fichier pour la propriété
Caption. Appuyez ensuite sur ENTREE. Dans le concepteur de menus, le nom affiché pour le premier élément du menu est
Fichier.
4. Dans le concepteur de menus, sélectionnez Fichier. Un champ de commande vide s'affiche dans le groupe Fichier.
Sélectionnez la commande vide.
5. Dans l'inspecteur d'objets, entrez mnNewChild pour la propriété Name et &Nouvel enfant pour la propriété Caption ;
appuyez ensuite sur ENTREE. Dans le concepteur de menus, le nom de la première commande de fichier affiché est Nouvel
enfant et un champ de commande vide s'affiche juste à côté de Nouvel enfant.
6. Sélectionnez la commande vide.
7. Dans l'inspecteur d'objets, entrez mnCloseAll pour la propriété Name et &Tout fermer pour la propriété Caption ; appuyez
ensuite sur ENTREE. Dans le concepteur de menus, le nom affiché pour la deuxième commande de fichier est Tout fermer.

Pour ajouter des gestionnaires d'événements pour les commandes Nouvel enfant et Tout fermer
1. Si nécessaire, ouvrez le concepteur de menus et sélectionnez Nouvel enfant.
2. Dans l'inspecteur d'objets, double-cliquez sur l'événement OnClick de l'onglet Evénements. L'éditeur de code s'affiche,
avec le curseur placé dans le bloc du gestionnaire de l'événement TfrMain.mnNewChildClick (Delphi) ou
TfrMain::mnNewChildClick (C++).
3. Pour Delphi, entrez le code suivant :
CreateChildForm('Enfant '+IntToStr(MDIChildCount+1));

103
 Construction d'une application SDI Fiches RAD Studio 2.5 Procédures VCL

Pour C++, entrez le code suivant :

CreateChildForm( "Enfant " + IntToStr( MDIChildCount + 1 ) );
4. Dans le concepteur de menus, sélectionnez Tout fermer.
5. Dans l'inspecteur d'objets, double-cliquez sur l'événement OnClick de l'onglet Evénements. L'éditeur de code s'affiche,
avec le curseur placé dans le bloc du gestionnaire de l'événement TfrMain.mnCloseAllClick (Delphi) ou
TfrMain::mnCloseAllClick (C++).
6. Pour Delphi, entrez le code suivant :
for i:=0 to MDIChildCount - 1 do
MDIChildren[i].Close;
Pour C++, entrez le code suivant :
for( int i = 0; i < MDIChildCount; i++ ) {
MDIChildren[i]->Close();
}
7. Pour Delphi, déclarez la variable locale i. Les deux premières lignes du code du gestionnaire d'événement doivent apparaître
comme affiché ici lorsque vous avez terminé :
procedure TfrMain.mnCloseAllClick(Sender: TObject);
var i : integer;
Remarque: Le gestionnaire d'événement minimise la fenêtre enfant dans la fenêtre principale. Pour fermer la fenêtre enfant,
vous devez ajouter une procédure OnClose à la fiche enfant (ci-dessous).

Pour fermer la fenêtre enfant

1. Activez la fiche enfant.
2. Dans l'inspecteur d'objets, double-cliquez sur l'événement OnClose de l'onglet Evénements. L'éditeur de code s'affiche,
2 avec le curseur placé dans le bloc du gestionnaire de l'événement TfrChild.FormClose (Delphi) ou
TfrChild::FormClose (C++).
3. Pour Delphi, entrez l'instruction suivante :
Action := caFree;
Pour C++, entrez l'instruction suivante :
Action = caFree;

Pour compiler et exécuter l'application MDI

1. Choisissez Exécuter Exécuter.
2. L'application s'exécute, en affichant la commande Fichier.
3. Choisissez Fichier Nouvel enfant une ou plusieurs fois. Une fenêtre enfant apparaît avec chaque commande Nouvel
enfant.
4. Choisissez Fichier Tout fermer. Les fenêtres enfants se ferment.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.8 Construction d'une application SDI Fiches VCL

Pour créer une nouvelle application SDI
1. Choisissez Fichier Nouveau Autre Projets Delphi, puis double-cliquez sur l'icône Application SDI.

104
2.5 Procédures VCL RAD Studio Création d'un nouveau composant VCL

2. Choisissez un dossier dans lequel enregistrer les fichiers et cliquez sur OK.
3. Choisissez Exécuter Exécuter pour compiler et lancer l'application.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.9 Création d'un nouveau composant VCL

Vous pouvez utiliser l'expert Nouveau composant VCL pour créer un nouveau composant VCL pour votre application. Il détecte
la personnalité du produit que vous utilisez et crée le type de composant approprié.

Métaprocédure : Création d'un nouveau composant VCL

1. Spécifiez un composant ancêtre sur la page Composant ancêtre.
2. Spécifiez le nom de la classe et d'autres propriétés sur la page Composant.
3. Choisissez une des trois méthodes suivantes pour la création d'une unité :
• Créer une unité, sur la page Créer une unité
• Installer l'unité dans un package existant, sur la page Package existant
• Installer l'unité dans un nouveau package, sur la page Nouveau package

Pour spécifier un composant ancêtre

1. Créez un nouveau package pour le nouveau composant en choisissant Fichier Nouveau Autre Projets Delphi et en
double-cliquant sur l'icône Package. Cette étape ajoute un nouveau package au Gestionnaire de projets et active l'option 2
Ajouter l'unité au projet <mon_nouveau_package> sur la page Créer une unité.
2. Dans l'EDI, choisissez Composant Nouveau composant VCL. Cette étape affiche la première page de l'expert Nouveau
composant VCL (la page Composant ancêtre) et charge la page avec des noms de composant, ainsi que l'unité qui définit
chaque composant.
3. Sur la page Composant ancêtre, sélectionnez un composant ancêtre dans la liste.
4. Cliquez sur Suivant. Cela affiche la page Composant de l'expert Nouveau composant VCL.

Pour spécifier le nom de la classe et d'autres propriétés

1. Sur la page Composant, les champs Nom de classe, Page de palette, Nom d'unité et Chemin de recherche sont
préremplis. Vous pouvez accepter les valeurs par défaut de ces champs ou modifier les valeurs en suivant les étapes
ci-après. Si vous souhaitez accepter les valeurs par défaut, passez directement à l'étape 6.
2. Pour modifier le nom de classe par défaut, entrez un autre nom de classe dans la zone de saisie Nom de classe.
3. Pour changer la page de palette par défaut pour le composant, entrez dans la zone de saisie Page de palette le nom de la
zone de la palette d'outils choisie ou cliquez sur la flèche vers le bas pour faire une sélection parmi les zones de la palette
d'outils.
4. Dans la zone de saisie Nom d'unité, vous pouvez entrer ou modifier le chemin complet du nom de l'unité. Cliquez sur [...]
pour naviguer et sélectionner l'unité voulue.
5. Entrez ou modifiez le chemin de recherche dans la zone de saisie Chemin de recherche.
6. Cliquez sur Suivant. Cela ouvre la page Créer une unité de l'expert. Les choix de la page Créer une unité sont les suivants :
• Créer l'unité
• Installer dans un package existant
• Installer dans un nouveau package

105
 Conception d'une application Fiches VCL RAD Studio 2.5 Procédures VCL

• Ajouter l'unité au projet <mon_nouveau_package> (cette sélection est présente uniquement si vous avez créé un
nouveau package à la première étape ci-dessus)

Pour créer une unité

1. Sur la page Créer une unité, sélectionnez le bouton radio Créer l'unité.
2. Cliquez sur Terminer. La nouvelle unité s'ouvre dans l'éditeur de code.

Pour installer une unité dans un package existant

1. Sur la page Créer une unité, sélectionnez le bouton radio Installer dans un package existant.
2. Cliquez sur Suivant. Cela génère une liste des packages existants.
3. Sur la page Package existant, sélectionnez le package dans lequel vous souhaitez installer l'unité.
4. Cliquez sur Terminer. La nouvelle unité s'ouvre dans l'éditeur de code.

Pour installer une unité dans un nouveau package

1. Sur la page Créer une unité, sélectionnez le bouton radio Installer dans un nouveau package.
2. Cliquez sur Suivant.
3. Sur la page Nouveau package, entrez le nom du package dans la zone de saisie Nom du package.
4. Dans la zone de saisie Description, entrez la description de votre nouveau package.
5. Cliquez sur Terminer. La nouvelle unité s'ouvre dans l'éditeur de code.

Pour installer une unité dans le package créé avant de lancer l'expert
1. Sur la page Créer une unité, sélectionnez Ajouter l'unité au projet <mon_nouveau_package>.
2 2. Cliquez sur Terminer. La nouvelle unité s'ouvre dans l'éditeur de code.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.10 Conception d'une application Fiches VCL de base de

données ADO
La procédure suivante indique comment construire une application de base de données ADO.

La construction d'une application VCL ADO comprend les étapes principales suivantes :

1. Définition de la connexion à la base de données.

2. Définition de l'ensemble de données.
3. Installation du fournisseur de données, de l'ensemble de données client et de la source de données.
4. Connexion d'une grille de données aux composants connexion.
5. Exécution de l'application.

Pour ajouter un composant connexion ADO

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. A partir de la page ADO de la palette d'outils, placez un composant ADOConnection sur la fiche.

106
2.5 Procédures VCL RAD Studio Conception d'une application Fiches VCL

3. Double-cliquez sur le composant ADOConnection pour afficher la boîte de dialogue ConnectionString.

4. Si nécessaire, sélectionnez Utiliser la chaîne de connexion puis cliquez sur le bouton Construire pour afficher la boîte de
dialogue Propriétés de liaison.
5. Sur la page Fournisseur de la boîte de dialogue, sélectionnez Fournisseur Microsoft Jet 4.0 OLE DB puis cliquez sur le
bouton Suivant pour afficher la page Connexion.
6. Sur la page Connexions, cliquez sur le bouton points de suspension pour parcourir la base de données dbdemos.mdb. Le
chemin par défaut de cette base de données est C:\Program Files\Fichiers communs\Borland Shared\Data.
7. Cliquez sur Tester la connexion pour confirmer la connexion. L'état de la connexion s'affiche dans une boîte de dialogue.
8. Cliquez sur OK pour fermer la boîte de dialogue des propriétés de liaison de données. Cliquez sur OK pour fermer la boîte
de dialogue ConnectionString.

Pour configurer l'ensemble de données

1. Sur la page ADO, placez un composant ADODataSet en haut de la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété Connection. Attribuez-lui la valeur
ADOConnection1.
3. Affectez une commande SQL à la propriété CommandText ; par exemple, Select * from orders. Vous pouvez soit taper
l'instruction Select dans l'inspecteur d'objets, soit cliquer sur les points de suspension à droite de CommandText pour
afficher l'éditeur de CommandText, dans lequel vous pouvez construire votre propre requête.
Conseil: Si vous avez besoin d'une assistance particulière lorsque vous utilisez l'éditeur de CommandText
, cliquez sur le bouton Aide.
4. Initialisez la propriété Active à True pour ouvrir l'ensemble de données. Vous êtes invité à vous connecter. Utilisez admin
comme nom d'utilisateur et ne saisissez pas de mot de passe.

Pour ajouter le fournisseur 2

1. Sur l'onglet Accès aux données, placez un composant DataSetProvider en haut de la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété DataSet. Attribuez-lui la valeur ADODataSet1.

Pour ajouter l'ensemble de données client

1. Sur la page Accès aux données, placez un composant ClientDataSet à droite du composant DataSetProvider sur la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété ProviderName. Attribuez-lui la valeur
DataSetProvider1.
3. Définissez la propriété Active par True pour permettre la transmission des données à votre application. Une source de
données se connecte à l'ensemble de données client par des contrôles orientés données. Chaque contrôle orienté données
doit être associé à un composant source de données afin de pouvoir afficher et manipuler des données. De même, tous les
ensembles de données doivent être associés à un composant source de données afin que leurs données puissent être
affichées et manipulées dans les contrôles orientés données de la fiche.

Pour ajouter la source de données

1. Sur la page Accès aux données de la palette d'outils, placez un composant DataSource à droite du composant
ClientDataSet sur la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété DataSet. Attribuez-lui la valeur ClientDataSet1.

Pour connecter un DataGrid au DataSet

1. Sur la page Contrôles de données de la palette d'outils, placez un composant DBGrid sur la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété DataSource. Attribuez la valeur DataSource1 à la
source de données.
3. Choisissez Exécuter Exécuter.

107
 Création d'actions dans une application RAD Studio 2.5 Procédures VCL

4. Vous êtes invité à vous connecter. Entrez admin comme nom d'utilisateur et n'entrez pas de mot de passe. L'application se
compile et affiche une fiche VCL comportant un composant DBGrid.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.11 Construction d'une application Fiches VCL

La procédure suivante illustre les étapes essentielles de la construction d'une application Fiches VCL avec RAD Studio.

Pour créer une fiche VCL

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. A partir de la palette d'outils, placez des composants sur la fiche pour créer l'interface utilisateur.
3. Ecrivez le code des contrôles.

Pour associer du code à un contrôle

1. Double-cliquez sur le composant auquel vous souhaitez appliquer la logique. L'éditeur de code apparaît, avec le curseur
dans le bloc de code du gestionnaire d'événement.
2. Codez la logique de votre application.
3. Enregistrez et compilez l'application.
Voir aussi
2
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL "Hello World" ( see page 109)

Construction d'une application MDI Fiches VCL sans utiliser d'expert ( see page 102)

Utilisation de ActionManager pour créer des actions dans une application Fiches VCL ( see page 110)

2.5.12 Création d'actions dans une application Fiches VCL

Dans RAD Studio, la procédure suivante illustre comment créer des actions avec l'outil ActionList. Elle configure une application
simple et explique comment créer un élément de menu fichier avec une action d'ouverture de fichier.

La construction d'une application VCL avec ActionList comprend les étapes principales suivantes :

1. Créez une fenêtre principale et ajoutez des outils pour créer un menu principal et une action d'ouverture de fichier.
2. Ajoutez la catégorie Fichier au menu principal.
3. Ajoutez l'action d'ouverture de fichier à la catégorie Fichier.
4. Construction et exécution de l'application.

Pour créer une fenêtre principale

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Dans la catégorie Standard de la palette d'outils, ajoutez un composant TMainMenu et TActionList à la fiche.

108
2.5 Procédures VCL RAD Studio Construction d'une application Fiches VCL

Conseil: Pour afficher des icônes pour les composants non visuels tels que ActionList1, choisissez
Outils->Options->Options d'environnement
, sélectionnez Concepteur VCL dans les options Delphi, cliquez sur Afficher libellés des composants puis sur OK.

Pour ajouter la catégorie Fichier au menu principal

1. Double-cliquez sur MainMenu1 dans la fiche. L'éditeur MainMenu1 s'affiche avec la première catégorie de commande vide
sélectionnée.
2. Dans l'inspecteur d'objets, entrez &Fichier pour la propriété Caption et appuyez sur la touche ENTREE. Fichier apparaît
dans le menu principal.
3. Cliquez sur Fichier dans l'éditeur MainMenu1. La première action vide sous la commande Fichier s'affiche. Sélectionnez
l'action vide.
4. Double-cliquez sur ActionList1 dans la fiche. L'éditeur ActionList s'affiche.
5. Dans l'éditeur, sélectionnez Nouvelle action standard dans la liste déroulante pour afficher la boîte de dialogue Classes
d'actions standard.
6. Faites défiler jusqu'à la catégorie Fichier et cliquez sur l'action TFileOpen.
7. Cliquez sur OK pour fermer la boîte de dialogue. Fichier s'affiche dans la boîte liste Catégories dans l'éditeur ActionList.
8. Cliquez sur Fichier dans l'éditeur. L'action FileOpen1 s'affiche dans la boîte liste Action.

Pour ajouter l'action d'ouverture de fichier à la catégorie Fichier

1. Double-cliquez sur MainMenu1, si nécessaire, pour afficher l'éditeur MainMenu1. Sélectionnez l'action vide sous la catégorie
Fichier.
2. Dans l'inspecteur d'objets, entrez &Ouvrir pour la propriété Caption et sélectionnez FileOpen1 dans la liste déroulante de la
propriété Action. Appuyez ensuite sur ENTREE. Ouvrir... s'affiche dans l'action vide de l'éditeur MainMenu1.
2
Pour construire et exécuter l'application
1. Choisissez Exécuter Exécuter. L'application s'exécute et affiche une fiche avec la barre de menus principale et le menu
Fichier.
2. Choisissez Fichier Ouvrir dans l'application. La boîte de dialogue d'ouverture de fichier standard apparaît.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.13 Construction d'une application Fiches VCL "Hello

World"
Cette procédure montre comment construire une simple application Fiches VCL "Hello world" avec Delphi ou C++. Malgré sa
simplicité, l'application Fiches VCL "Hello world" illustre les étapes essentielles de la création d'une application Fiches VCL.
L'application utilise une fiche VCL, un contrôle et un événement, et affiche une boîte de dialogue en réponse à une action de
l'utilisateur.

La création de l'application "Hello world" comprend les étapes suivantes :

1. Création d'une fiche VCL avec un contrôle bouton.

2. Ecriture du code pour afficher "Hello Word" quand l'utilisateur clique sur le bouton.
3. Exécution de l'application.

109
 Utilisation de ActionManager pour créer RAD Studio 2.5 Procédures VCL

Pour créer une fiche VCL

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Cliquez sur la fiche VCL pour afficher la vue de la fiche.
3. Sur la page Standard de la palette d'outils, placez un composant TButton sur la fiche.

Pour afficher la chaîne "Hello world"

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur le champ d'action OnClick de l'onglet Evénements. L'éditeur de code
s'affiche, avec le curseur placé dans le bloc du gestionnaire d'événement Button1Click.
3. Pour Delphi, déplacez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une
nouvelle ligne au-dessus du bloc de code. Pour C++, placez le curseur après l'accolade ouvrante ({), puis appuyez sur la
touche Entrée.
4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez la déclaration de variable suivante :
var s: string;
Pour C++, entrez le code suivant :
AnsiString s;
5. Pour Delphi, placez le curseur dans le bloc de code, puis tapez le code suivant :
s:= 'Hello world!';
ShowMessage( s );
Pour C++, entrez le code suivant :
2 s = "Hello world!";
ShowMessage( s );

Pour exécuter l'application "Hello world"

1. Choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche apparaît avec un bouton appelé Button1.
2. Cliquez sur Button1. Une boîte de dialogue affiche le message "Hello World!"
3. Fermez la fiche VCL pour revenir à l'EDI.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.14 Utilisation de ActionManager pour créer des actions

dans une application Fiches VCL
Dans RAD Studio, la procédure suivante illustre comment créer des actions avec ActionManager. Elle configure une interface
utilisateur simple avec une zone de texte, adaptée à une application d'édition de texte, et explique comment créer un élément de
menu fichier avec une action d'ouverture de fichier.

La construction d'une application VCL avec ActionManager comprend les étapes principales suivantes :

1. Création d'une fenêtre principale.

2. Ajout d'une action d'ouverture de fichier à ActionManager.
3. Création du menu principal.

110
2.5 Procédures VCL RAD Studio Conception d'une application Fiches VCL

4. Ajout de l'action au menu.

5. Construction et exécution de l'application.

Pour créer une fenêtre principale et ajouter une action d'ouverture de fichier
1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Supplément de la palette d'outils, ajoutez un composant TActionManager sur la fiche.
3. Double-cliquez sur TActionManager pour afficher l'éditeur de gestionnaire d'actions.
Conseil: Pour afficher les libellés des composants non visuels comme ActionManager, choisissez Outils->Options
d'environnement
. Sur l'onglet Concepteur, cochez Afficher les libellés des composants et cliquez sur OK.
4. Au besoin, cliquez sur l'onglet Actions.
5. Sélectionnez Nouvelle action standard dans la liste déroulante pour afficher la boîte de dialogue Classes d'actions
standard.
6. Faites défiler jusqu'à la catégorie Fichier et cliquez sur l'action TFileOpen.
7. Cliquez sur OK pour fermer la boîte de dialogue.
8. Dans l'éditeur de gestionnaire d'actions, sélectionnez la catégorie Fichier. Ouvrir... s'affiche dans la boîte liste Actions : .
9. Cliquez sur Fermer pour fermer l'éditeur.

Pour créer le menu principal

1. Sur la page Supplément de la palette d'outils, placez un composant TActionMainMenuBar sur la fiche.
2. Ouvrez l'éditeur du gestionnaire d'actions, puis sélectionnez la catégorie Fichier dans la boîte de liste Catégories : .
2
3. Faites glisser la catégorie Fichier sur la barre de menus vide. Fichier apparaît dans la barre de menus.

Pour construire et exécuter l'application

1. Choisissez Exécuter Exécuter. L'application s'exécute et affiche une fiche avec la barre de menus principale et le menu
Fichier.
2. Choisissez Fichier Ouvrir. La boîte de dialogue d'ouverture de fichier s'affiche.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

Construction d'une application MDI Fiches VCL sans utiliser d'expert ( see page 102)

2.5.15 Conception d'une application Fiches VCL de base de

données dbExpress
La procédure suivante indique comment construire une application de base de données dbExpress.

La construction d'une application Fiches VCL dbExpress comprend les étapes principales suivantes :

1. Définition de la connexion à la base de données.

2. Installation de l'ensemble de données unidirectionnel.
3. Installation du fournisseur de données, de l'ensemble de données client et de la source de données.

111
 Conception d'une application Fiches VCL RAD Studio 2.5 Procédures VCL

4. Connexion d'une grille de données aux composants connexion.

5. Exécution de l'application.

Pour ajouter un composant de connexion dbExpress

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. A partir de la page dbExpress de la palette d'outils, placez un composant TSQLConnection sur la fiche.
3. Double-cliquez sur le composant TSQLConnection pour afficher l'éditeur de connexion.
4. Dans l'éditeur de connexion, affectez au champ Nom de connexion la valeur IBConnection.
5. Dans la zone Paramètres de connexion, indiquez dans le champ Database le chemin d'accès au fichier de base de
données InterBase appelé employee.gdb. Par défaut, le fichier se trouve dans C:\Program Files\Fichiers
communs\Borland Shared\Data.
6. Acceptez la valeur des champs Nom d'utilisateur (sysdba) et Mot de passe (masterkey).
7. Cliquez sur OK pour fermer l'éditeur de connexions et enregistrer les modifications.

Pour configurer l'ensemble de données unidirectionnel

1. Sur la page dbExpress de la palette d'outils, placez un composant TSQLDataSet en haut de la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété SQLConnection. Attribuez-lui la valeur
TSQLConnection1.
3. Affectez une commande SQL à la propriété CommandText ; par exemple, Select * from SALES. Vous êtes invité à vous
connecter. Utilisez le mot de passe masterkey. Pour la commande SQL, vous pouvez soit taper une instruction Select dans
l'inspecteur d'objets, soit cliquer sur les points de suspension à droite de CommandText pour afficher l'éditeur de
CommandText, dans lequel vous pouvez construire votre propre instruction de requête.
2 Conseil: Si vous avez besoin d'une assistance particulière lorsque vous utilisez l'éditeur de CommandText
, cliquez sur le bouton Aide.
4. Dans l'inspecteur d'objets, initialisez la propriété Active à la valeur True pour ouvrir l'ensemble de données

Pour ajouter le fournisseur

1. Sur la page Accès aux données de la palette d'outils, placez un composant TDataSetProvider en haut de la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété DataSet. Attribuez-lui la valeur SQLDataSet1.

Pour ajouter l'ensemble de données client

1. Sur la page Accès aux données de la palette d'outils, placez un composant TClientDataSet à droite du composant
TDataSetProvider sur la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété ProviderName. Attribuez-lui la valeur
DataSetProvider1.
3. Définissez la propriété Active par True pour permettre la transmission des données à votre application. Une source de
données se connecte à l'ensemble de données client par des contrôles orientés données. Chaque contrôle orienté données
doit être associé à un composant source de données afin de pouvoir afficher et manipuler des données. De même, tous les
ensembles de données doivent être associés à un composant source de données afin que leurs données puissent être
affichées et manipulées dans les contrôles orientés données de la fiche.

Pour ajouter la source de données

1. Sur la page Accès aux données de la palette d'outils, placez un composant TDataSource à droite du composant
TClientDataSet sur la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété DataSet. Attribuez-lui la valeur ClientDataSet1.

112
2.5 Procédures VCL RAD Studio Construction d'une application avec des

Pour connecter un DataGrid au DataSet

1. Sur la page Contrôles de données de la palette d'outils, placez un composant TDBGrid sur la fiche.
2. Dans l'inspecteur d'objets, sélectionnez la liste déroulante de la propriété DataSource. Attribuez la valeur DataSource1 à la
source de données.
3. Choisissez Exécuter Exécuter. Vous êtes invité à saisir un mot de passe. Entrez masterkey. Si vous entrez un mot de
passe incorrect ou si vous n'entrez aucun mot de passe, le débogueur déclenche une exception. L'application se compile et
affiche une fiche VCL comportant un composant DBGrid.
Voir aussi
Présentation de la VCL ( see page 46)

2.5.16 Construction d'une application avec des composants

XML
Cet exemple crée une application Fiches VCL qui utilise un composant XMLDocument pour afficher le contenu d'un fichier XML.

Les étapes de base sont les suivantes :

1. Création d'un document XML.
2. Création d'une fiche VCL.
3. Positionnement d'un composant XMLDocument sur la fiche et association au fichier XML.
4. Création de composants VCL pour permettre l'affichage du contenu du fichier XML. 2
5. Ecriture de gestionnaires d'événements pour afficher le contenu des noeuds enfants XML.
6. Compilation et exécution de l'application.

Pour créer le document XML

1. Copiez le texte ci-dessous dans un fichier dans un éditeur de texte.
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<!DOCTYPE StockHoldings [
<!ELEMENT StockHoldings (Stock+)>
<!ELEMENT Stock (name)>
<!ELEMENT Stock (price)>
<!ELEMENT Stock (symbol)>
<!ELEMENT Stock (shares)>
]>

<StockHoldings>
<Stock exchange="NASDAQ">
<name>CodeGear</name>
<price>10.375</price>
<symbol>BORL</symbol>
<shares>100</shares>
</Stock>

<Stock exchange="NYSE">
<name>MyCompany</name>
<price>8.75</price>
<symbol>MYCO</symbol>
<shares type="preferred">25</shares>
</Stock>
</StockHoldings>

113
 Construction d'une application avec des RAD Studio 2.5 Procédures VCL

2. Enregistrez le fichier sur votre disque local en tant que document XML. Donnez-lui un nom semblable à stock.xml.
3. Ouvrez le document dans votre navigateur. Le contenu devrait s'afficher sans erreur.
Remarque: Dans le navigateur, vous pouvez choisir Voir->Source
pour consulter le fichier source dans l'éditeur de texte.

Pour créer une fiche avec un composant XMLDocument

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Internet de la palette d'outils, placez un composant TXMLDocument sur la fiche.
3. Dans l'inspecteur d'objets, cliquez sur les points de suspension à côté de la propriété FileName, naviguez jusqu'à
l'emplacement du fichier XML que vous avez créé et ouvrez-le. Le fichier XML est associé au composant TXMLDocument.
4. Dans l'inspecteur d'objets, initialisez la propriété Active à la valeur true.

Pour configurer les composants VCL

1. Sur la page Standard de la palette d'outils, placez un composant TMemo sur la fiche.
2. Sur la page Standard de la palette d'outils, placez deux composants TButton sur la fiche juste au-dessus de Memo1.
3. Dans l'inspecteur d'objets, avec Button1 sélectionné, entrez CodeGear pour la propriété Caption.
4. Dans l'inspecteur d'objets, avec Button2 sélectionné, entrez MyCompany pour la propriété Caption.

Pour afficher le contenu des noeuds enfants dans le fichier XML

1. Dans l'inspecteur d'objets avec Button1 sélectionné, double-cliquez sur l'événement OnClick sur l'onglet Evénements. Le
code s'affiche, avec le curseur placé dans le bloc du gestionnaire d'événement TForm1.Button1Click.
2 2. Entrez le code suivant pour afficher le cours de l'action pour le premier noeud enfant lorsque l'utilisateur clique sur le bouton
CodeGear :
BorlandStock:=XMLDocument1.DocumentElement.ChildNodes[0];
Price:= BorlandStock.ChildNodes['price'].Text;
Memo1.Text := Price;
IXMLNode *BorlandStock = XMLDocument1->DocumentElement->
ChildNodes->GetNode(0);
WideString Price = BorlandStock->ChildNodes->
FindNode( "price" )->Text;
Memo1->Text = Price;
3. Pour Delphi, ajoutez une section var juste au-dessus du bloc de code dans le gestionnaire d'événement et entrez les
déclarations de variables locales suivantes :
var
BorlandStock: IXMLNode;
Price: string;
4. Dans l'inspecteur d'objets avec Button2 sélectionné, double-cliquez sur l'événement OnClick sur l'onglet Evénements. Le
code s'affiche, avec le curseur placé dans le bloc du gestionnaire d'événement TForm1.Button2Click.
5. Entrez le code suivant pour afficher le cours de l'action pour le deuxième noeud enfant lorsque l'utilisateur clique sur le bouton
MyCompany :
MyCompany:=XMLDocument1.DocumentElement.ChildNodes[1];
Price:= MyCompany.ChildNodes['price'].Text;
Memo1.Text := Price;
IXMLNode *MyCompany = XMLDocument1–>DocumentElement
->ChildNodes->GetNode(1);
WideString Price = BorlandStock->ChildNodes
->FindNode( "price" )->Text;
Memo1–>Text = Price;
6. Pour Delphi, ajoutez une section var juste au-dessus du bloc de code dans le gestionnaire d'événement et entrez les

114
2.5 Procédures VCL RAD Studio Copie de données d'un flux vers un autre

déclarations de variables locales suivantes :

var
MyCompany: IXMLNode;
Price: string;

Pour compiler et exécuter l'application

1. Choisissez Exécuter Exécuter pour compiler et exécuter l'application. La fiche de l'application affiche deux boutons et un
mémo.
2. Cliquez sur le bouton CodeGear. Le cours de l'action s'affiche.
3. Cliquez sur le bouton MyCompany. Le cours de l'action s'affiche.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

2.5.17 Copie de données d'un flux vers un autre

La création de cette application VCL comprend les étapes suivantes :

1. Création d'un répertoire projet contenant un fichier texte à copier.

2. Création d'une fiche VCL avec un contrôle bouton.
3. Ecriture du code pour lire la chaîne et l'écrire dans un fichier.
4. Exécution de l'application. 2
Pour configurer votre répertoire projet et un fichier texte à copier
1. Créez un répertoire dans lequel stocker les fichiers de votre projet.
2. En utilisant un éditeur de texte, créez un fichier texte simple et enregistrez-le sous from.txt dans votre répertoire projet.

Pour créer une fiche VCL avec un contrôle bouton

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Standard de la palette d'outils, placez un composant TButton sur la fiche.
3. Dans l'inspecteur d'objets, entrez CopyFile pour les propriétés Caption et Name.

Pour écrire la procédure de copie de flux

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, avec le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.CopyFileClick (Delphi) ou
TForm1::CopyFileClick (C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une nouvelle
ligne au-dessus du bloc de code.
4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez la déclaration de variable suivante :
var stream1, stream2: TStream;
Pour C++, entrez les déclarations de variables suivantes :
TStream *stream1, *stream2;

115
 Copie de la totalité d'une liste de chaînes RAD Studio 2.5 Procédures VCL

5. Placez le curseur dans le bloc de code, puis tapez le code suivant :

stream1 := TFileStream.Create('from.txt', fmOpenRead);
try
stream2:= TFileStream.Create('to.txt', fmCreate);
try
stream2.CopyFrom(stream1, stream1.Size);
finally
stream2.Free;
end;
finally
stream1.Free;
end;
stream1 = new TFileStream( “from.txt”, fmOpenRead );
try {
stream2 = new TFileStream( “to.txt”, fmCreate );
try {
stream2–>CopyFrom( stream1, stream1–>Size );
} __finally {
stream2–>Free();
}
} finally {
stream1–>Free();
}

Pour exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche
apparaît avec un bouton appelé CopyFile.
2. Cliquez sur CopyFile.
3. Utilisez un éditeur de texte pour ouvrir le fichier nouvellement créé to.txt, qui est localisé dans votre répertoire projet. Le
2 contenu de from.txt est copié dans to.txt.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

2.5.18 Copie de la totalité d'une liste de chaînes

La copie d'une liste de chaînes peut avoir l'effet d'ajouter un élément ou d'écraser une liste de chaînes existante. Cette
application VCL ajoute un élément à une liste de chaînes. Avec une simple modification, elle peut écraser une liste de chaînes.
La création de cette application VCL comprend les étapes suivantes :

1. Création d'une fiche VCL avec des contrôles TButtons, TComboBox et TMemo.
2. Ecriture du code de création d'une liste de chaînes dans le gestionnaire OnClick de Button1.
3. Ecriture du code de copie de la liste de chaînes dans le gestionnaire OnClick de Button2.
4. Exécution de l'application.

Pour créer une fiche VCL avec des contrôles de boutons, boîtes à options et mémo
1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. A partir de la page Standard de la palette d'outils, placez deux composants TButtons, un composant TComboBox et un
composant TMemo sur la fiche.

116
2.5 Procédures VCL RAD Studio Copie de la totalité d'une liste de chaînes

Pour créer la liste de chaînes

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi) ou TForm1::Button1Click
(C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une
nouvelle ligne au-dessus du bloc de code.
4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez les déclarations de variables suivantes :
var
StringList: TStrings;
Pour C++, entrez les déclarations de variables suivantes :
TStrings *StringList;
5. Placez le curseur dans le bloc de code, puis tapez le code suivant :
StringList := TStringList.Create;
try
with StringList do begin
Add('Cet exemple utilise une liste de chaînes.');
Add('C'est le moyen le plus facile d'ajouter des chaînes');
Add('à la liste des chaînes d'une boîte à options.');
Add('N'oubliez pas que : la méthode TStrings.Create');
Add('est abstraite; utilisez plutôt la');
Add('méthode TStringList.Create.');
end;

with ComboBox1 do begin

Width := 210; 2
Items.Assign(StringList);
ItemIndex := 0;
end;
finally
StringList.free;
end;
StringList = new TStringList();
try {
StringList->Add( "Cet exemple utilise une liste de chaînes" );
StringList->Add( "C'est le moyen le plus facile d'ajouter des chaînes" );
StringList->Add( "à la liste des chaînes d'une boîte à options." );
StringList->Add( "Pensez à appeler le constructeur TstringList!" );
ComboBox1->Width = 210;
ComboBox1->Items->Assign( StringList );
ComboBox1->ItemIndex = 0;
} __finally {
StringList->Free();
}

Pour copier la liste de chaînes

1. Sélectionnez Button2 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button2Click (Delphi) ou TForm1::Button2Click
(C++). Au niveau du curseur, entrez le code suivant :
Memo1.Lines.AddStrings(ComboBox1.Items);
Memo1–>Lines->AddStrings( ComboBox1–>Items

Pour exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche

117
 Création de chaînes RAD Studio 2.5 Procédures VCL

apparaît avec les contrôles.

2. Cliquez sur Button1.
3. Dans ComboBox1, cliquez sur la flèche pour étendre la liste déroulante. Les chaînes s'affichent dans TComboBox suivant
l'ordre dans lequel elles apparaissent dans le code du gestionnaire d'événement pour Button1.
4. Cliquez sur Button2. Dans la fenêtre Memo1, les chaînes de ComboBox1 sont ajoutées à la chaîne 'Memo1'.
Remarque: Essayez de remplacer le code dans le gestionnaire d'événement Button2 par le code suivant, puis compilez et
exécutez de nouveau l'application.

Memo1.Lines.Assign(ComboBox1.Items);
Memo1–>Lines->Assign( ComboBox1–>Items );
Les chaînes de ComboBox1 écrasent la chaîne 'Memo1'.

Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

2.5.19 Création de chaînes

La création de cette application VCL comprend les étapes suivantes :

1. Créer une fiche VCL avec des contrôles TButton et TComboBox.

2 2. Ecrire le code de création des chaînes dans le gestionnaire OnClick de TButton.
3. Exécuter l'application.

Pour créer une fiche VCL avec des contrôles TButton et TComboBox
1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Standard de la palette d'outils, placez un composant TButton, un TLabel et un TComboBox sur la fiche.

Pour écrire la procédure de création de chaîne

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi) ou TForm1::Button1Click
(C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une
nouvelle ligne au-dessus du bloc de code.
4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez les déclarations de variables suivantes :
var
StringList: TStrings;
Pour C++, entrez les déclarations de variables suivantes :
TStrings *StringList;
5. Placez le curseur dans le bloc de code, puis tapez le code suivant :
StringList := TStringList.Create;
try
with StringList do begin

118
2.5 Procédures VCL RAD Studio Création d'une instance de fiche VCL en

Add('Animaux');
Add('Chats');
Add('Fleurs');
end;

with ComboBox1 do begin

Width := 210;
Items.Assign(StringList);
ItemIndex := 0;
end;

Label1.Caption := 'Fleurs a un indice de ' +

IntToStr( StringList->IndexOf( 'Fleurs' ) );
finally
StringList.free;
end;
StringList = new TStringList();
try {
StringList->Add( "Animaux" );
StringList->Add( "Chats" );
StringList->Add( "Fleurs" );
ComboBox1–>Width = 210;
ComboBox1–>Items->Assign( StringList );
ComboBox1–>ItemIndex = 0;
Label1–>Caption = "Fleurs a un indice de " +
IntToStr( StringList->IndexOf( "Fleurs" ) );
} __finally {
StringList->Free();
}

Pour exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche
apparaît avec les contrôles. 2
2. Cliquez sur le composant Button. Les chaînes 'Animaux', 'Voitures' et 'Fleurs' s'affichent dans l'ordre alphabétique dans une
liste de la boîte liste. Le libellé affiche le message : 'Les fleurs ont l'indice 2.'
3. Dans la boîte à options, cliquez sur la flèche pour développer la liste déroulante. Les chaînes ajoutées au gestionnaire
d'événement TButton s'affichent.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

2.5.20 Création d'une instance de fiche VCL en utilisant une

variable locale
Un moyen fiable de créer une instance unique d'une fiche VCL modale consiste à utiliser une variable locale d'un gestionnaire
d'événement comme référence à une nouvelle instance. Si vous utilisez une variable locale, peu importe que la fiche soit créée
automatiquement ou non. Le code du gestionnaire d'événement ne fait pas référence à la variable fiche globale. En utilisant
RAD Studio, la procédure suivante crée une instance de fiche modale dynamiquement. Elle retire (facultativement) l'appel de la
deuxième fiche au démarrage.

La construction de cette application VCL comprend les étapes suivantes :

1. Créer le répertoire projet.

2. Créer deux fiches pour le projet.

119
 Création d'une instance de fiche VCL en RAD Studio 2.5 Procédures VCL

3. Retirer l'appel de la deuxième fiche au démarrage (facultatif).

4. Lier les fiches.
5. Créer un contrôle sur la fiche principale pour créer et afficher la fiche modale, puis écrire le gestionnaire d'événement.
6. Construire et exécuter l'application.

Pour créer les deux fiches

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL affiche Form1.
2. Choisissez Fichier Nouveau Autre Projets Delphi Fichiers Delphi ou Projets C++Builder, puis double-cliquez sur
l'icône Fiches. Le concepteur de fiches VCL affiche Form2.

Pour retirer facultativement l'appel de Form2 au démarrage

1. Choisissez Projet Options Fiches. La boîte de dialogue Options du projet s'affiche.
2. Sélectionnez Form2 dans la liste Fiches créées automatiquement et cliquez sur [>]. Form2 est déplacée dans la liste
Fiches disponibles.
3. Cliquez sur OK pour fermer la boîte de dialogue.

Pour lier Form1 à Form2

1. Sélectionnez Form1 et choisissez Fichier Utiliser l'unité (Delphi) or Inclure l'en-tête d'unité (C++). La boîte de dialogue
Utiliser l'unité s'affiche.
2. Sélectionnez Form2 (la fiche nécessaire à Form1 comme référence) dans la boîte de dialogue.
3. Cliquez sur OK.
Pour Delphi, une clause uses contenant le nom de l'unité Unit2 est placée dans la section implementation de Unit1.
2
Pour C++, la directive #include "Unit2.h" est ajoutée à Unit1.h.

Pour afficher Form2 à partir de Form1

1. Sélectionnez Form1, si nécessaire, puis, dans la page Standard de la palette d'outils, placez un TButton sur la fiche.
2. Dans l'inspecteur d'objets avec Button1 sélectionné, double-cliquez sur l'événement OnClick de l'onglet Evénements.
L'éditeur de code s'affiche, le curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi)
ou TForm1::Button1Click (C++).
3. Pour Delphi, placez le curseur juste au-dessus du bloc gestionnaire d'événement et entrez l'instruction suivante définissant
une variable locale :
var FM: TForm2;
Pour C++, entrez la déclaration de variable suivante :
TForm2 *FM;
4. Insérez le curseur dans le bloc du gestionnaire d'événement et entrez le code suivant :
FM := TForm2.Create(self);
FM.ShowModal;
FM.Free;
FM = new TForm2( this );
FM->ShowModal();
FM->Free();

Pour construire et exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter. L'application s'exécute, en affichant Form1.
2. Cliquez sur le bouton. Form2 s'affiche.
3. Avec Form2 affichée, essayez de cliquer sur Form1 pour l'activer. Rien ne se passe. Cliquez sur le X dans le coin supérieur

120
2.5 Procédures VCL RAD Studio Suppression de chaînes

droit de Form2. Form2 se ferme et Form1 devient la fiche active.

Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

Création dynamique d'une fiche VCL non modale ( see page 131)

Affichage d'une fiche VCL créée automatiquement ( see page 122)

2.5.21 Suppression de chaînes

La création de cette application VCL comprend les étapes suivantes :

1. Créer une fiche VCL avec des contrôles de boutons et de boîtes liste.
2. Ecrire du code afin d'ajouter des chaînes à une liste.
3. Ecrire du code pour supprimer une chaîne de la liste.
4. Exécuter l'application.

Pour créer une fiche VCL avec des contrôles TButton et ListBox
1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. A partir de la page Standard de la palette d'outils, placez deux composants TButtons et un composant TListBox sur la fiche.
3. Sélectionnez Button1 sur la fiche. 2
4. Dans l'inspecteur d'objets, entrez Ajouter pour les propriétés Caption et Name.
5. Sélectionnez Button2 sur la fiche.
6. Dans l'inspecteur d'objets, entrez Supprimer pour les propriétés Caption et Name.

Pour ajouter des chaînes à une liste

1. Sélectionnez le bouton Ajouter sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.AddClick (Delphi) ou TForm1::AddClick (C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une nouvelle
ligne au-dessus du bloc de code.
4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez la déclaration de variable suivante :
var
MyList: TStringList;
Pour C++, entrez la déclaration de variable suivante :
TStringList *MyList;
5. Placez le curseur dans le bloc de code, puis tapez le code suivant :
MyList := TStringList.Create;
try
with MyList do
begin
Add('Souris');
Add('Chèvres');
Add('Eléphants');

121
 Affichage d'une fiche VCL créée RAD Studio 2.5 Procédures VCL

Add('Oiseaux');
ListBox1.Items.AddStrings(MyList);
end;
finally
MyList.Free;
end;
MyList = new TStringList();
try {
MyList->Add( "Souris" );
MyList->Add( "Chèvres" );
MyList->Add( "Eléphants" );
MyList->Add( "Oiseaux" );
ListBox1–>Items->AddStrings( MyList );
} __finally {
MyList->Free();
}

Pour supprimer une chaîne de la liste

1. Sélectionnez le bouton Supprimer sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, avec le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.DeleteClick (Delphi) ou TForm1::DeleteClick
(C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une
nouvelle ligne au-dessus du bloc de code.
4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez la déclaration de variable suivante :
var
BIndex: Integer;
Pour C++, entrez la déclaration de variable suivante :
2
int BIndex;
5. Pour Delphi, placez le curseur dans le bloc de code, puis tapez le code suivant :
with ListBox1.Items do
begin
BIndex := IndexOf('Eléphants');
Delete (BIndex);
end;
BIndex = ListBox1–>Items->IndexOf( "Eléphants" );
ListBox1–>Items->Delete( BIndex );

Pour exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche
apparaît avec les contrôles.
2. Cliquez sur le bouton Ajouter. Les chaînes 'Souris', 'Chèvres', 'Eléphants' et 'Oiseaux' s'affichent dans l'ordre indiqué.
3. Cliquez sur le bouton Supprimer. La chaîne 'Eléphants' est supprimée de la liste.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

2.5.22 Affichage d'une fiche VCL créée automatiquement

Avec RAD Studio, la procédure suivante crée au moment de la conception une fiche modale qui est affichée ultérieurement au

122
2.5 Procédures VCL RAD Studio Affichage d'une image bitmap dans une

moment de l'exécution du programme.

La construction de cette application VCL comprend les étapes suivantes :

1. Créer le répertoire projet.

2. Créer deux fiches pour le projet.
3. Lier les fiches.
4. Créer un contrôle sur la fiche principale pour afficher la fiche modale, puis écrire le gestionnaire d'événement.
5. Construire et exécuter l'application.

Pour créer les deux fiches

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL affiche Form1.
2. Choisissez Fichier Nouveau Autre Projets Delphi Fichiers Delphi ou Fichier Nouveau Autre Fichiers
C++Builder, puis double-cliquez sur l'icône Fiche. Le concepteur de fiches VCL affiche Form2.

Pour lier Form1 à Form2

1. Pour Delphi, sélectionnez Form1 et choisissez Fichier Utiliser l'unité. Pour C++, sélectionnez Form1 et choisissez
Fichier Inclure l'en-tête d'unité. La boîte de dialogue Utiliser l'unité s'affiche.
2. Sélectionnez Form2 (la fiche nécessaire à Form1 comme référence) dans la boîte de dialogue.
3. Cliquez sur OK.
Pour Delphi, une clause uses contenant le nom de l'unité Unit2 est placée dans la section implementation de Unit1.
Pour C++, la directive #include "Unit2.h" est ajoutée à Unit1.h.

Pour afficher Form2 à partir de Form1 2

1. Sélectionnez Form1, si nécessaire, puis, dans la page Standard de la palette d'outils, placez un bouton sur la fiche.
2. Dans l'inspecteur d'objets avec Button1 sélectionné, double-cliquez sur l'événement OnClick de l'onglet Evénements.
L'éditeur de code s'affiche, le curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi)
ou TForm1::Button1Click (C++).
3. Entrez le code de gestion d'événement suivant :
Form2.ShowModal;
Form2–>ShowModal();

Pour construire et exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter. L'application s'exécute, en affichant Form1.
2. Cliquez sur le bouton. Form2 s'affiche.
3. Cliquez sur le X dans le coin supérieur droit de Form2. Form2 se ferme et Form1 devient la fiche active.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

Création dynamique d'une fiche VCL modale ( see page 129)

123
 Affichage d'une image bitmap dans une RAD Studio 2.5 Procédures VCL

2.5.23 Affichage d'une image bitmap dans une application

Fiches VCL
Cette procédure charge une image bitmap à partir d'un fichier et l'affiche sur une fiche VCL.

1. Créer une fiche VCL avec un contrôle bouton.

2. Fournir une image bitmap.
3. Coder le gestionnaire d'événement onClick du bouton pour charger et afficher une image bitmap.
4. Construire et exécuter l'application.

Pour créer une fiche VCL et un bouton

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Standard de la palette d'outils, placez un composant TButton sur la fiche.

Pour fournir une image bitmap

1. Créez un répertoire dans lequel stocker les fichiers de votre projet.
2. Localisez une image bitmap sur votre disque local, puis copiez-la dans le répertoire de votre projet.
3. Enregistrez tous les fichiers du projet dans le répertoire de votre projet.

2 Pour écrire le gestionnaire d'événement OnClick

1. Dans l'inspecteur d'objets, double-cliquez sur l'événement Button1 OnClick de l'onglet Evénements. L'éditeur de code
s'affiche, le curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi) ou
TForm1::Button1Click (C++).
2. Entrez le code de gestion d'événement suivant, en remplaçant MyFile.bmp par le chemin d'accès à l'image bitmap du
répertoire de votre projet :
Bitmap := TBitmap.Create;
try
Bitmap.LoadFromFile('MyFile.bmp');
Form1.Canvas.Brush.Bitmap := Bitmap;
Form1.Canvas.FillRect(Rect(0,0,100,100));
finally
Form1.Canvas.Brush.Bitmap := nil;
Bitmap.Free;
end;
Graphics::TBitmap *Bitmap = new Graphics::TBitmap();
try {
Bitmap->LoadFromFile( "..\\MyFile.bmp" );
Form1->Canvas->Brush->Bitmap = Bitmap;
Form1->Canvas->FillRect( Rect(0,0,100,100) );
} __finally {
Form1->Canvas->Brush->Bitmap = NULL;
Bitmap->Free();
}
Remarque: Pour les projets C++, le code suppose que le répertoire de sortie cible est situé dans le répertoire du projet.

Conseil: Vous pouvez modifier la taille du rectangle à afficher en ajustant les valeurs du paramètre Rect.

3. Pour Delphi, ajoutez la déclaration de variable suivante dans le bloc var :

Bitmap : TBitmap;

124
2.5 Procédures VCL RAD Studio Affichage d'une image bitmap plein écran

Pour exécuter le programme

1. Sélectionnez Exécuter Exécuter.
2. Cliquez sur le bouton pour afficher l'image bitmap dans un rectangle de 100 x 100 pixels dans le coin supérieur gauche de la
fiche.
Voir aussi
Présentation de la VCL ( see page 46)

Dessin de lignes droites dans une application VCL ( see page 128)

Dessin de rectangles et d'ellipses dans une application VCL ( see page 127)

Dessin d'un polygone dans une application VCL ( see page 126)

Insertion d'une image bitmap dans une boîte à options d'une application VCL ( see page 144)

2.5.24 Affichage d'une image bitmap plein écran dans une

application Fiches VCL
Cette procédure charge une image bitmap à partir d'un fichier et l'affiche dans son intégralité sur une fiche VCL. Elle utilise les
propriétés Height et Width de l'objet Bitmap pour afficher une vue complète de l'image.

1. Créer une fiche VCL avec un contrôle bouton.

2. Fournir une image bitmap. 2
3. Coder le gestionnaire d'événement onClick du bouton pour charger et afficher une image bitmap.
4. Construire et exécuter l'application.

Pour créer une fiche VCL et un bouton

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Standard de la palette d'outils, placez un composant bouton sur la fiche.
3. Dans l'inspecteur d'objets, entrez "Vue complète" pour la propriété Caption et FullView pour la propriété Name.

Pour fournir une image bitmap

1. Créez un répertoire dans lequel stocker les fichiers de votre projet.
2. Localisez une image bitmap sur votre disque local, puis copiez-la dans le répertoire de votre projet.
3. Enregistrez tous les fichiers du projet dans le répertoire de votre projet.

Pour écrire le gestionnaire d'événement OnClick

1. Dans l'inspecteur d'objets, double-cliquez sur l'événement Button1 OnClick de l'onglet Evénements. L'éditeur de code
s'affiche, avec le curseur placé dans le bloc du gestionnaire de l'événement TForm1.FullViewClick (Delphi) ou
TForm1::FullViewClick (C++).
2. Entrez le code de gestion d'événement suivant, en remplaçant MyFile.bmp par le nom de l'image bitmap du répertoire de
votre projet :
Bitmap := TBitmap.Create;
try
Bitmap.LoadFromFile('MyFile.bmp');
Form1.Canvas.Brush.Bitmap := Bitmap;

125
 Dessin d'un polygone dans une application RAD Studio 2.5 Procédures VCL

Form1.Canvas.FillRect(Rect(0,0,Bitmap.Width,Bitmap.Height));
finally
Form1.Canvas.Brush.Bitmap := nil;
Bitmap.Free;
end;
Graphics::TBitmap Bitmap = new Graphics::TBitmap();
try {
Bitmap->LoadFromFile( "..\\MyFile.bmp" );
Form1–>Canvas->Brush->Bitmap = Bitmap;
Form1–>Canvas->FillRect(
Rect( 0, 0, Bitmap->Width, Bitmap->Height ) );
} __finally {
Form1–>Canvas->Brush->Bitmap = NULL;
Bitmap->Free();
}
Remarque: Pour les projets C++, le code suppose que le répertoire de sortie cible est situé dans le répertoire du projet.

3. Pour Delphi, ajoutez la déclaration de variable suivante dans le bloc var :

Bitmap : TBitmap;s

Pour exécuter le programme

1. Choisissez Exécuter Exécuter.
2. Cliquez sur le bouton pour afficher l'image bitmap dans un rectangle dans le coin supérieur gauche de la fiche.
Voir aussi
Présentation de la VCL ( see page 46)

Dessin de lignes droites dans une application Fiches VCL ( see page 128)

Affichage d'une image bitmap dans une application Fiches VCL ( see page 124)
2
Dessin de rectangles et d'ellipses dans une application Fiches VCL ( see page 127)

Dessin d'un polygone dans une application Fiches VCL ( see page 126)

Insertion d'une image bitmap dans une boîte à options d'une application Fiches VCL ( see page 144)

2.5.25 Dessin d'un polygone dans une application Fiches

VCL
Cette procédure dessine un polygone dans une fiche VCL.

1. Créer une fiche VCL.

2. Coder le gestionnaire d'événement OnPaint de la fiche pour dessiner un polygone.
3. Construire et exécuter l'application.

Pour créer une fiche VCL

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Dans la vue fiche, cliquez sur la fiche, si nécessaire, pour afficher Form1 dans l'inspecteur d'objets.

Pour écrire le gestionnaire d'événement OnPaint

1. Dans l'inspecteur d'objets, cliquez sur l'onglet Evénements.

126
2.5 Procédures VCL RAD Studio Dessin de rectangles et d'ellipses dans une

2. Double-cliquez sur l'événement OnPaint. L'éditeur de code s'affiche, avec le curseur placé dans le bloc du gestionnaire de
l'événement TForm1.FormPaint (Delphi) ou TForm1::FormPaint (C++).
3. Entrez le code de gestion d'événement suivant :
Canvas.Polygon ([Point(0,0), Point(0, ClientHeight),
Point(ClientWidth, ClientHeight)]);
TPoint points[] = { Point(0,0),
Point(0, ClientHeight),
Point(ClientWidth, ClientHeight) };
Canvas->Polygon( points, 3 );

Pour exécuter le programme

1. Sélectionnez Exécuter Exécuter.
2. L'application s'exécute, en affichant un triangle droit dans la moitié inférieure gauche de la fiche.
Voir aussi
Présentation de la VCL ( see page 46)

Dessin de lignes droites dans une application Fiches VCL ( see page 128)

Dessin de rectangles et d'ellipses dans une application Fiches VCL ( see page 127)

Affichage d'une image bitmap dans une application Fiches VCL ( see page 124)

2.5.26 Dessin de rectangles et d'ellipses dans une

application Fiches VCL 2
Cette procédure dessine un rectangle et une ellipse dans une fiche VCL.

1. Créer une fiche VCL.

2. Coder le gestionnaire d'événement OnPaint de la fiche pour dessiner un rectangle et une ellipse.
3. Construire et exécuter l'application.

Pour créer une fiche VCL et y placer une image

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Dans la vue fiche, cliquez sur la fiche, si nécessaire, pour afficher Form1 dans l'inspecteur d'objets.

Pour écrire le gestionnaire d'événement OnPaint

1. Dans l'inspecteur d'objets, double-cliquez sur l'événement Form1 OnPaint de l'onglet Evénements. L'éditeur de code
s'affiche, avec le curseur placé dans le bloc du gestionnaire de l'événement TForm1.FormPaint (Delphi) ou
TForm1::FormPaint (C++).
2. Entrez le code de gestion d'événement suivant :
Canvas.Rectangle (0, 0, ClientWidth div 2, ClientHeight div 2);
Canvas.Ellipse (0, 0, ClientWidth div 2, ClientHeight div 2);
Canvas->Rectangle( 0, 0, ClientWidth / 2, ClientHeight / 2 );
Canvas->Ellipse( 0, 0, ClientWidth / 2, ClientHeight / 2 );

Pour exécuter le programme

1. Choisissez Exécuter Exécuter.
2. L'application s'exécute et affiche un rectangle et une ellipse dans le quart supérieur gauche de la fiche.

127
 Dessin de lignes droites dans une RAD Studio 2.5 Procédures VCL

Voir aussi
Présentation de la VCL ( see page 46)

Dessin d'un polygone dans une application Fiches VCL ( see page 126)

Affichage d'une image bitmap dans une application Fiches VCL ( see page 124)

2.5.27 Dessin d'un rectangle arrondi dans une application

Fiches VCL
Cette procédure dessine un rectangle arrondi dans une fiche VCL.

1. Créer une fiche VCL et coder le gestionnaire d'événement OnPaint de la fiche.

2. Construire et exécuter l'application.

Pour créer une fiche VCL

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Dans l'inspecteur d'objets, cliquez sur l'onglet Evénements.
3. Double-cliquez sur l'événement OnPaint. L'éditeur de code s'affiche, avec le curseur placé dans le bloc du gestionnaire de
l'événement TForm1.FormPaint (Delphi) ou TForm1::FormPaint (C++).
4. Entrez le code de gestion d'événement suivant :
2
Canvas.RoundRect(0, 0, ClientWidth div 2,
ClientHeight div 2, 10, 10);
Canvas->RoundRect( 0, 0, ClientWidth / 2, ClientHeight / 2, 10, 10 );

Pour exécuter le programme

1. Enregistrez tous les fichiers de votre projet, puis choisissez Exécuter Exécuter.
2. L'application s'exécute et affiche un rectangle arrondi dans le quart supérieur gauche de la fiche.
Voir aussi
Présentation de la VCL ( see page 46)

Dessin de rectangles et d'ellipses dans une application Fiches VCL ( see page 127)

2.5.28 Dessin de lignes droites dans une application Fiches

VCL
Cette procédure dessine deux diagonales droites sur une image dans une fiche VCL.

1. Créer une fiche VCL.

2. Coder le gestionnaire d'événement OnPaint de la fiche pour dessiner les lignes droites.
3. Construire et exécuter l'application.

128
2.5 Procédures VCL RAD Studio Création dynamique d'une fiche VCL

Pour créer une fiche VCL et y placer une image

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Dans la vue fiche, cliquez sur la fiche, si nécessaire, pour afficher Form1 dans l'inspecteur d'objets.

Pour écrire le gestionnaire d'événement OnPaint

1. Dans l'inspecteur d'objets, double-cliquez sur l'événement Form1 OnPaint de l'onglet Evénements. L'éditeur de code
s'affiche, avec le curseur placé dans le bloc du gestionnaire d'événement TForm1.FormPaint.
2. Entrez le code de gestion d'événement suivant :
with Canvas do
begin
MoveTo(0,0);
LineTo(ClientWidth, ClientHeight);
MoveTo(0, ClientHeight);
LineTo(ClientWidth, 0);
end;
Canvas->MoveTo( 0, 0 );
Canvas->LineTo( ClientWidth, ClientHeight );
Canvas->MoveTo( 0, ClientHeight );
Canvas->LineTo( ClientWidth, 0 );

Pour exécuter le programme

1. Choisissez Exécuter Exécuter.
2. L'application s'exécute et affiche une fiche avec deux diagonales.
Conseil: Pour que le crayon devienne vert, insérez l'instruction suivante après la première instruction MoveTo() dans le
code du gestionnaire d'événement : Pen.Color := clGreen; (Delphi) Canvas->Pen->Color = clGreen; (C++). 2
Essayez d'utiliser d'autres propriétés des objets canevas et crayon. Voir "Utilisation des propriétés de l'objet canevas" dans le
guide du développeur de Delphi 7.

Voir aussi
Présentation de la VCL ( see page 46)

Construction d'applications Fiches VCL avec graphiques ( see page 101)

Dessin de rectangles et d'ellipses dans une application Fiches VCL ( see page 127)

Dessin d'un polygone dans une application Fiches VCL ( see page 126)

Affichage d'une image bitmap dans une application Fiches VCL ( see page 124)

2.5.29 Création dynamique d'une fiche VCL modale

Toutes les fiches de votre application n'ont pas besoin d'être en mémoire simultanément. Pour réduire la quantité de mémoire
requise au moment du chargement, votre application peut créer des fiches uniquement lorsqu'elles doivent être disponibles pour
être utilisées. Une boîte de dialogue, par exemple, n'a besoin d'être en mémoire que pendant le temps où l'utilisateur interagit
avec elle. En utilisant RAD Studio, la procédure suivante crée une instance de fiche modale dynamiquement. La principale
différence entre la création dynamique d'une fiche et l'affichage d'une fiche VCL créée automatiquement réside dans le fait que
vous supprimez l'appel de la deuxième fiche au démarrage et écrivez du code pour créer dynamiquement la fiche.

La construction de cette application VCL comprend les étapes suivantes :

129
 Création dynamique d'une fiche VCL RAD Studio 2.5 Procédures VCL

1. Créer le répertoire projet.

2. Créer deux fiches pour le projet.
3. Retirer l'appel de la deuxième fiche au démarrage.
4. Lier les fiches.
5. Créer un contrôle sur la fiche principale pour créer et afficher la fiche modale, puis écrire le gestionnaire d'événement.
6. Construire et exécuter l'application.

Pour créer les deux fiches

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL affiche Form1.
2. Choisissez Fichier Nouveau Autre Projets Delphi Fichiers Delphi ou Fichier Nouveau Autre Fichiers
C++Builder, puis double-cliquez sur l'icône Fiche. Le concepteur de fiches VCL affiche Form2.

Pour retirer l'appel de Form2 au démarrage

1. Choisissez Projet Options Fiches. La boîte de dialogue Options du projet s'affiche.
2. Sélectionnez Form2 dans la liste Fiches créées automatiquement et cliquez sur [>]. Form2 est déplacée dans la liste
Fiches disponibles.
3. Cliquez sur OK pour fermer la boîte de dialogue.

Pour lier Form1 à Form2

1. Pour Delphi, sélectionnez Form1 et choisissez Fichier Utiliser l'unité. Pour C++, sélectionnez Form1 et choisissez
Fichier Inclure l'en-tête d'unité. La boîte de dialogue Utiliser l'unité s'affiche.
2. Sélectionnez Form2 (la fiche nécessaire à Form1 comme référence) dans la boîte de dialogue.
2
3. Cliquez sur OK. Pour Delphi, une clause uses contenant le nom de l'unité Unit2 est placée dans la section implementation de
Unit1. Pour C++, la directive #include "Unit2.h" est ajoutée à Unit1.h.

Pour afficher Form2 à partir de Form1

1. Sélectionnez Form1, si nécessaire, puis, dans la page Standard de la palette d'outils, placez un TButton sur la fiche.
2. Dans l'inspecteur d'objets avec Button1 sélectionné, double-cliquez sur l'événement OnClick de l'onglet Evénements.
L'éditeur de code s'affiche, le curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi)
ou TForm1::Button1Click (C++).
3. Entrez le code de gestion d'événement suivant :
Form2 := TForm2.Create(self);
try
Form2.ShowModal;
finally
Form2.Free;
end;
Form2 = new TForm2( this );
try {
Form2–>ShowModal();
} __finally {
Form2–>Free();
}

Pour construire et exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter. L'application s'exécute, en affichant Form1.
2. Cliquez sur le bouton. Form2 s'affiche.
3. Cliquez sur le X dans le coin supérieur droit de la fiche. Form2 se ferme et Form1 devient la fiche active.

130
2.5 Procédures VCL RAD Studio Création dynamique d'une fiche VCL non

Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

Création dynamique d'une fiche VCL non modale ( see page 131)

Affichage d'une fiche VCL créée automatiquement ( see page 122)

2.5.30 Création dynamique d'une fiche VCL non modale

Une fiche non modale est une fenêtre qui s'affiche jusqu'à ce qu'elle soit masquée par une autre fenêtre ou jusqu'à sa fermeture
ou sa réduction par l'utilisateur. Avec RAD Studio, la procédure suivante crée une fiche non modale dynamiquement.

La construction de cette application VCL comprend les étapes suivantes :

1. Créer le répertoire projet.

2. Créer deux fiches pour le projet.
3. Retirer l'appel de la deuxième fiche au démarrage.
4. Lier les fiches.
5. Créer un contrôle sur la fiche principale pour créer et afficher la fiche modale, puis écrire le gestionnaire d'événement.
6. Construire et exécuter l'application.

Pour créer les deux fiches 2

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL affiche Form1.
2. Choisissez Fichier Nouveau Autre Projets Delphi Fichiers Delphi ou Fichier Nouveau Autre Fichiers
C++Builder, puis double-cliquez sur l'icône Fiche. Le concepteur de fiches VCL affiche Form2.

Pour retirer l'appel de Form2 au démarrage

1. Choisissez Projet Options. La boîte de dialogue Options du projet s'affiche.
2. Sélectionnez Form2 dans la liste Fiches créées automatiquement et cliquez sur [>]. Form2 est déplacée dans la liste
Fiches disponibles.
3. Cliquez sur OK pour fermer la boîte de dialogue.

Pour lier Form1 à Form2

1. Pour Delphi, sélectionnez Form1 et choisissez Fichier Utiliser l'unité. Pour C++, sélectionnez Form1 et choisissez
Fichier Inclure l'en-tête d'unité. La boîte de dialogue Utiliser l'unité s'affiche.
2. Sélectionnez Form2 (la fiche nécessaire à Form1 comme référence) dans la boîte de dialogue.
3. Cliquez sur OK. Pour Delphi, une clause uses contenant le nom de l'unité Unit2 est placée dans la section implementation de
Unit1. Pour C++, la directive #include "Unit2.h" est ajoutée à Unit1.h.

Pour afficher Form2 à partir de Form1

1. Sélectionnez Form1, si nécessaire, puis, dans la page Standard de la palette d'outils, placez un bouton sur la fiche.
2. Dans l'inspecteur d'objets avec Button1 sélectionné, double-cliquez sur l'événement OnClick de l'onglet Evénements.
L'éditeur de code s'affiche, le curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi)
ou TForm1::Button1Click (C++).

131
 Parcours des chaînes d'une liste RAD Studio 2.5 Procédures VCL

3. Entrez le code de gestion d'événement suivant :

Form2 := TForm2.Create(self);
Form2.Show;
Form2 = new TForm2( this );
Form2–>Show();
Remarque: Si votre application a besoin d'autres instances de la fiche non modale, déclarez une variable globale distincte pour
chaque instance. Le plus souvent, vous utiliserez la référence globale qui a été créée lorsque vous avez réalisé la fiche (le nom
de variable qui correspond à la valeur de la propriété Name de la fiche).

Pour construire et exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter. L'application s'exécute, en affichant Form1.
2. Cliquez sur le bouton. Form2 s'affiche.
3. Cliquez sur Form1. Form1 devient la fiche active. Form2 est affichée jusqu'à sa réduction ou sa fermeture.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

Affichage d'une fiche VCL créée automatiquement ( see page 122)

Création dynamique d'une fiche VCL modale ( see page 129)

2.5.31 Parcours des chaînes d'une liste

2
Cette application VCL crée d'abord une liste de chaînes. Elle parcourt ensuite les chaînes, en transformant tous les caractères
de chaînes en majuscule. Elle est constituée des étapes suivantes :

1. Créer une fiche VCL avec des boutons et des contrôles TListBox.
2. Ecrire du code pour créer une liste de chaînes et ajouter des chaînes à cette liste.
3. Ecrire du code pour parcourir la liste de chaînes afin de traiter les caractères des chaînes.
4. Exécuter l'application.

Pour créer une fiche VCL avec des contrôles TButton et TListBox
1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. A partir de la page Standard de la palette d'outils, placez deux composants TButtons et un composant TListBox sur la fiche.
3. Sélectionnez Button1 sur la fiche.
4. Dans l'inspecteur d'objets, entrez Ajouter pour les propriétés Caption et Name.
5. Sélectionnez Button2 sur la fiche.
6. Dans l'inspecteur d'objets, entrez ToUpper pour les propriétés Caption et Name.

Pour créer une liste de chaînes et ajouter des chaînes à cette liste
1. Sélectionnez le bouton Ajouter sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.AddClick (Delphi) ou TForm1::AddClick (C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une

132
2.5 Procédures VCL RAD Studio Parcours des chaînes d'une liste

nouvelle ligne au-dessus du bloc de code.

4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez la déclaration de variable suivante :
var
MyList: TStringList;
5. Placez le curseur dans le bloc de code, puis tapez le code suivant :
MyList := TStringList.Create;
try
with MyList do
begin
Add('Souris');
Add('Chèvres');
Add('Eléphants');
Add('Oiseaux');
ListBox1.Items.AddStrings(MyList);
end;
finally
MyList.Free;
end;
TStringList *MyList = new TStringList();
try {
MyList->Add( "Souris" );
MyList->Add( "Chèvres" );
MyList->Add( "Eléphants" );
MyList->Add( "Oiseaux" );
ListBox1–>Items->AddStrings( MyList );
} __finally {
MyList->Free();
}

Pour transformer tous les caractères en majuscules

2
1. Sélectionnez le bouton ToUpper sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.ToUpperClick (Delphi) ou TForm1::ToUpperClick
(C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une nouvelle
ligne au-dessus du bloc de code.
4. Pour Delphi, placez le curseur sur la nouvelle ligne créée, puis tapez la déclaration de variable suivante :
var
Index: Integer;
5. Placez le curseur dans le bloc de code, puis tapez le code suivant :
for Index := 0 to ListBox1.Items.Count - 1 do
ListBox1.Items[Index] := UpperCase(ListBox1.Items[Index]);
for( int i = 0; i < ListBox1–>Items->Count; i++ ) {
ListBox1–>Items[i] = UpperCase( ListBox1–>Items[i] );
}

Pour exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche
apparaît avec les contrôles.
2. Cliquez sur le bouton Ajouter. Les chaînes 'Souris', 'Chèvres', 'Eléphants' et 'Oiseaux' s'affichent dans l'ordre indiqué.
3. Cliquez sur le bouton ToUpper. Les caractères de la chaîne sont affichés en majuscules.
Voir aussi
Présentation de la VCL ( see page 46)

133
 Eviter les accès de threads simultanés RAD Studio 2.5 Procédures VCL

Construction d'une application Fiches VCL ( see page 108)

2.5.32 Construction d'une application multithread

Voici les étapes essentielles de construction d'une application Fiches VCL multithread avec un objet thread en utilisant RAD
Studio.

Pour placer un composant sur une fiche

1. Créer une fiche VCL avec un objet thread défini.
2. Initialiser le thread (facultatif).
3. Ecrire la fonction thread.
4. Ecrire le code de nettoyage (facultatif).
Voir aussi
Présentation de la VCL ( see page 46)

Définition d'un objet thread ( see page 136)

Initialisation d'un thread ( see page 139)

Ecriture de la fonction Thread ( see page 144)

Ecriture du code de nettoyage ( see page 134)

2.5.33 Ecriture du code de nettoyage

Pour nettoyer un thread quand son exécution est terminée
1. Centralisez le code de nettoyage en le plaçant dans le gestionnaire d'événement OnTerminate. Vous êtes ainsi certain que le
code s'exécutera.
2. N'utilisez pas de variables locales de thread, car OnTerminate ne s'exécute pas dans le cadre de votre thread.
3. Vous pouvez accéder en toute sécurité à tous les objets du gestionnaire OnTerminate.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application multithread ( see page 134)

2.5.34 Eviter les accès de threads simultanés dans la même

mémoire
Utilisez ces techniques de base pour empêcher les autres threads d'accéder à la même mémoire que votre thread :

1. Verrouiller les objets.

2. Utiliser les sections critiques.

134
2.5 Procédures VCL RAD Studio Définition de l'objet thread

3. Utiliser le synchronisateur à écriture exclusive et lecture multiple.

Pour verrouiller des objets

1. Pour les objets tels que les canevas qui possèdent une méthode Lock, appelez la méthode Lock, si nécessaire, pour
empêcher d'autres objets d'accéder à cet objet, et appelez Unlock quand le verrouillage n'est plus nécessaire.
2. Appelez TThreadList.LockList (Delphi) ou TThreadList::LockList() (C++) pour empêcher des threads d'utiliser
l'objet liste TThreadList, et appelez TThreadList.UnlockList quand le verrouillage n'est plus nécessaire.
Remarque: Vous pouvez appeler en toute sécurité TCanvas.Lock et TThreadList.LockList.

Pour utiliser une section critique

1. Créez une instance globale de TCriticalSection.
2. Appelez la méthode Acquire pour verrouiller les autres threads pendant l'accès à la mémoire globale.
3. Appelez la méthode Release pour que les autres threads puissent accéder à la mémoire en appelant Acquire. Le code
suivant a une section critique des variables globales, LockXY, qui bloque l'accès aux variables globales X et Y. Tout thread
utilisant X ou Y doit encadrer cette utilisation d'appels à la section critique comme ci-dessous :
LockXY.Acquire;
try
X := X + 1;
Y := sin(X);
finally
LockXY.Release
end;
LockXY->Acquire();
try {
x++;
y = sin( x ); 2
} __finally {
LockXY->Release();
}
Avertissement: Les sections critiques ne peuvent fonctionner que si tous les threads les utilisent pour accéder à la mémoire
globale. Sinon, des problèmes d'accès simultané peuvent se produire.

Pour utiliser le synchronisateur à écriture exclusive et lecture multiple

1. Créez une instance globale de TMultiReadExclusiveWriteSynchronizer associée à la mémoire globale que vous
souhaitez protéger.
2. Pour qu'un thread puisse lire la mémoire, il doit appeler BeginRead.
3. Une fois l'opération de lecture de la mémoire achevée, le thread doit appeler EndRead.
4. Pour qu'un thread puisse écrire dans la mémoire, il doit appeler BeginWrite.
5. Une fois l'opération d'écriture achevée, le thread doit appeler EndWrite.
Avertissement: Le synchronisateur à écriture exclusive et à lecture multiple ne fonctionne que si chaque thread l'utilise pour
accéder à la mémoire globale associée. Sinon, des problèmes d'accès simultané peuvent se produire.
Voir aussi
Présentation de la VCL ( see page 46)

Ecriture de la fonction Thread ( see page 144)

Utilisation du thread VCL principal ( see page 140)

Attente des threads ( see page 142)

Gestion des exceptions ( see page 139)

135
 Définition de l'objet thread RAD Studio 2.5 Procédures VCL

2.5.35 Définition de l'objet thread

Pour définir l'objet thread
1. Choisissez Fichier Nouveau Autre Projets Delphi Fichiers Delphi ou Fichier Nouveau Autre Fichiers
C++Builder, puis double-cliquez sur l'icône Objet Thread. La boîte de dialogue Nouvel objet Thread apparaît.
2. Entrez un nom de classe, par exemple TMyThread.
3. Vous pouvez éventuellement cocher la case Thread nommé et spécifier un nom de thread, par exemple MyThreadName.
Conseil: Le fait d'entrer un nom pour Thread nommé facilite le suivi du thread pendant le débogage.

4. Cliquez sur OK.

L'éditeur de code affiche le squelette du code pour l'objet thread.
Le code généré pour la nouvelle unité ressemblera à cela si vous avez nommé votre classe thread TMyThread.
unit Unit1;

interface

uses
Classes;

type
TMyThread = class(TThread)
private
2 { Déclarations privées }
protected
procedure Execute; override;
end;

implementation

{ Important : Les méthodes et les propriétés des objets dans les composants visuels peuvent
uniquement être
utilisées dans une méthode appelée en utilisant Synchronize, par exemple,

Synchronize(UpdateCaption);

et UpdateCaption pourra ressembler à

procedure TMyThread.UpdateCaption;
begin
Form1.Caption := 'Mis à jour dans un thread';
end; }

{ TMyThread }

procedure TMyThread.Execute;
begin
{ placer le code du thread ici }
end;

end.
L'ajout d'un nom pour le thread génère du code supplémentaire pour l'unité. Il inclut l'unité Windows, ajoute la procédure (Delphi)
ou la fonction (C++) SetName et ajoute l'enregistrement TThreadNameInfo (Delphi) ou la structure THREADNAME_INFO (C++).
Le nom est affecté au champ FName comme ci-dessous :

136
2.5 Procédures VCL RAD Studio Définition de l'objet thread

unit Unit1;

interface

uses
Classes {$IFDEF MSWINDOWS} , Windows {$ENDIF};

type
TMyThread = class(TThread)
private
procedure SetName;
protected
procedure Execute; override;
end;

implementation

{ Important : Les méthodes et les propriétés des objets dans les composants visuels peuvent
uniquement être
utilisées dans une méthode appelée en utilisant Synchronize, par exemple,

Synchronize(UpdateCaption);

et UpdateCaption pourra ressembler à

procedure TMyThread.UpdateCaption;
begin
Form1.Caption := 'Mis à jour dans un thread';
end; }

{$IFDEF MSWINDOWS}
type
TThreadNameInfo = record
FType: LongWord; // doit avoir la valeur 0x1000 2
FName: PChar; // pointeur sur le nom (dans l'espace adresse de l'utilisateur)
FThreadID: LongWord; // ID de thread (-1 indique le thread appelant)
FFlags: LongWord; // réservé à un usage ultérieur, doit être à zéro
end;
{$ENDIF}

{ TMyThread }

procedure TMyThread.SetName;
{$IFDEF MSWINDOWS}
var
ThreadNameInfo: TThreadNameInfo;
{$ENDIF}
begin
{$IFDEF MSWINDOWS}
ThreadNameInfo.FType := $1000;
ThreadNameInfo.FName := 'MyThreadName';
ThreadNameInfo.FThreadID := $FFFFFFFF;
ThreadNameInfo.FFlags := 0;

try
RaiseException( $406D1388, 0, sizeof(ThreadNameInfo) div sizeof(LongWord), @ThreadNameInfo
);
except
end;
{$ENDIF}
end;

procedure TMyThread.Execute;
begin
SetName;
{ placer le code du thread ici }

137
 Gestion des exceptions RAD Studio 2.5 Procédures VCL

end;

end.
// Unit1.h

#ifndef Unit1H
#define Unit1H
#include <Classes.hpp>
class TMyThread : public TThread
{
typedef struct tagTHREADNAME_INFO
{
DWORD dwType;
LPCSTR szName;
DWORD dwThreadID;
DWORD dwFlags;
} THREADNAME_INFO;
private:
void SetName();
protected:
void __fastcall Execute();
public:
__fastcall TMyThread(bool CreateSuspended);
};

#endif
// Unit1.cpp
#include "Unit3.h"
#pragma package(smart_init)

__fastcall TMyThread::TMyThread(bool CreateSuspended)

: TThread(CreateSuspended)
{
2 }

void TMyThread::SetName()
{
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = "TMyThreadName";
info.dwThreadID = -1;
info.dwFlags = 0;

__try
{
RaiseException( 0x406D1388, 0, sizeof(info)/sizeof(DWORD),(DWORD*)&info; );
}
__except (EXCEPTION_CONTINUE_EXECUTION)
{
}
}

void __fastcall TMyThread::Execute()

{
SetName();
// ---- Placez le code du thread ici ----
}
Voir aussi
Présentation de la VCL ( see page 46)

Initialisation du thread ( see page 139)

Ecriture de la fonction Thread ( see page 144)

Ecriture du code de nettoyage ( see page 134)

138
2.5 Procédures VCL RAD Studio Initialisation d'un thread

2.5.36 Gestion des exceptions

Pour gérer les exceptions dans la fonction thread
1. Ajoutez un bloc try...except à l'implémentation de votre méthode Execute.
2. Codez la logique comme suit :
procedure TMyThreadExecute;
begin
try
while not Terminated do
PerformSomeTask;
except
{ faire quelque chose avec les exceptions }
end;
end;
void __fastcall TMyThread::Execute() {
try {
while( !Terminated() ) {
// exécuter des tâches
}
} catch(...) { // catch des exceptions spécifiques d'abord
// code de gestion d'exception
}
}
Voir aussi
Présentation de la VCL ( see page 46)
2
Ecriture de la fonction Thread ( see page 144)

Utilisation du thread VCL principal ( see page 140)

Eviter les accès de threads simultanés dans la même mémoire ( see page 134)

Attente des threads ( see page 142)

2.5.37 Initialisation d'un thread

Pour initialiser un objet thread
1. Affectez une priorité par défaut.
2. Indiquez le moment auquel le thread est libéré.

Pour affecter une priorité par défaut

1. Affectez une priorité par défaut au thread à partir des valeurs du tableau ci-dessous. Utilisez une priorité élevée pour gérer les
tâches critiques et une priorité basse pour les autres tâches.

Valeur Priorité
tpIdle Le thread s'exécute seulement quand le système est en attente. Windows n'interrompt pas les autres
threads pour exécuter un thread de priorité tpIdle.
tpLowest La priorité du thread est deux points en dessous de la normale.
tpLower La priorité du thread est un point en dessous de la normale.

139
 Utilisation du thread VCL principal RAD Studio 2.5 Procédures VCL

tpNormal La priorité du thread est normale.

tpHigher La priorité du thread est un point au dessus de la normale
tpHighest La priorité du thread est deux points au dessus de la normale.
tpTimeCritical Le thread a la priorité la plus élevée.

2. Redéfinissez la méthode Create (Delphi) ou le constructeur par défaut (C++) de la classe thread en ajoutant un nouveau
constructeur à la déclaration.
3. Codez le constructeur. Voici l'exemple d'un thread à basse priorité :
constructor TMyThread.Create(CreateSuspended: Boolean);
begin
inherited Create(CreateSuspended);
Priority := tpIdle;
end;
TMyThread::TMyThread( bool CreateSuspended ) : TThread( CreateSuspended ) {
Priority = tpIdle;
}
4. Indiquez si le thread doit être automatiquement libéré quand son exécution est terminée.
Avertissement: "Gonfler" la priorité du thread pour une opération utilisant intensivement la CPU peut "sous-alimenter" les
autres threads de l'application. Il ne faut accorder une priorité élevée qu'à des threads qui passent l'essentiel du temps à
attendre des événements extérieurs.

Pour indiquer le moment auquel un thread est libéré

1. Attribuez la valeur true à la propriété FreeOnTerminate, sauf si le thread doit être coordonné avec d'autres threads.
2. Si le thread doit être coordonné avec un autre thread, initialisez FreeOnTerminate à false, puis libérez explicitement le
2 premier thread du second.
Voir aussi
Présentation de la VCL ( see page 46)

Définition d'un objet thread ( see page 136)

Ecriture de la fonction Thread ( see page 144)

Ecriture du code de nettoyage ( see page 134)

2.5.38 Utilisation du thread VCL principal

L'utilisation du thread VCL principal comprend les étapes suivantes :

1. Créer une routine distincte pour gérer les messages Windows reçus par les composants de votre application.
2. Appeler régulièrement CheckSynchronize.
3. Déclarer, si nécessaire, des variables locales aux threads pour une utilisation exclusive par votre thread.

Pour créer une routine distincte

1. Ecrivez une routine de thread principal qui gère l'accès aux propriétés des objets et l'exécution des méthodes de tous les
objets de votre application.
2. Appelez la routine en utilisant la méthode TThread.Synchronize (Delphi) ou TThread::Synchronize. Le code suivant
illustre un exemple de l'appel d'une méthode en utilisant Synchronize :
procedure TMyThread.PushTheButton

140
2.5 Procédures VCL RAD Studio Attente des threads

begin
Button1.Click;
end;
procedure TMyThread.Execute;
begin
...
Synchronize(PushThebutton);
...
end;
void TMyThread::PushTheButton() { Form1–>Button1–>Click(); }
void __fastcall TMyThread::Execute() {
...
Synchronize( (TThreadMethod)&PushTheButton );
...
}
Synchronize attend le thread principal pour entrer dans la boucle des messages puis exécute la méthode qui lui est transmise.

Remarque: Comme Synchronize utilise une boucle de messages, elle ne fonctionne pas dans les applications console. Pour
les applications consoles, utilisez d'autres mécanismes, comme les sections critiques, pour protéger l'accès aux objets VCL.

Pour appeler CheckSynchronize

1. Appelez régulièrement CheckSynchronize depuis le thread principal pour que les threads d'arrière-plan synchronisent leur
exécution avec le thread principal.
2. Pour garantir la sécurité des appels aux threads d'arrière-plan, appelez CheckSynchronize lorsque l'application est inactive
(par exemple, dans le gestionnaire de l'événement OnIdle).

Pour utiliser une variable locale au thread

1. Identifiez les variables que vous voulez rendre globales pour toutes les routines exécutées dans votre thread sans qu'elles ne
soient partagées par les autres instances de la même classe de thread.
2
2. Pour Delphi, déclarez ces variables dans une section threadvar, par exemple,
threadvar
x: integer;
Dans C++, déclarez ces variables avec le modificateur __thread :
int __thread x;
Remarque: La section threadvar

ne peut être utilisée que pour des variables globales. Ne l'utilisez pas pour les variables Pointer et Function ou les types qui
utilisent une sémantique de copie-sur-écriture, comme les chaînes longues.

Remarque: Pour C++, si vous initialisez une variable __thread

, vous devez l'initialiser par une expression constante. Par exemple, int __thread foo = 3; est une instruction correcte
mais int __thread foo = get_value(); est interdit car l'initialisation se produit au moment de l'exécution.

Voir aussi
Présentation de la VCL ( see page 46)

Ecriture de la fonction Thread ( see page 144)

Eviter les accès de threads simultanés dans la même mémoire ( see page 134)

Attente des threads ( see page 142)

Gestion des exceptions ( see page 139)

141
 Attente des threads RAD Studio 2.5 Procédures VCL

2.5.39 Attente des threads

Voici les procédures qui peuvent être utilisées pour attendre les threads.

• Attendre la fin d'exécution d'un thread

• Attendre l'achèvement d'une tâche
• Vérifier si un autre thread attend la fin de votre thread

Pour attendre la fin d'exécution d'un thread

1. Utilisez la méthode WaitFor de l'autre thread.
2. Codez votre logique. Par exemple, le code suivant attend qu'un autre thread remplisse un objet liste de threads avant
d'accéder aux objets de la liste :
if ListFillingThread.WaitFor then
begin
with ThreadList1.LockList do
begin
for I := 0 to Count - 1 do
ProcessItem(Items[I];
end;
ThreadList1.UnlockList;
end;
if( ListFillingThread->WaitFor() ) {
TList* list = ThreadList1–>LockList();
for( int i = 0; i < list->Count; i++ ) {
DoSomething( list->Items[i] );
2 }
ThreadList1–>UnlockList();
}

Pour attendre l'achèvement d'une tâche

1. Créez un objet TEvent de portée globale.
2. Quand un thread termine une opération que d'autres threads attendent, il appelle TEvent.SetEvent.
3. Pour désactiver le signal, appelez TEvent.ResetEvent.
L'exemple suivant est un gestionnaire d'événement OnTerminate qui utilise un compteur global dans une section critique pour
mémoriser le nombre de threads terminés. Quand Counter atteint 0, le gestionnaire appelle la méthode SetEvent pour
signaler que tous les processus sont terminés :
procedure TDataModule.TaskTerminateThread(Sender: TObject);
begin
...
CounterGuard.Acquire; {obtient un verrou sur le compteur}
Dec(Counter); { décrémente la variable globale du compteur }
if Counter = 0 then
Event1.SetEvent; { signale s'il s'agit du dernier thread }
Counter.Release; {déverrouiller le compteur}
...
end;
void __fastcall TDataModule::TaskThreadTerminate( TObject *Sender ) {
...
CounterGuard->Acquire(); // verrouille le compteur
if( ––Counter == 0 ) // décrémente le compteur
Event1->SetEvent(); // signale si c'est le dernier thread
CounterGuard->Release(); // libère le verrouillage
}

142
2.5 Procédures VCL RAD Studio Ecriture de la fonction Thread

Le thread principal initialise la variable Counter, lance les threads de tâches et attend le signal indiquant l'achèvement de
l'exécution de tous les threads en appelant la méthode TEvent::WaitFor. WaitFor attend l'activation du signal pendant une
durée spécifiée et renvoie l'une des valeurs du tableau ci-dessous.

L'exemple de code suivant montre comment le thread principal lance les threads de tâches et reprend la main lorsque leur
exécution est achevée.
Event1.ResetEvent; {efface l'événement avant de lancer les threads}
for i := 1 to Counter do
TaskThread.Create(False); {crée et lance les threads de tâches}
if Event1.WaitFor(20000) <> wrSignaled then
raise Exception;
{poursuite avec le thread principal}
Event1–>ResetEvent(); // efface l'événement avant de lancer les threads
for( int i = 0; i < Counter; i++ ) {
new TaskThread( false );
if( Event1–>WaitFor(20000) != wrSignaled )
throw Exception;
// poursuite maintenant avec le thread principal
Remarque: Si vous ne voulez pas cesser d'attendre un gestionnaire d'événement après un délai spécifié, transmettez à la
méthode WaitFor une valeur de paramètre INFINITE. Faites attention en utilisant INFINITE, car cela peut provoquer le blocage
du thread si le signal attendu n'arrive pas.

Pour vérifier si un autre thread attend la fin de votre thread

1. Dans votre procédure Execute, implémentez la méthode Terminate en testant la valeur de la propriété Terminated.
2. Voici un moyen de coder la logique :
procedure TMyThread.Execute;
begin
while not Terminated do 2
PerformSomeTask;
end;
void __fastcall TMyThread::Execute() {
while( !Terminated )
DoSomething();
}
Valeurs renvoyées par WaitFor

Valeur Signification
wrSignaled Le signal de l'objet événement a été activé.
wrTimeout La durée spécifiée s'est écoulée sans que le signal soit défini.
wrAbandoned L'objet événement a été détruit avant l'écoulement de la période d'attente.
wrError Une erreur a eu lieu pendant l'attente.

Voir aussi
Présentation de la VCL ( see page 46)

Ecriture de la fonction Thread ( see page 144)

Utilisation du thread VCL principal ( see page 140)

Eviter les accès de threads simultanés dans la même mémoire ( see page 134)

Gestion des exceptions ( see page 139)

143
 Insertion d'une image bitmap dans un RAD Studio 2.5 Procédures VCL

2.5.40 Ecriture de la fonction Thread

La méthode Execute constitue la fonction thread. Vous pouvez la concevoir comme un programme qui est exécuté par
l'application, à cette différence près qu'il partage le même espace de processus. L'écriture d'une fonction thread est plus délicate
que celle d'un programme distinct car il faut prendre garde à ne pas écraser la mémoire utilisée par d'autres processus de
l'application. D'un autre côté, comme le thread partage le même espace de processus que les autres threads, il est possible
d'utiliser la mémoire partagée pour faire communiquer les threads.

Pour implémenter la méthode Execute, coordonnez l'exécution des threads en

1. Les synchronisant avec un thread VCL principal.
2. Evitant les accès simultanés à la même mémoire.
3. Attendant des threads.
4. Gérant les exceptions.
Voir aussi
Présentation de la VCL ( see page 46)

Utilisation du thread VCL principal ( see page 140)

Eviter les accès de threads simultanés dans la même mémoire ( see page 134)

Attente des threads ( see page 142)

Gestion des exceptions ( see page 139)

2

2.5.41 Insertion d'une image bitmap dans un contrôle d'une

application Fiches VCL
Cette procédure ajoute une image bitmap à une boîte à options d'une application Fiches VCL.

1. Créer une fiche VCL.

2. Ajouter des composants à la fiche.
3. Définir des propriétés des composants dans l'inspecteur d'objets.
4. Ecrire des gestionnaires d'événements pour l'action de dessin des composants.
5. Construire et exécuter l'application.

Pour créer une fiche VCL avec un composant TComboBox

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Win32 de la palette d'outils, placez un composant TImageList sur la fiche.
3. Sur la page Standard de la palette d'outils, placez un composant TComboBox sur la fiche.

Pour définir les propriétés d'un composant

1. Sélectionnez ComboBox1 sur la fiche.

144
2.5 Procédures VCL RAD Studio Lecture d'une chaîne et écriture de cette

2. Dans l'inspecteur d'objets, définissez la liste déroulante de la propriété Style à csOwnerDrawFixed.

3. Dans l'inspecteur d'objets, cliquez sur le bouton points de suspension à côté de la propriété Items. L'éditeur de liste de
chaînes s'affiche.
4. Entrez une chaîne à associer à l'image bitmap, par exemple MyImage, puis cliquez sur OK.
5. Double-cliquez sur ImageList1 dans la fiche. L'éditeur ImageList s'affiche.
6. Cliquez sur le bouton Ajouter pour afficher la boîte de dialogue d'ajout d'images.
7. Localisez une image bitmap à afficher dans la boîte à options. Pour localiser une image, vous pouvez rechercher les images
*.bmp sur votre disque local. Sélectionnez une très petite image comme une icône. Copiez-la dans le répertoire de votre
projet et cliquez sur Ouvrir. L'image s'affiche dans l'éditeur ImageList.
8. Cliquez sur OK pour fermer l'éditeur.

Pour ajouter le code du gestionnaire d'événement

1. Dans la vue Fiche VCL, sélectionnez ComboBox1.
2. Dans l'inspecteur d'objets, cliquez sur la page Evénements et double-cliquez sur l'événement OnDrawItem. L'éditeur de
code s'affiche, avec le curseur placé dans le bloc du gestionnaire de l'événement ComboBox1DrawItem (Delphi) ou
ComboBox1::DrawItem (C++).
3. Entrez le code suivant pour ce gestionnaire d'événement :
Combobox1.Canvas.FillRect(Rect);
ImageList1.Draw(ComboBox1.Canvas, Rect.Left, Rect.Top, Index);
Combobox1.Canvas.TextOut(Rect.Left+ImageList1.Width+2,
Rect.Top, ComboBox1.Items[Index]);
ComboBox1–>Canvas->FillRect( Rect );
ImageList1–>Draw( ComboBox1–>Canvas, Rect.Left, Rect.Top, Index );
ComboBox1–>Canvas->TextOut( Rect.Left + ImageList1–>Width + 2,
Rect.Top,
ComboBox1–>Items[Index] ); 2

Pour exécuter le programme

1. Choisissez Exécuter Exécuter. L'application s'exécute et affiche une fiche avec une boîte à options.
2. Cliquez sur la liste déroulante de la boîte à options. L'image bitmap et la chaîne de texte apparaissent en tant qu'élément de
la liste.
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'applications Fiches VCL avec graphiques ( see page 101)

2.5.42 Lecture d'une chaîne et écriture de cette chaîne dans

un fichier
La création de cette application VCL comprend les étapes suivantes :

1. Création d'une fiche VCL avec un contrôle bouton.

2. Ecriture du code pour lire la chaîne et l'écrire dans un fichier.
3. Exécuter l'application.

Pour créer une fiche VCL

1. Créez un répertoire dans lequel stocker les fichiers de votre projet.

145
 Renommage de fichiers RAD Studio 2.5 Procédures VCL

2. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
3. Sur la page Standard de la palette d'outils, placez un composant TButton sur la fiche.

Pour lire et écrire une chaîne

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi) ou TForm1::Button1Click
(C++).
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une nouvelle
ligne au-dessus du bloc de code.
4. Tapez les déclarations de variables suivantes :
TFileStream *fs const AnsiString str = "Bonjour";
5. Placez le curseur dans le bloc de code, puis tapez le code suivant :
fs = new TFileStream( "temp.txt", fmCreate );
fs->Write ((void*)str.c_str(), str.fmCreate);

Pour exécuter l'application "Hello world"

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche
apparaît avec un bouton appelé Button1.
2. Cliquez sur Button1.
3. Utilisez un éditeur de texte pour ouvrir le fichier nouvellement créé temp.txt, qui est localisé dans votre répertoire projet. La
chaîne 'Hello' apparaît dans le fichier.
2 Voir aussi
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

2.5.43 Renommage de fichiers

La création de cette application VCL comprend les étapes suivantes :

1. Créer un répertoire projet contenant un fichier à renommer.

2. Créer une fiche VCL avec des contrôles de boutons et de libellés.
3. Ecrire du code pour renommer le fichier.
4. Exécuter l'application.

Pour configurer votre répertoire projet et un fichier texte à copier

1. Créez un répertoire dans lequel stocker les fichiers de votre projet.
2. Créez ou copiez un fichier texte dans votre répertoire projet puis enregistrez-le sous le nom MyFile.txt.

Pour créer une fiche VCL avec un bouton et un libellé

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Standard de la palette d'outils, placez un composant TButton sur la fiche.

146
2.5 Procédures VCL RAD Studio Ajout et tri de chaînes

3. A partir de la page Standard de la palette d'outils, placez un composant TLabel sur la fiche.

Pour écrire la procédure de renommage de fichier

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TForm1.Button1Click (Delphi) ou TForm1::Button1Click
(C++).
3. Au niveau du curseur, tapez le code suivant :
if not RenameFile('MyFile.txt', 'YourFile.txt') then
Label1.Caption := 'Erreur de renommage du fichier!';
if( !RenameFile( "..\\MyFile.txt", "..\\YourFile.txt" )
Label1–>Caption = "Erreur de renommage du fichier";
// les paramètres fichier supposent que le répertoire de sortie cible est situé dans le
répertoire du projet
Remarque: Il n'est pas possible de renommer (déplacer) un fichier d'un lecteur vers un autre en utilisant RenameFile. Pour ce
faire, vous devez commencer par copier le fichier, puis supprimer le fichier original. Dans la bibliothèque d'exécution,
RenameFile est une enveloppe pour la fonction MoveFile de l'API Windows, et MoveFile ne fonctionne donc pas non plus d'un
lecteur à l'autre.

Pour exécuter l'application

1. Enregistrez le fichier projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche apparaît.
2. Cliquez sur le bouton. Si aucun message ne s'affiche dans le libellé, vérifiez le nom du fichier dans votre répertoire projet.
MyFile.txt devrait être renommé en YourFile.txt.
3. Si le libellé affiche le message d'erreur, revérifiez le code de votre gestionnaire d'événement.
Voir aussi 2
Présentation de la VCL ( see page 46)

Construction d'une application Fiches VCL ( see page 108)

2.5.44 Ajout et tri de chaînes

La création de cette application VCL comprend les étapes suivantes :

1. Créer une fiche VCL avec des contrôles Button, Label et TListBox.
2. Ecrire du code pour ajouter et trier des chaînes.
3. Exécuter l'application.

Pour créer une fiche VCL avec des contrôles de boutons, de libellés et de boîtes liste
1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Dans la catégorie Standard de la palette d'outils, placez un composant TButton, TLabel et TListBox sur la fiche.

Pour écrire la procédure de copie de flux

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, avec le
curseur placé dans le bloc du gestionnaire d'événement TForm1.Button1Click.
3. Pour Delphi, placez le curseur avant le mot réservé begin, puis appuyez sur la touche Entrée. Cette action crée une

147
 Création d'un bouton ActiveX Fiches VCL RAD Studio 2.5 Procédures VCL

nouvelle ligne au-dessus du bloc de code.

4. Tapez les déclarations de variables suivantes :
var
MyList: TStringList;
Index: Integer;
TStringList *MyList;
int Index;
5. Placez le curseur dans le bloc de code, puis tapez le code suivant :
MyList := TStringList.Create;
try
MyList.Add('Animaux');
MyList.Add('Fleurs');

MyList.Add('Voitures');

MyList.Sort;
if MyList.Find('Fleurs', Index) then
begin
ListBox1.Items.AddStrings(MyList);
Label1.Caption := 'Fleurs a une valeur d''indice de ' + IntToStr(Index);
end;
finally
MyList.Free;
end;
MyList = new TStringList();
try {
MyList->Add("Animaux");
MyList->Add("Fleurs");
MyList->Add( "Voitures" );
MyList->Sort();
2 if( MyList->Find( "Fleurs", Index ) {
ListBox1–>Items->AddStrings( MyList );
Label1–>Caption = "Fleurs a un indice de " +
IntToStr( Index );
}
} __finally {
MyList->Free();
}
Remarque: Find ne fonctionne que sur des listes triées. Utilisez IndexOf sur les listes non triées.

Pour exécuter l'application

1. Enregistrez tous les fichiers du projet, puis choisissez Exécuter Exécuter pour construire et exécuter l'application. La fiche
apparaît avec les contrôles.
2. Cliquez sur le composant Button. Les chaînes 'Animaux', 'Voitures' et 'Fleurs' s'affichent dans l'ordre alphabétique dans une
liste de la boîte liste. Le libellé affiche le message : 'Les fleurs ont l'indice 2.'
Voir aussi
Présentation de la VCL ( see page 46)

2.5.45 Création d'un bouton ActiveX Fiches VCL

Comme un contrôle Delphi, un contrôle ActiveX génère du code de programme lorsque vous placez le composant sur une fiche
ou un autre conteneur logique dans l'EDI. La principale différence entre un contrôle ActiveX et un contrôle Delphi réside dans le
fait qu'un contrôle ActiveX est indépendant du langage. Vous pouvez créer des contrôles ActiveX pour le déploiement vers
plusieurs environnements de programmation sous Windows, pas seulement Delphi ou C++Builder.

148
2.5 Procédures VCL RAD Studio Création d'un bouton ActiveX Fiches VCL

Cette procédure utilise l'expert ActiveX Fiches VCL pour créer un contrôle ActiveX. Pour tester le contrôle, vous pouvez l'installer
sur votre machine comme un composant VCL dans l'EDI. Pour installer le contrôle, vous devez d'abord lui créer un package.
Cette procédure est constituée des étapes majeures suivantes :

1. Créez un projet de bibliothèque ActiveX pour un contrôle de bouton ActiveX.

2. Recensez le bouton ActiveX pour que son icône puisse être affichée dans la barre d'outils.
3. Créez un package pour le bouton ActiveX.
4. Installez le package.
5. Testez le bouton ActiveX.

Pour créer un projet de bibliothèque ActiveX pour un contrôle de bouton ActiveX

1. Créez un répertoire sur votre disque local pour le projet ActiveX. Attribuez-lui un nom facile à trouver, par exemple ActiveX.
2. Choisissez Fichier Nouveau Autre et sélectionnez la page ActiveX dans la boîte de dialogue Nouveaux éléments.
3. Dans la page ActiveX, double-cliquez sur Contrôle ActiveX. L'expert Contrôle ActiveX apparaît.
4. Dans la liste déroulanteClasse VCL, sélectionnez TButton.
5. Par défaut, ButtonX s'affiche comme ActiveX. Renommez ButtonX en attribuant le nom que vous souhaitez afficher pour
votre bouton ActiveX, par exemple, MyActiveXButton.
Remarque: Les modifications apportées au nom mettent à jour l'unité d'implémentation et le nom du projet. Laissez les
autres champs aux valeurs par défaut.

6. Cliquez sur OK. L'expert génère le code nécessaire à l'implémentation du contrôle ActiveX et ajoute le code au projet. Si le
projet est déjà une bibliothèque ActiveX, l'expert ajoute le contrôle au projet en cours.
Remarque: Si le projet n'est pas encore une bibliothèque ActiveX, une boîte de dialogue Avertissement 2
s'affiche et vous demande si vous souhaitez démarrer un nouveau projet de bibliothèque ActiveX.
7. Cliquez sur OK pour démarrer le nouveau projet de bibliothèque ActiveX.

Pour recenser le bouton ActiveX

1. Construisez le projet et enregistrez tous les fichiers dans votre répertoire projet ActiveX. Faites disparaître l'avertissement sur
le débogage. Le projet construit et crée un fichier OCX dans votre répertoire projet.
2. Choisissez Exécuter Recenser le serveur ActiveX pour recenser le bouton ActiveX. Une boîte de dialogue affiche un
message indiquant que ce recensement a réussi et elle affiche le chemin du fichier OCX résultant.
3. Cliquez sur OK.

Pour créer un nouveau package pour le bouton ActiveX

1. Choisissez Fichier Nouveau Autre afin de créer un nouveau package. La boîte de dialogue Nouveaux éléments
apparaît.
2. Double-cliquez sur Package dans la page Nouveau pour afficher la boîte de dialogue Package - package.dpk et cliquez sur
Ajouter.
3. Sur l'onglet d'ajout d'unité de la boîte de dialogue d'ajout, naviguez jusqu'au répertoire projet.
4. Sélectionnez le fichier ButtonXControl1_TLB.pas et cliquez sur Ouvrir.
5. Cliquez sur OK pour ajouter le fichier au package et revenez à la boîte de dialogue Package - package.dpk. La boîte de
dialogue Package - package.dpk apparaît, en montrant les fichiers du package et deux fichiers nécessaires : rtl.dcp et
vcl.dcp.

Pour ajouter les fichiers nécessaires et installer le package

1. Dans la boîte de dialogue Package - package.dpk, sélectionnez rtl.dcp et cliquez sur Ajouter.

149
 Création d'une fiche active VCL ActiveX RAD Studio 2.5 Procédures VCL

2. Sur l'onglet d'ajout d'unité de la boîte de dialogue d'ajout, naviguez jusqu'au répertoire Lib dans Delphi, sélectionnez le
fichier rtl.dcp et cliquez sur Ouvrir, puis cliquez sur OK dans la boîte de dialogue d'ajout.
3. Dans la boîte de dialogue Package - package.dpk, sélectionnez vcl.dcp et cliquez sur Ajouter.
4. Sur l'onglet d'ajout d'unité de la boîte de dialogue d'ajout, naviguez jusqu'au répertoire Lib dans Delphi, sélectionnez le
fichier vcl.dcp et cliquez sur Ouvrir, puis cliquez sur OK dans la boîte de dialogue d'ajout.
5. Dans la boîte de dialogue Package - package.dpk, cliquez sur Compiler pour compiler le package. Une boîte de dialogue
apparaît, en indiquant que le package a été installé. Cliquez sur OK.
6. Cliquez sur le X dans le coin supérieur droit de la boîte de dialogue Package - package.dpk pour la fermer. Vous êtes invité
à enregistrer le package.
7. Enregistrez le package dans le répertoire de vos projets.

Pour tester le bouton

1. Choisissez Fichier Nouvelle application.
2. Sur la page ActiveX de la palette d'outils, localisez votre bouton et placez-le sur la fiche. Le bouton s'affiche sur la fiche.
Voir aussi
Présentation de VCL.NET

Création d'une fiche active ActiveX Fiches VCL ( see page 150)

2.5.46 Création d'une fiche active VCL ActiveX

2 Comme un contrôle Delphi, un contrôle ActiveX génère du code de programme lorsque vous placez le composant sur une fiche
ou un autre conteneur logique dans l'EDI. La principale différence entre un contrôle ActiveX et un contrôle Delphi réside dans le
fait qu'un contrôle ActiveX est indépendant du langage. Vous pouvez créer des contrôles ActiveX pour le déploiement vers
plusieurs environnements de programmation sous Windows, pas seulement Delphi ou C++Builder, par exemple.

Cette procédure utilise l'expert de fiche active ActiveX Fiches VCL pour créer une fiche active contenant deux composants. Pour
tester le contrôle, vous pouvez le déployer sur le Web. Cette procédure est constituée des étapes majeures suivantes :

1. Créer un projet de bibliothèque ActiveX pour une fiche active ActiveX.

2. Ajouter des contrôles à la fiche active.
3. Ajouter du code de gestion des événements pour les contrôles.
4. Déployer le projet sur le Web.
5. Afficher la fiche et tester les contrôles dans votre navigateur Web.

Pour créer un projet de bibliothèque ActiveX pour une fiche active ActiveX
1. Créez un répertoire sur votre disque local pour le projet ActiveX. Attribuez-lui un nom facile à trouver, par exemple ActiveX.
2. Créez un deuxième répertoire destiné à contenir le composant ActiveX et un fichier HTML pour déployer la fiche active dans
votre navigateur Web Microsoft Internet Explorer. Nommez ce répertoire ActiveX_Deploy.
3. Choisissez Fichier Nouveau Autre et sélectionnez la page ActiveX dans la boîte de dialogue Nouveaux éléments.
4. Dans la page ActiveX, double-cliquez sur la fiche active. L'expert Fiche active s'affiche.
5. Acceptez les paramètres par défaut et cliquez sur OK. L'expert génère le code nécessaire à l'implémentation du contrôle
ActiveX et ajoute le code au projet. Si le projet est déjà une bibliothèque ActiveX, l'expert ajoute le contrôle au projet en cours.
Remarque: Si le projet n'est pas encore une bibliothèque ActiveX, une boîte de dialogue Avertissement
s'affiche et vous demande si vous souhaitez démarrer un nouveau projet de bibliothèque ActiveX.

150
2.5 Procédures VCL RAD Studio Construction d'une application de

6. Cliquez sur OK pour démarrer un nouveau projet de bibliothèque ActiveX. Une fiche active ActiveX apparaît.

Pour ajouter certaines fonctionnalités à la fiche active

1. A partir de la page Standard de la palette d'outils, ajoutez des composants TEdit et TButton sur la fiche.
2. Sélectionnez le bouton.
3. Sur l'onglet Evénements, double-cliquez sur l'événement OnClick de l'inspecteur d'objets. L'éditeur de code s'affiche, le
curseur placé dans le bloc du gestionnaire de l'événement TActiveFormX.Button1Click (Delphi) ou
TActiveFormX::Button1Click() (C++). Entrez le code suivant au niveau du curseur :
ShowMessage(Edit1.text);
ShowMessage( Edit1–>Text )
4. Enregistrez les fichiers du projet pour votre répertoire ActiveX.
Remarque: Pour déployer la fiche active sur votre Web, utilisez le Gestionnaire de déploiement
. Cliquez sur Fichier Nouveau Autre Déploiement.

Pour tester la fiche active

1. Lancez votre navigateur.
2. Choisissez Fichier Ouvrir et naviguez jusqu'au répertoire ActiveX_Deploy.
3. Double-cliquez sur le fichier HTML pour le lancer dans la fenêtre du navigateur. La fiche active s'affiche dans la fenêtre du
navigateur.
4. Cliquez sur le bouton. Une boîte de dialogue déroulante affiche le texte dans la zone de saisie.
5. Modifiez le texte et cliquez à nouveau sur le bouton. Le nouveau texte que vous avez saisi s'affiche dans la boîte de dialogue
déroulante.
Voir aussi
2
Présentation de VCL.NET

Utilisation du gestionnaire de déploiement

2.5.47 Construction d'une application de navigateur Web

Fiches VCL
La création de l'application de navigateur Web comprend les étapes suivantes :

1. Créer une fiche VCL avec un contrôle bouton.

2. Ajouter un composant TWebBrowser à la fiche.
3. Ajouter des contrôles pour entrer une URL et lancer le navigateur.
4. Ecrire du code pour lancer le navigateur lorsque l'utilisateur clique sur un bouton.
5. Exécuter l'application.

Pour créer une fiche VCL

1. Choisissez Fichier Nouveau Autre Projets Delphi ou Projets C++Builder et double-cliquez sur l'icône Application
Fiches VCL. Le concepteur de fiches VCL apparaît.
2. Sur la page Internet de la palette d'outils, placez un composant TWebBrowser sur la fiche.
3. Avec le composant TWebBrowser sélectionné sur la fiche, déplacez les poignées pour ajuster la taille de la fenêtre du
navigateur. Laissez un espace sur la fiche sous le composant TWebBrowser pour ajouter une fenêtre de saisie d'URL. Si la

151
 Création d'une application qui utilise les RAD Studio 2.5 Procédures VCL

fenêtre n'est pas assez grande pour afficher une page entière du navigateur, le composant TWebBrowser ajoute des barres
de défilement lorsque vous exécutez l'application et lancez la fenêtre du navigateur.
4. Sur la page Standard de la palette d'outils, placez un composant TMemo sur la fiche. Avec le composant TMemo
sélectionné sur la fiche, déplacez les poignées afin d'ajuster la taille pour une URL saisie par l'utilisateur.
5. Sur la page Standard de la palette d'outils, placez un composant Label sur la fiche.
6. Sélectionnez le libellé, puis dans l'inspecteur d'objets, entrez l'URL : comme légende du libellé.
7. Sur la page Standard de la palette d'outils, placez un composant TButton sur la fiche.
8. Sélectionnez le bouton et dans l'inspecteur d'objets, entrez OK comme libellé de TButton.

Pour coder un bouton, cliquez sur l'événement qui lance le navigateur

1. Sélectionnez Button1 sur la fiche.
2. Dans l'inspecteur d'objets, double-cliquez sur l'action OnClick de l'onglet Evénements. L'éditeur de code s'affiche, avec le
curseur placé dans le bloc du gestionnaire d'événement Button1Click.
3. Tapez le code suivant :
WebBrowser1.Navigate(WideString(Memo1.Text));
WebBrowser1–>Navigate( WideString( Memo1–>Text ) );

Pour exécuter l'application

1. Choisissez Exécuter Exécuter pour construire et exécuter l'application.
2. Entrez une URL vers une page Web dans la fenêtre mémo, puis cliquez sur le bouton. Le navigateur démarre dans la fenêtre
TWebBrowser.
Voir aussi
Présentation de la VCL ( see page 46)
2
Construction d'une application Fiches VCL ( see page 108)

2.5.48 Création d'une application qui utilise les contrôles

ruban
Cette procédure décrit la création d'une application qui utilise les contrôles ruban. La fonctionnalité ruban est dérivée du
composant TRibbon. Lorsque le ruban utilise d'autres composants, aucun composant fondamental n'est recensé sur la palette
d'outils.

Composants :

1. TRibbon : Composant visuel principal qui fournit le plus de fonctionnalités.

2. TRibbonApplicationMenuBar : Composant qui fournit la fonctionnalité du menu d'application.
3. TRibbonQuickAccessToolbar : Composant qui fournit la fonctionnalité de la barre d'outils d'accès rapide.
4. TRibbonPage : Composant qui représente la page du ruban actuellement visible
5. TRibbonGroup : Composant dans lequel sont affichées toutes les commandes de pages. Les commandes doivent être
placées dans un groupe.

Pour créer une application à l'aide de l'expert Application Ruban

1. Sélectionnez Nouveau Autre... Projets Delphi.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez l'icône Nouvelle application Ruban.

152
2.5 Procédures VCL RAD Studio Ajout de commandes au ruban

3. Cliquez sur OK pour créer la nouvelle application. Vous serez invité à spécifier un dossier pour l'enregistrement de
l'application. Les fichiers générés seront placés dans ce dossier. Après la génération des fichiers et l'ouverture du projet dans
l'EDI, passez à la section Ajout de commandes au ruban de ce document.

Pour créer une nouvelle application sans l'expert

1. Créez une nouvelle application Delphi Win32 VCL (sélectionnez Nouveau Application Fiches VCL — Delphi pour
Win32).
2. Déposez un composant TActionManager sur la fiche.
3. Déposez un composant TRibbon sur la fiche.
4. Cliquez avec le bouton droit sur le composant TRibbon et sélectionnez l'élément Ajouter Menu Application.
5. Cliquez avec le bouton droit de nouveau sur le composant TRibbon et sélectionnez l'élément Ajouter Barre d'outils Accès
rapide.
Remarque: Durant la configuration initiale du ruban, vous pourrez voir un dialogue vous indiquant que le style actuellement
sélectionné dans le TActionManager.Style n'est pas un style de ruban valide. Définissez la propriété TRibbonManager.Style
sur Ribbon – Luna. Les styles applicables au ruban ont le préfixe Ribbon. Par défaut, trois styles de ruban sont implémentés.
Ces styles de ruban fonctionnent également avec la barre d'outils ActionManager par défaut et les contrôles de la barre de
menus. Les styles de ruban disponibles sont les suivants :
• Luna
• Obsidian
• Silver
Voir aussi
Présentation de la VCL ( see page 46)

Construction d'applications Fiches VCL avec graphiques ( see page 101)

2
win32_ribboncontrols2.xml ( see page 153)

2.5.49 Ajout de commandes au ruban

Cette rubrique suit en séquence la création d'une application ruban à l'aide de l'expert Application Ruban ou des étapes
manuelles décrites dans Création d'une application qui utilise les contrôles ruban ( see page 152).

Cette rubrique suppose que vous êtes familier avec le composant TActionManager et les composants associés à son utilisation.
De nombreuses nouvelles propriétés ont été ajoutées afin de prendre en charge les exigences de ruban. La plupart des
propriétés existantes sont sans effet quand elles sont modifiées sur une commande qui est affichée sur le ruban.

Par exemple :

• Les petits boutons affichent toujours leur glyphe sur la gauche du libellé.
• Les grands boutons affichent toujours leur glyphe en haut.
• Un grand bouton doit avoir un libellé. Le libellé doit être au maximum de deux lignes et la largeur du bouton est
redimensionnée en conséquence. La hauteur d'un grand bouton est fixée pour couvrir la hauteur du groupe où la commande
est affichée.
• Seuls les petits boutons sans libellé peuvent être affichés dans les groupes.
Nouvelles propriétés
CommandStyle : La propriété CommandStyle détermine le type de contrôle qui est utilisé pour représenter cette commande sur
le ruban. Le style par défaut est csButton. CommandStyle est beaucoup utilisée pour déterminer le type de contrôle utilisé pour
la commande, sauf sous une exception.

153
 Ajout de commandes au ruban RAD Studio 2.5 Procédures VCL

type TCommandStyle = (csButton, csMenu, csSeparator, csText, csGallery, csComboBox, csControl,

csCustom);

Style de la commande sur le groupe de ruban

csButton La commande est un bouton.

csMenu La commande est un élément de menu.
csSeparator La commande est un séparateur avec une description texte.
csText La commande affiche seulement du texte et n'a pas de contrôle associé.
csGallery La commande est une galerie, ou elle affiche une galerie quand elle est sélectionnée.
csComboBox La commande affiche une boîte à options de style Office 2007. Voir la remarque suivante.
csControl La commande a un descendant de TControl qui lui est associé. Un exemple est l'action de déposer un
composant TEdit sur un groupe de ruban.
csCustom Défini par l'utilisateur.

Remarque: Vous pouvez seulement utiliser le style de commande csComboBox si vous avez d'abord placé un composant
TRibbonComboBox de la palette d'outils sur votre groupe de ruban.

CommandProperties : CommandProperties est une classe de propriété dynamique. Les propriétés publiées de cette propriété
(c'est un descendant de TPersistent) varient selon le style de commande sélectionné. Si vous sélectionnez le style de
commande csButton, la classe CommandProperties utilisée est appelée TButtonProperties. Cette classe de propriété publie les
propriétés qui sont spécifiques au style de commande csButton.

L'exemple ButtonSize vous permet d'indiquer si le bouton est un petit ou un grand bouton. Il n'est pas nécessaire pour une
commande csMenu d'avoir une propriété ButtonSize car le menu ne réagit pas à une variation de taille.
2
Toutes les classes CommandProperties dérivent de TCommandProperties. Si vous utilisez le style de commande csCustom,
vous devez dériver de la classe TCommandProperties.

Les propriétés disponibles dans la propriété CommandProperties dépendent du style de commande sélectionné.

csButton ButtonSize
Taille du bouton :
TButtonSize = (bsSmall, bsLarge);

ButtonType
Types spéciaux des boutons autorisés :
TButtonType = (btNone, btDropDown, btSplit, btGallery); // btNone - bouton
normal // btDropdown - bouton affichant un menu déroulant // btSplit - bouton
ayant un menu déroulant et une action par défaut // btGallery - bouton affichant
une galerie
GroupPosition
Position de cette commande dans un groupe de commandes :
TGroupPosition = (gpNone, gpStart, gpMiddle, gpEnd, gpSingle); // Détermine si
une bordure est dessinée autour d'un bouton // gpNone - pas de bordure dessinée
// gpStart - le côté droit d'une bordure n'est pas dessiné // gpMiddle - le haut
et le bas de la bordure sont dessinés // gpEnd - le côté gauche n'est pas
dessiné // gpSingle - la bordure complète est dessinée
csMenu ShowRichContent Définissez cette propriété sur true pour afficher le contenu enrichi d'un élément de menu.
Content Le contenu à afficher sous forme de contenu enrichi. Font Permet d'utiliser une fonte personnalisée
lors de l'affichage du contenu enrichi. Les éléments de menu du contenu enrichi sont limités à deux lignes.
Selon le contenu, les éléments de menu peuvent être plus larges et ne sont pas changés afin d'être plus
hauts, et par conséquent certains éléments de menu affichent des lignes supplémentaires (au-delà des deux
permises.)

154
2.5 Procédures VCL RAD Studio Ajout de commandes au ruban

csSeparator csText et csSeparator partagent la même classe CommandProps, les propriétés disponibles sont ainsi les
mêmes.
Alignment : L'alignement du texte du libellé.
EllipsisPosition : Place des points de suspension si le texte du libellé est trop large pour la largeur du
menu. Il est seulement possible pour les éléments de menu d'être affichés dans le menu Application.
Font : Fonte à utiliser lors du dessin du texte du libellé.
Width : Impose une taille spécifique à la largeur du contrôle créé. Laissez -1 pour csSeparator
CommandStyle et modifiez à votre guise csText CommandStyle.
csText csText et csSeparator partagent la même classe CommandProps, les propriétés disponibles sont ainsi les
mêmes.
csGallery La classe CommandProperties csGallery dérive de la classe CommandProperties csButton. Cela
signifie que toutes les propriétés csButton sont également disponibles pour les commandes csGallery,
ainsi que les propriétés de galerie suivantes.
GalleryType
Type de galerie à afficher :
TGalleryType = (gtDropDown, gtGrid, gtRibbon); // gtDropDown - La galerie a la
forme d'un menu déroulant // gtGrid - La galerie est une disposition grille.
ItemsPerRow contrôle le nombre d'éléments par ligne // gtRibbon - la galerie est
dans le ruban
ItemsPerRow
Nombre d'éléments à afficher sur une ligne.
ShowRichContent
Définissez cette propriété sur true pour afficher le contenu enrichi des éléments de la galerie.
csComboBox AllowResize Contrôle si le menu déroulant associé à la boîte à options peut être redimensionné :
TGalleryResize = (grNone, grVertical, grBoth); // grNone – ne permet pas le
redimensionnement // grVertical – autorise seulement le redimensionnement 2
vertical // grBoth – autorise les redimensionnements vertical et horizontal
Items
Eléments à afficher quand l'utilisateur sélectionne le bouton déroulant. Ces éléments s'affichent dans une
fenêtre comme une boîte à options habituelle.
Text
Le texte à afficher dans la boîte à options.
Width
La largeur du contrôle incrémenteur, à l'exclusion de toute largeur de libellé.
csControl ContainedControl Référence au contrôle auquel elle est associée sur le ruban.
csCustom Défini par l'utilisateur.

KeyTip : La touche qui est enfoncée pour activer la commande lors de l'utilisation du clavier. Pour activer KeyTips, appuyez
sur la touche Alt ou F10.
NewCol : La définition de NewCol pour une commande force l'affichage du contrôle dans une nouvelle colonne du groupe de
ruban. Cette propriété est seulement effective quand l'alignement du groupe de ruban est gaVertical.
NewRow : La définition de NewRow pour une commande force l'affichage du contrôle dans une nouvelle ligne du groupe de
ruban. Cette propriété est seulement effective quand l'alignement du groupe de ruban est gaHorizontal.
Default : Définissez cette propriété sur true pour afficher en gras le libellé des éléments de de menu. Seulement effective pour
les éléments de menu.

Voir aussi
Présentation de la VCL ( see page 46)

Construction d'applications Fiches VCL avec graphiques ( see page 101)

155
 Ajout de commandes au ruban RAD Studio 2.5 Procédures VCL

Création d'une application qui utilise les contrôles ruban ( see page 152)

156
2.6 Procédures WebSnap RAD Studio Construction d'une application WebSnap

2.6 Procédures WebSnap

Cette section propose des informations relatives au développement d'applications WebSnap.

Veuillez noter que WebSnap est en cours de dépréciation dans RAD Studio. Bien que WebSnap soit toujours documenté dans
l'aide en ligne, le produit WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser IntraWeb (VCL pour le
Web). IntraWeb ( see page 2330) est documenté dans cette aide en ligne. Pour obtenir davantage de documentation sur la
VCL pour le Web, visitez http://www.atozed.com/intraweb/docs/.

Rubriques
Nom Description
Construction d'une application WebSnap ( see page 157) La procédure suivante décrit les étapes génériques requises pour construire un
projet WebSnap simple. Pour des rubriques plus avancées, voir les informations
connexes après la procédure.
La construction d'une application WebSnap comprend cinq étapes principales :

1. Créer un projet WebSnap

2. Modifier les composants inclus (facultatif)
3. Définir les options de page (facultatif)
4. Créer des pages WebSnap supplémentaires
5. Exécuter l'application.
Construction d'une application "Hello world" WebSnap ( see page 158) Malgré sa simplicité, l'application "Hello world" WebSnap illustre les étapes
essentielles de la création d'une application WebSnap.
La construction de l'application "Hello world" comprend cinq étapes principales : 2
1. Créer un projet WebSnap.
2. Accepter les composants inclus par défaut.
3. Définir le titre de la page dans les options de page.
4. Modifier le modèle HTML.
5. Exécuter l'application.
Débogage d'une application WebSnap à l'aide du débogueur d'application Web Cette rubrique décrit les tâches essentielles du débogage d'une application
( see page 160) WebSnap au moyen du débogueur d'application Web.

2.6.1 Construction d'une application WebSnap

La procédure suivante décrit les étapes génériques requises pour construire un projet WebSnap simple. Pour des rubriques plus
avancées, voir les informations connexes après la procédure.

La construction d'une application WebSnap comprend cinq étapes principales :

1. Créer un projet WebSnap

2. Modifier les composants inclus (facultatif)
3. Définir les options de page (facultatif)
4. Créer des pages WebSnap supplémentaires
5. Exécuter l'application.

157
 Construction d'une application "Hello RAD Studio 2.6 Procédures WebSnap

Pour créer un projet WebSnap

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Application WebSnap à partir du dossier Projets
Delphi WebSnap.
3. Cliquez sur OK. La boîte de dialogue Nouvelle application WebSnap apparaît.
4. Sélectionnez le type de l'application créée.
5. Sélectionnez les composants du modèle de votre application.
6. Dans le champ Nom de page, entrez le nom de votre page.
7. Sélectionnez votre type de mise en cache dans la liste déroulante Mise en cache.

Pour modifier les composants inclus (facultatif)

1. Dans la boîte de dialogue Nouvelle application WebSnap, cliquez sur Composants. La boîte de dialogue Composants
d'application Web s'affiche.
2. Sélectionnez les composants que vous souhaitez inclure.
Conseil: Dans la plupart des cas, les paramètres par défaut sont suffisants.

3. Cliquez sur OK.

Pour définir les options de page (facultatif)

1. Dans la boîte de dialogue Nouvelle application WebSnap, cliquez sur Options de page. La boîte de dialogue Options de
page du module d'application s'affiche.
2 2. Définissez les options de page.

Pour créer des pages WebSnap supplémentaires

1. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Module de page WebSnap à partir du répertoire Projets
Delphi WebSnap.
2. Configurez les options de module de page et cliquez sur OK.
3. Ajoutez et configurez les composants.
Remarque: WebSnap est en cours de dépréciation dans RAD Studio. Bien que WebSnap soit toujours documenté dans
l'aide en ligne, le produit WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser IntraWeb (VCL pour
le Web). IntraWeb ( see page 2330) est documenté dans cette aide en ligne. Pour obtenir davantage de documentation sur
la VCL pour le Web, visitez http://www.atozed.com/intraweb/docs/.
Voir aussi
Présentation des applications Web ( see page 51)

Construction d'une application "Hello world" WebSnap ( see page 158)

2.6.2 Construction d'une application "Hello world" WebSnap

Malgré sa simplicité, l'application "Hello world" WebSnap illustre les étapes essentielles de la création d'une application
WebSnap.

La construction de l'application "Hello world" comprend cinq étapes principales :

1. Créer un projet WebSnap.

158
2.6 Procédures WebSnap RAD Studio Construction d'une application "Hello

2. Accepter les composants inclus par défaut.

3. Définir le titre de la page dans les options de page.
4. Modifier le modèle HTML.
5. Exécuter l'application.

Pour créer un projet WebSnap

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Dans la boîte de dialogue Nouveaux éléments, sélectionnez Application WebSnap à partir du dossier Projets
Delphi WebSnap ou Projets C++Builder WebSnap.
3. Cliquez sur OK. La boîte de dialogue Nouvelle application WebSnap apparaît.
4. Sélectionnez le bouton radio Exécutable débogueur d'application Web.
5. Dans le champ Nom de classe, entrez HelloWorld.
6. Sélectionnez les composants du modèle de votre application.
7. Dans le champ Nom de page, entrez HelloWorld.
8. Sélectionnez votre type de mise en cache dans la liste déroulante Mise en cache.

Pour modifier les composants inclus (facultatif)

1. Dans la boîte de dialogue Nouvelle application WebSnap, cliquez sur Composants. La boîte de dialogue Composants
d'application Web s'affiche.
2. Sélectionnez les composants que vous souhaitez inclure.
Conseil: Dans la plupart des cas, les paramètres par défaut sont suffisants.
2
3. Cliquez sur OK.

Pour définir le titre de la page dans les options de page

1. Dans la boîte de dialogue Nouvelle application WebSnap, cliquez sur Options de page. La boîte de dialogue Options de
page du module d'application s'affiche.
2. Dans le champ Titre, entrez Hello World!.

Pour modifier le modèle HTML

1. Cliquez sur l'onglet HTML dans l'EDI.
2. Sous la ligne <h2><%= Page.Title %></h2>, insérez une ligne indiquant Voici ma première application
WebSnap.
3. Enregistrez l'application.

Pour exécuter l'application "Hello world"

1. Choisissez Exécuter Exécuter. Une fenêtre d'application s'ouvre et le serveur COM enregistre votre application WebSnap
avec le débogueur d'application Web.
2. Fermez la fenêtre de l'application.
3. Choisissez Outils Débogueur d'application Web. Le débogueur d'application Web se lance.
4. Dans le débogueur, cliquez sur le bouton Démarrer.
5. Cliquez sur URL par défaut pour lancer le navigateur.
6. Dans le navigateur, sélectionnez votre application Hello World dans la liste des applications et cliquez sur Aller. Votre
application apparaît dans le navigateur avec le texte Hello World! Voici ma première application WebSnap.

159
 Débogage d'une application WebSnap à RAD Studio 2.6 Procédures WebSnap

7. Fermez le navigateur Web pour revenir à l'EDI.

Remarque: WebSnap est en cours de dépréciation dans RAD Studio. Bien que WebSnap soit toujours documenté dans
l'aide en ligne, le produit WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser IntraWeb (VCL pour
le Web). IntraWeb ( see page 2330) est documenté dans cette aide en ligne. Pour obtenir davantage de documentation sur
la VCL pour le Web, visitez http://www.atozed.com/intraweb/docs/.
Voir aussi
Présentation des applications Web ( see page 51)

Construction d'une application WebSnap ( see page 157)

2.6.3 Débogage d'une application WebSnap à l'aide du

débogueur d'application Web
Cette rubrique décrit les tâches essentielles du débogage d'une application WebSnap au moyen du débogueur d'application
Web.

Pour déboguer une application WebSnap à l'aide du débogueur d'application Web

1. Enregistrez l'application des informations de serveur pour le débogueur d'application Web.
2. Enregistrez votre application WebSnap avec le débogueur d'application Web à sa première exécution.
3. Lancez le débogueur d'application Web.
4. Sélectionnez et lancez votre application web.
2 5. Déboguez votre application web en utilisant des points d'arrêt et le journal du débogueur d'application Web.

Pour enregistrer l'application des informations de serveur pour le débogueur d'application Web
1. Naviguez vers le répertoire bin de votre installation RAD Studio.
2. Exécutez serverinfo.exe.
3. Fermez la fenêtre vide d'application qui s'ouvre.
Cette étape doit uniquement être effectuée lors de la première utilisation du débogueur d'application Web.

Pour enregistrer votre application web avec le débogueur

1. Choisissez Exécuter Exécuter. Cela affiche la fenêtre console du serveur COM qui constitue votre application serveur Web.
2. Fermez la fenêtre vide d'application qui s'ouvre.
Votre serveur COM est maintenant enregistré et accessible au débogueur d'application Web.

Pour lancer le débogueur d'application Web

1. Choisissez Outils Débogueur d'application Web. Le débogueur d'application Web se lance.
2. Dans le débogueur, cliquez sur le bouton Démarrer.
3. Cliquez sur URL par défaut pour lancer le navigateur.

Pour sélectionner et lancer votre application web

1. Dans le navigateur, sélectionnez votre application dans la liste des applications.
2. Cliquez sur Aller. Votre application apparaît dans le navigateur.
Remarque: WebSnap est en cours de dépréciation dans RAD Studio. Bien que WebSnap soit toujours documenté dans

160
2.6 Procédures WebSnap RAD Studio Débogage d'une application WebSnap à

l'aide en ligne, le produit WebSnap n'est plus entièrement supporté. En alternative, commencez à utiliser IntraWeb (VCL pour
le Web). IntraWeb ( see page 2330) est documenté dans cette aide en ligne. Pour obtenir davantage de documentation sur
la VCL pour le Web, visitez http://www.atozed.com/intraweb/docs/.
Voir aussi
Présentation des applications Web ( see page 51)

Construction d'une application WebSnap ( see page 157)

161
 Construction d'une application de services RAD Studio 2.7 Procédures de services Web

2.7 Procédures de services Web

Cette section propose des informations relatives au développement et à l'utilisation de services web.

Rubriques
Nom Description
Construction d'une application de services Web "Hello World" ( see page 162) Les services Web sont des applications modulaires indépendantes qui peuvent
être publiées ou invoquées sur un réseau (comme le web). Les services Web
utilisent SOAP, un protocole léger standard permettant d'échanger des
informations dans une environnement distribué. Il utilise HTTP comme protocole
de communication et XML pour coder les appels des procédures distantes.
Accès à une application services Web "Hello World" ( see page 164) Pour exploiter l'application de services Web que vous avez créée, vous devez
créer une application client qui accédera à l'application de services Web
ASP.NET. Ce processus requiert différentes étapes de développement pour
atteindre le résultat recherché.
L'accès à une application "Hello World" simple avec des services Web ASP.NET
comprend quatre étapes principales :

1. Créez une application client.

2. Ajoutez une référence Web pour un service Web XML.
3. Créez la logique de code sous-jacent.
4. Sélectionnez un nom pour votre projet et cliquez sur OK.
Un fichier WinForm1.cs TWinForm1.pas est généré.
Construction d'une application de services Web "Hello World" ASP.NET ( see La construction d'une application avec des services Web ASP.NET vous permet
page 165) d'exposer des fonctionnalités à votre application client sur une connexion Web.
2 Ces étapes vous guident dans la construction d'une application "Hello World"
simple avec des services Web ASP.NET. Une fois construite, l'application
expose tous ses objets et méthodes par le biais d'un WebMethod que vous créez
et atteignez via un navigateur Web.
La création d'une application "Hello World" simple avec des services Web
ASP.NET comprend trois étapes principales :

1. Créer une application de services Web ASP.NET.

2. Créer un WebMethod.
3. Tester et exécuter l'application de services Web
ASP.NET.
Remarque: Actuellement, avec... suite ( see page 165)

2.7.1 Construction d'une application de services Web "Hello

World"
Les services Web sont des applications modulaires indépendantes qui peuvent être publiées ou invoquées sur un réseau
(comme le web). Les services Web utilisent SOAP, un protocole léger standard permettant d'échanger des informations dans
une environnement distribué. Il utilise HTTP comme protocole de communication et XML pour coder les appels des procédures
distantes.

Pour construire une application de services Web "Hello World"

1. Choisissez Fichier Nouveau Autre. La boîte de dialogue Nouveaux éléments apparaît.
2. Sélectionnez le dossier WebServices.

162
2.7 Procédures de services Web RAD Studio Accès à une application services Web

3. Double-cliquez sur l'icône Application serveur SOAP. L'expert Application serveur SOAP s'ouvre.
4. Choisissez le type d'application serveur Web que vous voulez utiliser pour votre service Web. L'expert génère une nouvelle
application serveur Web qui inclut un module Web contenant les trois composants HTTPSoapPascalInvoker,
HTTPSoapDispatcher et WSDLHTMLPublish. Lorsque vous quittez l'expert d'application serveur SOAP, il vous demande de
définir une interface pour votre service Web.
5. Pour créer un service Web à partir de rien, cliquez sur Oui. L'expert d'ajout d'un nouveau service Web s'ouvre.
6. Pour ajouter un nouveau service Web, spécifiez le nom de l'interface invocable que vous souhaitez exposer aux clients.
L'expert d'ajout d'un nouveau service Web vous permet de spécifier le nom de l'interface invocable et génère le code pour
déclarer et recenser l'interface et sa classe d'implémentation.
7. Pour implémenter un service Web ayant déjà été défini dans un document WSDL, utilisez l'importateur WSDL pour générer
les interfaces.

Pour utiliser l'importateur WSDL

1. Choisissez Fichier Nouveau Autre. Une boîte de dialogue Nouveaux éléments apparaît.
2. Sélectionnez le dossier WebServices.
3. Double-cliquez sur l'icône Importateur WSDL. Un expert Importateur WSDL apparaît.
4. Dans cette boîte de dialogue, spécifiez le nom de fichier d'un document WSDL (ou d'un fichier XML) ou spécifiez l'URL où ce
document est publié. Si vous ignorez l'URL du document WSDL à importer, cliquez sur Rechercher UDDI. Cela lance le
navigateur UDDI.
5. Si le document WSDL réside sur un serveur nécessitant l'authentification, cliquez sur Options. Une boîte de dialogue
Options d'importation apparaît.
6. Entrez un nom d'utilisateur et un mot de passe afin que l'expert puisse récupérer le document WSDL.
7. Cliquez sur Suivant. L'importateur WSDL affiche le code qu'il génère pour chaque définition dans le document WSDL
compatible avec l'infrastructure de services Web. 2
8. Cliquez sur Terminer. L'importateur crée de nouvelles unités qui définissent et recensent les interfaces invocables pour les
opérations définies dans le document, et qui définissent et recensent les classes distantes correspondant aux types définis
par le document.

Pour utiliser le navigateur UDDI

1. Dans le Navigateur UDDI, indiquez le registre UDDI.
2. Pour localiser l'entité métier à partir de laquelle vous souhaitez importer un service Web, entrez son nom.
3. Pour une correspondance exacte et une recherche sensible à la casse, cliquez sur les cases à cocher Concordance exacte et
MAJ/min.
4. Dans la zone de texte Lignes, entrez le nombre de correspondances désiré.
5. Pour spécifier l'ordre des résultats, choisissez dans la liste déroulante Tri la valeur pour Nom, Description,
LastUpdatedDescending et LastUpdatedAescending.
6. Cliquez sur Rechercher. Toutes les correspondances apparaissent dans la vue arborescente dans le coin supérieur droit.
Lorsque vous sélectionnez un TModel qui représente un service Web avec un document WSDL, le bouton d'importation est
activé.
7. Cliquez sur le bouton Importer.
Voir aussi
Présentation des services Web ( see page 54)

Utilisation de services Web ( see page 2388)

Accès à une application de services Web "Hello World"

163
 Accès à une application services Web RAD Studio 2.7 Procédures de services Web

2.7.2 Accès à une application services Web "Hello World"

Pour exploiter l'application de services Web que vous avez créée, vous devez créer une application client qui accédera à
l'application de services Web ASP.NET. Ce processus requiert différentes étapes de développement pour atteindre le résultat
recherché.

L'accès à une application "Hello World" simple avec des services Web ASP.NET comprend quatre étapes principales :

1. Créez une application client.

2. Ajoutez une référence Web pour un service Web XML.
3. Créez la logique de code sous-jacent.
4. Sélectionnez un nom pour votre projet et cliquez sur OK. Un fichier WinForm1.cs TWinForm1.pas est généré.

Pour créer une application client

1. Choisissez Fichier Nouveau Autre. Une boîte de dialogue Nouveaux éléments apparaît.
2. Sélectionnez n'importe quel type d'application pour créer votre client, comme une application RAD Studio ou une application
Web ASP.NET. Pour cet exemple, nous allons créer une application RAD Studio utilisant un Windows Form.
3. Cliquez sur OK. Une boîte de dialogue Nouveau projet apparaît.

Pour ajouter une référence Web pour une application de services Web ASP.NET
1. Choisissez Projet Ajouter une référence Web.

2 2. Dans la boîte de dialogue web Navigateur UDDI Universel CodeGear C#Builder Navigateur UDDI Universel CodeGear
Delphi pour .NET , entrez l'URL suivante : http://localhost/WebService1/WebService1.asmx dans la zone
d'adresse en haut de la boîte de dialogue.
Remarque: Le nom de votre application peut être différent de WebService1, comme indiqué. Dans ce cas, utilisez le nom de
votre application à la place de WebService1 dans l'exemple précédent.

3. Appuyez sur la touche Entrée.

Remarque: Si vous devez déterminer le chemin correct et que vous utilisez IIS, vous pouvez ouvrir l'administrateur IIS à
partir des outils d'administration dans le panneau de configuration de Windows XP. Trouvez le service Web que vous avez
enregistré et compilé dans la liste des sites Web IIS, puis consultez le nom du site et le nom du fichier .asmx.
Si vous avez entré le chemin correct, les informations concernant les WebMethods doivent s'afficher.
4. Cliquez sur le lien Description du service pour visualiser le document WSDL.
5. Cliquez sur Ajouter une référence pour ajouter le document WSDL à l'application client. Un dossier Références Web est
ajouté au répertoire Projet dans le gestionnaire de projet qui contient le fichier WebService1.wsdl et la boîte de dialogue
disparaît.

Pour créer la logique de code sous-jacent

1. Ajoutez un objet button dans Windows Form.
2. Double-cliquez sur le contrôle button pour visualiser le fichier de code sous-jacent.
3. Créez un événement button en tapant le texte suivant dans l'éditeur de code :
private void button1_Click(object sender, System.EventArgs e)
{
WebService1 ws = new WebService1();
button1.Text = ws.HelloWorld();
}

164
2.7 Procédures de services Web RAD Studio Construction d'une application de services

procedure TWinForm1.Button1_Click(sender: System.Object; e: System.EventArgs);

begin
new ws := WebService1();
button1.Text := ws.HelloWorld();
end;

Pour exécuter l'application client

1. Enregistrez l'application.
2. Compilez le projet et exécutez-le.
3. Cliquez sur le contrôle button. La mention "HelloWorld" apparaît sur le bouton.
Voir aussi
Présentation des services Web ( see page 54)

Support des services Web

Construction d'une application de services Web "Hello World" ( see page 165)

2.7.3 Construction d'une application de services Web "Hello

World" ASP.NET
La construction d'une application avec des services Web ASP.NET vous permet d'exposer des fonctionnalités à votre application
client sur une connexion Web. Ces étapes vous guident dans la construction d'une application "Hello World" simple avec des
services Web ASP.NET. Une fois construite, l'application expose tous ses objets et méthodes par le biais d'un WebMethod que
vous créez et atteignez via un navigateur Web. 2
La création d'une application "Hello World" simple avec des services Web ASP.NET comprend trois étapes principales :

1. Créer une application de services Web ASP.NET.

2. Créer un WebMethod.
3. Tester et exécuter l'application de services Web ASP.NET.
Remarque: Actuellement, avec RAD Studio vous pouvez seulement créer des services web en utilisant la méthode de code
sous-jacent. Vous ne pouvez pas utiliser la méthode de code en ligne, dans laquelle vous codez votre service web dans le
fichier <NomService>.asmx. Actuellement, RAD Studio ne prend pas en charge la méthode de code en ligne de création de
services web.

Pour créer une application de services Web ASP.NET

1. Choisissez Fichier Nouveau Autre. Une boîte de dialogue Nouveaux éléments apparaît.
2. Sélectionnez le dossier pour la langue que vous utilisez.
3. Sélectionnez Application Service Web ASP.NET. Une boîte de dialogue Nom de l'application apparaît.
4. Entrez un nom et un emplacement pour l'application dans les champs et conservez toutes les autres valeurs par défaut.
Remarque: Si vous utilisez le serveur Web Cassini, vous devez modifier les entrées Emplacement et Serveur. Vous devez
également vous assurer de configurer le serveur Web Cassini avant de tenter d'exécuter cette application. Choisissez
Outils->Options
et sélectionnez Options ASP.NET pour définir le Chemin et le Port pour Cassini.
5. Cliquez sur OK. Un fichier WebService1.asmx et un WebService1.asmx.<typefichier> sont automatiquement créés.

165
 Construction d'une application de services RAD Studio 2.7 Procédures de services Web

Pour créer un WebMethod

1. Sélectionnez l'onglet WebService.asmx.cs WebService.asmx.pas en bas de l'éditeur de code. Si vous donnez un nom
différent du nom par défaut à votre application de service Web, c'est ce nom qui apparaîtra sur l'onglet. Le code de
l'application "Hello World" est déjà inclus dans le WebMethod qui est créé lorsque vous créez l'application de services Web.
2. Retirez le commentaire du WebMethod exemple "HelloWorld" et du WebMethod exemple "EchoString" fournis dans le fichier
de code sous-jacent. L'un se trouve dans le module Interface et l'autre dans le module Implementation.
3. Choisissez Projet Construire <nom_projet> pour construire votre projet.
4. Exécutez votre projet. Cette opération appelle le navigateur qui héberge le service Web. Les pages que vous verrez incluront
le code exemple SOAP et HTTP que vous pouvez utiliser pour accéder aux WebMethods. Vous pouvez exécuter les
exemples et voir comment les résultats sont transmis à un fichier XML de sortie.

Pour tester et exécuter manuellement le service Web XML

1. A partir d'un navigateur Web, entrez l'emplacement du fichier WebService1.asmx sur votre hôte local :
http://localhost/WebService1/WebService1.asmx. Les pages que vous verrez incluront le code exemple SOAP et
HTTP que vous pouvez utiliser pour accéder aux WebMethods. Vous pouvez exécuter les exemples et voir comment les
résultats sont transmis à un fichier XML de sortie.
Remarque: Vous pourrez utiliser une syntaxe légèrement différente de celle présentée dans cette étape. Par exemple, sur
certaines machines Windows XP, l'identificateur localhost doit être le nom de votre machine. Ainsi, si le nom de votre
machine est MaMachine, la syntaxe serait : http://MaMachine/WebService1/Webservice1.asmx.

2. Testez les deux méthodes à partir d'un navigateur Web.

Voir aussi
Présentation des services Web ASP.NET
2
Gestion des services Web ASP.NET

Accès à une application services Web "Hello World"

166
3 RAD Studio

3 Référence
Rubriques
Nom Description
Référence C++ ( see page 168) Cette section contient les rubriques de référence de la bibliothèque C++ de RAD
Studio.
Guide du développeur Win32 ( see page 1224) Cette section contient les rubriques du Guide du développeur Win32 relatives à
la personnalité Delphi Win32 de RAD Studio.

167
 Utilitaires en ligne de commande RAD Studio 3.1 Référence C++

3.1 Référence C++

Cette section contient les rubriques de référence de la bibliothèque C++ de RAD Studio.

Rubriques
Nom Description
Utilitaires en ligne de commande ( see page 168) C++Builder fournit un jeu complet d'utilitaires en ligne de commande en plus de
son environnement de développement intégré (EDI). Ces utilitaires vous
permettent d'utiliser la ligne de commande pour effectuer une compilation ciblée
et d'autres fonctions associées, y compris la recherche de fichiers et l'importation
de fichiers de définition.
Liste de tous les avertissements et erreurs du compilateur C++ ( see page 229) Cette section décrit les messages d'erreur et d'avertissement du compilateur C++
RAD Studio.
Exemples C++ ( see page 400) Cette section contient des exemples C++.
Guide du langage C++ ( see page 401) Cette section traite du langage C++.
C Runtime Library Reference ( see page 717) RAD Studio has several hundred functions, macros, and classes that you call
from within your C and C++ programs to perform a wide variety of tasks,
including low- and high-level I/O, string and file manipulation, memory allocation,
process control, data conversion, mathematical calculations, and more.
Note: In the online help, each function, macro, and class in the C Runtime
Library is listed only once . However, some functions, macros, and classes are
defined in more than one header file.
For example, _strerror is defined in both string.h and stdio.h. For functions
that are defined in several header files, the online... suite ( see page 717)

3.1.1 Utilitaires en ligne de commande

C++Builder fournit un jeu complet d'utilitaires en ligne de commande en plus de son environnement de développement intégré
(EDI). Ces utilitaires vous permettent d'utiliser la ligne de commande pour effectuer une compilation ciblée et d'autres fonctions
associées, y compris la recherche de fichiers et l'importation de fichiers de définition.

Rubriques
Nom Description
BCC32, le compilateur C++ en ligne de commande ( see page 171) Le compilateur C++ CodeGear (BCC32.EXE) est un shell de compilateur de
ressources. Il invoque BRCC32 et RLINK32, selon la syntaxe de la ligne de
commande.
BRC32, le Shell de ressources ( see page 176) Le compilateur de ressources Borland (BRC32) est un shell de compilateur de
ressources. Il invoque BRCC32 et RLINK32, selon la syntaxe de la ligne de
commande.
BRCC32.EXE, le compilateur de ressources ( see page 177) BRCC32 est la version en ligne de commande du compilateur de ressources. Il
accepte un fichier script de ressources (.RC) en entrée et produit un fichier objet
ressource (.RES) en sortie.
COFF2OMF.EXE, l'outil de conversion d'une bibliothèque d'importation ( see COFF2OMF convertit un fichier bibliothèque d'importation COFF (FichierEntrée)
page 178) en un fichier bibliothèque d'importation OMF correspondant (FichierSortie).
COFF2OMF.EXE est situé dans le répertoire \bin de C++Builder.
3 CPP32.EXE, le préprocesseur du compilateur C ( see page 179) CPP32.EXE produit un fichier de listage d'un programme C ou C++, dans lequel
tous les #define de macros et tous les #include de fichiers ont été développés.
Bien qu'il ne soit pas nécessaire d'utiliser le préprocesseur pour une compilation
normale, ce fichier de listage peut être utile à des fins de débogage.
Souvent, lorsque le compilateur signale une erreur dans une macro ou un fichier
d'inclusion, vous pouvez obtenir davantage d'informations sur la nature de
l'erreur en consultant les fichiers d'inclusion ou les résultats du développement
des macros. Avec un grand nombre de compilateurs à plusieurs passes, ce
travail est... suite ( see page 179)
DCC32.EXE, le compilateur en ligne de commande Delphi. ( see page 181) DCC32 est le compilateur en ligne de commande Delphi (Pascal Objet).
Pour afficher l'aide de la ligne de commande, entrez :

168
3.1 Référence C++ RAD Studio Utilitaires en ligne de commande

DCCIL.EXE, le compilateur en ligne de commande Delphi pour .NET ( see DCCIL est le compilateur en ligne de commande Delphi (Pascal Objet) pour
page 183) l'environnement .NET. Utilisez DCCIL pour compiler des exécutables .NET
managés.
Pour afficher l'aide de la ligne de commande, entrez :
GREP.EXE, l'utilitaire de recherche de texte ( see page 184) GREP (Global Regular Expression Print) est un puissant programme de
recherche de texte dérivé de l'utilitaire UNIX du même nom. GREP recherche un
texte dans un ou plusieurs fichiers ou dans le flux d'entrée standard.
ILINK32.EXE, le lieur incrémentiel ( see page 189) ILINK32 lie des modules objets (fichiers .OBJ), des modules bibliothèques
(fichiers .LIB) et des ressources pour produire des fichiers exécutables (fichiers
.EXE, .DLL et .BPL). ILINK32 crée et gère une série de fichiers d'état contenant
ces informations. Ces fichiers d'état permettent aux liens suivants d'être de type
incrémentiel, ce qui réduit sensiblement la durée totale des liens.
IMPDEF.EXE, le gestionnaire de définition de module ( see page 194) Les bibliothèques d'importation permettent d'accéder aux fonctions d'une DLL
Windows. Les bibliothèques d'importation contiennent des enregistrements.
Chaque enregistrement contient le nom d'une DLL et spécifie l'emplacement
dans la DLL des fonctions importées. Ces enregistrements sont liés à
l'application par le lieur, et ils fournissent à Windows les informations nécessaires
pour résoudre les appels de fonctions de DLL. Vous pouvez substituer une
bibliothèque d'importation à une partie ou à la totalité de la section IMPORTS
d'un fichier de définition de module.
IMPDEF accepte en entrée un nom de DLL et génère en sortie un fichier de
définition de module avec une... suite ( see page 194)
IMPLIB.EXE, l'outil bibliothèque d'importation ( see page 196) IMPLIB accepte en entrée des DLL et/ou des fichiers de définition de module et
génère en sortie une bibliothèque d'importation.
Si vous avez créé une application Windows, vous avez déjà utilisé
IMPORT32.LIB, la bibliothèque d'importation des DLLs Windows standard.
IMPORT32.LIB est liée automatiquement lors de la construction d'une application
Win32 dans l'EDI de C++Builder et lors de l'utilisation de BCC32 au niveau de la
ligne de commande.
Une bibliothèque d'importation liste certaines voire toutes les fonctions exportées
pour une ou plusieurs DLLs. IMPLIB crée directement une bibliothèque
d'importation à partir de DLLs ou de fichiers de définition de module pour... suite
( see page 196)
Utilisation des fichiers d'inclusion ( see page 197) Dans C++, les fichiers d'inclusion ont toujours l'extension de fichier .h.
MAKE ( see page 198) MAKE.EXE est un utilitaire en ligne de commande qui vous aide à gérer les
cycles de compilation et de liaison des projets. MAKE n'est pas uniquement
consacré à la compilation et à la liaison, c'est un outil plus généraliste
d'exécution de commandes basées sur les dépendances des fichiers. MAKE
vous aide à construire rapidement les projets en compilant uniquement les
fichiers modifiés depuis la dernière compilation. De plus, vous pouvez définir les
règles spécifiant comment doit agir MAKE dans certaines circonstances
spéciales au cours de vos constructions.
Directives MAKE ( see page 201) Les directives de MAKE ressemblent aux directives des langages tels que Pascal
et C. Dans MAKE, elles effectuent diverses opérations de contrôle, telles que
l'affichage des commandes avant leur exécution. Les directives de MAKE
commencent par un point ou par un point d'exclamation, et remplacent les
options données sur la ligne de commande. Les directives qui commencent par
un point d'exclamation doivent apparaître au début d'une nouvelle ligne.
Le tableau suivant donne la liste des directives de MAKE et leur options en ligne
de commande correspondantes :

Macros MAKE ( see page 206) Une macro est une variable que MAKE traduit par une chaîne à chaque fois qu'il
rencontre la macro dans un fichier make. Par exemple, vous pouvez définir une
macro appelée LIBNAME qui représente la chaîne "mylib.lib". Pour cela, tapez la
ligne LIBNAME = mylib.lib au début de votre fichier make. Puis, lorsque MAKE
rencontre la macro $(LIBNAME), il substitue la chaîne mylib.lib. Les macros vous
permettent de créer des fichiers make modèle que vous pouvez ensuite ajuster à
vos besoins.
Pour utiliser une macro dans un fichier make, tapez $(NomMacro) où NomMacro
est une macro définie. Vous pouvez utiliser des... suite ( see page 206)
3

169
 Utilitaires en ligne de commande RAD Studio 3.1 Référence C++

Commandes et règles (explicites et implicites) de MAKE ( see page 208) Vous écrivez des règles explicites et implicites indiquant à MAKE comment
construire les cibles de votre fichier make. En général, ces règles sont les
suivantes :

• Les règles explicites sont des instructions applicables à

certains fichiers.
• Les règles implicites sont des instructions générales
applicables aux fichiers non concernés par les règles
explicites.
Toutes les règles que vous écrivez doivent respecter le
format général suivant :
Options des messages ( see page 212) Utilisez l'option -w pour spécifier les options des messages du compilateur
CodeGear C++ :

• Pour activer un message d'avertissement particulier,

entrez l'option -w avec un code d'option d'une à trois
lettres.
• Pour désactiver le message d'avertissement, entrez
l'option -w- avec un code d'option d'une à trois lettres.
Fichiers de définition de module ( see page 214) Utilisez les fichiers de définition de module avec ILINK32. Un fichier de définition
de module est un fichier texte ASCII qui fournit des informations à ILINK32 sur le
contenu et les exigences système d'une application Windows. Utilisez IMPDEF
pour créer un fichier de définition de module.
Le fichier de définition de module nomme les fichiers .EXE ou .DLL, identifie le
type d'application, énumère les fonctions importées et exportées, décrit les
attributs des segments de données et des sections de code, vous permet de
spécifier les attributs des segments de données et des sections de code
supplémentaires, spécifie la taille de... suite ( see page 214)
Fichiers en-tête précompilés ( see page 219) Les fichiers en-tête précompilés accélèrent de façon significative la vitesse de
compilation en stockant une image de la table des symboles dans un fichier sur
disque. Ce fichier est ensuite rechargé au lieu d'analyser de nouveau tous les
fichiers en-tête. Le chargement direct de la table des symboles depuis le disque
est beaucoup plus rapide que l'analyse du texte des fichiers en-tête, en
particulier si plusieurs fichiers source incluent le même fichier en-tête.
Pour utiliser les fichiers en-tête précompilés, spécifiez les diverses options -H
dans votre commande BCC32.
Options des en-têtes précompilés
RLINK32.DLL, le lieur de ressources (C++) ( see page 220) RLINK32.DLL est le lieur de ressources qui lie des ressources sous la forme de
fichiers .RES pour produire un fichier .EXE et marque le fichier .EXE résultant
comme exécutable Windows. RLINK32.DLL :

• Lie les ressources en combinant les tables de chaînes et

les tables de messages, puis en liant ces ressources liées
à l'exécutable.
• Est appelé par ILINK32 et est utilisé pour les ressources
32 bits.
TDUMP.EXE, l'utilitaire de vidage de fichier ( see page 221) TDUMP.EXE produit un vidage montrant la structure d'un fichier.
TDUMP divise un fichier de manière structurelle et utilise son extension pour
déterminer le format d'affichage de sortie. TDUMP reconnaît de nombreux
formats de fichiers tels qu'.EXE, .OBJ et .LIB. Si TDUMP ne reconnaît pas une
extension, il produit un vidage hexadécimal du fichier. Vous pouvez contrôler le
format de sortie en utilisant les options de la ligne de commande TDUMP au
lancement du programme.
3 La capacité de TDUMP à visualiser la structure interne d'un fichier permet non
seulement de voir le contenu d'un fichier, mais aussi de savoir comment il... suite
( see page 221)

170
3.1 Référence C++ RAD Studio Utilitaires en ligne de commande

TLIB.EXE, le gestionnaire de bibliothèques ( see page 224) TLIB est un utilitaire qui gère les bibliothèques de fichiers .OBJ (modules objet).
Une bibliothèque permet de manipuler facilement un collection de modules objet
comme une unité.
Les bibliothèques fournies avec le compilateur CodeGear C++ ont été construites
avec TLIB. Vous pouvez utiliser TLIB pour construire vos propres bibliothèques
ou pour modifier les bibliothèques CodeGear C++, vos bibliothèques, les
bibliothèques fournies par d'autres programmeurs ou des bibliothèques que vous
avez achetées.
Quand TLIB modifie une bibliothèque existante, TLIB crée une copie de la
bibliothèque d'origine et lui attribue l'extension .BAK.
Vous pouvez utiliser TLIB pour :

• Créer une nouvelle bibliothèque à... suite ( see page

224)
Utilisation de TOUCH.EXE ( see page 227) TOUCH.EXE met à jour la date d'un fichier afin qu'elle corresponde à la date et à
l'heure en cours de votre système.
TRIGRAPH ( see page 228) Les trigraphs sont des séquences de trois caractères qui remplacent certains
caractères utilisés dans le langage C et qui ne sont pas disponibles sur tous les
claviers. Comme la conversion des trigraphs dans le compilateur ralentirait
considérablement les compilations, CodeGear C++ fournit un filtre nommé
TRIGRAPH.EXE qui permet de gérer les séquences trigraph.

3.1.1.1 BCC32, le compilateur C++ en ligne de commande

Le compilateur C++ CodeGear (BCC32.EXE) est un shell de compilateur de ressources. Il invoque BRCC32 et RLINK32, selon
la syntaxe de la ligne de commande.

Syntaxe de la ligne de commande

bcc32 [option [option...}] <nomfichier> [<nomfichier>...]

Utilisez des espaces pour séparer le nom du compilateur, chaque option et les noms de fichier sur la ligne de commande.
Placez devant chaque option un tiret (-) ou une barre oblique (/). Par exemple :
BCC32 -Ic:\code\hfiles

Vous pouvez également spécifier les options dans les fichiers de configuration (.CFG), qui sont décrites dans une section
suivante.

Vous pouvez également utiliser BCC32 pour envoyer les fichiers .OBJ à ILINK32 ou les fichiers .ASM à TASM32 (si TASM32 est
installé sur votre machine).

Consultez l'aide de la ligne de commande BCC32 pour obtenir des informations détaillées
Pour afficher l'aide de la ligne de commande BCC32.exe dans la fenêtre cmd, incluez l'option de ligne de commande —h.

Par exemple, pour afficher la liste des options de la ligne de commande du compilateur les plus courantes, tapez :
BCC32 -h

La liste affichée indique les options activées par défaut (*) :

C:\>bcc32 -h CodeGear C++ 5.92 for Win32 Copyright (c) 1993, 2007 CodeGear
Options disponibles (* = paramètre par défaut, xxx = comporte des sous-options : utilisez -h
-X) : 3
(Remarque : -X- ou -w-XXX annulera habituellement tout ce qui a été défini ou restauré par -X)
-3 Générer des instructions compatibles au mode protégé 80386
-4 Générer des instructions compatibles au mode protégé 80386/80486
-5 Générer les instructions Pentium
-6 Générer les instructions Pentium Pro
-Axxx Active la conformité ANSI
-B Compiler en .ASM (-S), puis assembler en .OBJ
-C Activer les commentaires imbriqués
-CP Activer la pagination de code (pour MBCS)
-D -D <nom> définit 'nom' comme une chaîne null, ou utilisez -D<nom>=<valeur>

171
 Utilitaires en ligne de commande RAD Studio 3.1 Référence C++

-E Spécifier l'assembleur à utiliser

-G Optimiser pour la taille/vitesse ; utilisez à la place -O1 et -O2
-Hxxx Générer et utiliser des en-têtes précompilés
-I Définit le chemin de recherche des fichiers d'inclusion
-Jxxx Options de génération de template
-K Définir le type de caractère par défaut à non signé
-L Chemin d'accès aux fichiers bibliothèque
-M Créer un fichier map du lieur
-O Optimiser les sauts
-P Effectuer la compilation C++ quelle que soit l'extension des sources
-Q Informations erreurs du compilateur étendues
-R Inclure les informations du navigateur dans les fichiers .OBJ générés
-RF Chercher les références au symbole
* -RT Activer les informations de type à l'exécution
-S Compiler en assembleur
-T Spécifier l'option assembleur, ex. -Tx
-U Annuler les définitions de nom précédentes
-Vxxx Options de compatibilité
-Wxxx La cible est une application Windows
-X Désactiver les sorties d'auto-dépendance du compilateur
-axxx Définir la frontière de l'alignement des données. La valeur par défaut est -a8; -a-
signifie -a1
* -b Donner une taille entière aux énumérations (-b- les rend aussi court que possible)
-c Compiler en fichier objet uniquement, ne pas lier
-d Fusionner les chaînes dupliquées
-dc Placer les chaînes dans le segment de données en lecture seule
-dw Placer les chaînes dans le segment de données (en écriture)
-e Spécifier le chemin de l'exécutable cible
* -ff Virgule flottante rapide
-fp Corriger le défaut Pentium FDIV
* -fq Utiliser l'instruction de comparaison en virgule flottante silencieuse (FUCOMP)
-g Arrêter la compilation groupée après n avertissements (255 par défaut)
-h Demande d'aide ('-h -' affiche toute l'aide). Peut être spécifique : -h -V
-i Définir la longueur d'identificateur significative maximale (250 par défaut)
-j Arrêter la compilation groupée après n erreurs (Aucune par défaut)
* -k Générer les cadres de pile standard
-l Passer des options au lieur ; par exemple : -ls -l-x
-m Générer les informations de dépendance du makefile
-md Placer les informations de dépendance dans des fichiers .d, pas dans le fichier
objet
-mm Ignorer les fichiers en-tête système en générant les informations de dépendance
-mo Spécifier le fichier de sortie pour les informations de dépendance
-n Définir le répertoire de sortie pour les fichiers objet
-o Définir le nom du fichier de sortie (-o<nomfichier> ou —o <nomfichier> supporté)
-pxxx Utiliser la convention d'appel Pascal
-q Supprimer la bannière d'identification du compilateur
-r Utiliser les variables registre
-rd Utiliser les variables registre seulement quand le mot clé register est employé
-s Lier en utilisant le lieur non incrémentiel du système
-txxx Un autre nom pour les commutateurs -Wxxx ; pas de différence
* -u Générer des traits de soulignement dans les noms de symbole
-vxxx Activer le débogage du source
-w Afficher tous les avertissements
-w! Renvoyer la valeur non-zéro du compilateur sur les avertissements
-xxxx Activer la gestion des exceptions
-y Numéros de ligne du débogage activés
3 -z Options de redéfinition des noms de segment standard

Affichage de l'aide pour des options spécifiques, des groupes comme -Axxx et -Vxxx
Vous pouvez obtenir des informations plus spécifiques sur les options multilettres, comme -Axxx (compatibilité au langage et
conformité aux standards) et -Vxxx (compatibilité descendante).

Pour ce faire, utilisez l'option de ligne de commande -h avec la lettre initiale du groupe d'options (comme -A pour spécifier les

172
3.1 Référence C++ RAD Studio Utilitaires en ligne de commande

options -Axxx). BCC32 affichera seulement les rubriques d'aide pour le jeu d'options spécifié (comme —Axxx, —Vxxx ou
—Wxxx).

Par exemple, pour afficher une description des options -Axxx (compatibilité au langage et conformité aux standards), utilisez les
options de ligne de commande —h et —A :
C:\>bcc32 -h -A
CodeGear C++ 6.10 pour Win32 Copyright (c) 1993-2008 CodeGear
Options disponibles (* = paramètre par défaut, xxx = comporte des sous-options : utilisez -h
-X) :
(Remarque : -X- ou -w-XXX annulera habituellement tout ce qui a été défini ou restauré par -X)
-A Activer la conformité ANSI
-AF Utiliser les extensions et mots clés SUN Forte
-AG Utiliser les extensions et mots clés GNU
-AK Utiliser les extensions et mots clés Kernighan and Ritchie
-AT Utiliser les extensions et mots clés CodeGear C++ (aussi -A-)
-AU Utiliser les extensions et mots clés UNIX System
-An Utiliser les extensions et mots clés C99
-Ax Utiliser les extensions et mots clés C++-0x
Dans l'exemple suivant, l'aide de la ligne de commande BCC32 affiche des détails sur toutes les options -Vxxx (compatibilité
descendante) :
C:\>bcc32 -h -V
CodeGear C++ 6.10 pour Win32 Copyright (c) 1993-2008 CodeGear
Options disponibles (* = paramètre par défaut, xxx = comporte des sous-options : utilisez -h
-X) :
(Remarque : -X- ou -w-XXX annulera habituellement tout ce qui a été défini ou restauré par -X)
-V Options de compatibilité
-V0 Tables virtuelles C++ externes
-V1 Tables virtuelles C++ publiques
* -VA Générer toutes les fonctions globales dans leur propre segment virtuel/faible
-VC Ne pas mélanger les conventions d'appel dans les symboles
-VF Compatibilité MFC
-VF3 Supporter MFC 3.2
-VF4 Supporter MFC 4.0
* -VI Utiliser l'algorithme de recherche Microsoft pour localiser les fichiers d'en-tête
-VM Compatibilité Microsoft Visual C++
-Va Supporter les arguments de classe de style ancien
-Vb Activer la compatibilité descendante avec les versions Bcc 5.8.2 et antérieures.
-Vbc Ne pas réduire la référence ou le pointeur à la référence, ou la référence qualifiée.
-Vbe Permettre la spécialisation de template explicite de style ancien
-Vbn Permettre l'appel d'une fonction membre non-const ou non-volatile pour un objet
const ou volatile
-Vbo Utiliser les anciennes règles de résolution de surcharge Borland
-Vbr Permettre la liaison de références non-const
-Vbs Traiter les littéraux chaîne en tant que non-const
-Vbt Utiliser les anciennes règles de type Borland pour les opérateurs ternaires
-Vbx Permettre la spécialisation de template explicite comme fonction membre
-Vc Supporter les déplacements de constructeurs
-Vd Utiliser les règles de portée d'instruction for C++ anciennes
-Ve Classes de base vides de taille nulle
-Vg Désactiver l'analyseur digraphe lexical
-Vi Utiliser l'algorithme de recherche 8.3 pour localiser les fichiers d'en-tête
-Vl Utiliser les anciennes dispositions de classe Borland
-Vm Options de pointeur membre 3
-Vmd Utiliser la plus petite représentation possible pour les pointeurs membre
-Vmm Supporter l'héritage multiple pour les pointeurs membre
-Vmp Honorer la précision déclarée des pointeurs membre
-Vms Supporter l'héritage unique pour les pointeurs membre
-Vmv Ne pas placer de restrictions sur l'endroit où les pointeurs membre peuvent pointer
-Vn Activer les nouveaux noms d'opérateur : and, or, and_eq, bitand, etc.
-Vo Définir les indicateurs de compatibilité ; utilisé avec le code ancien
-Vp Empiler 'this' en premier, comme en Pascal
-Vr Inverser l'ordre pour les constantes multicaractères
-Vs Utiliser la génération virdef de style ancien

173
 Utilitaires en ligne de commande RAD Studio 3.1 Référence C++

-Vt Placer le pointeur de table virtuelle au début de la disposition d'objet

-Vv Utiliser les pointeurs de base virtuelle 'slow'
-Vw Emettre le code natif au lieu de l'Unicode pour les caractères multi-octets
-Vx Fonctions de membre de classe vide de longueur zéro

Paramètres par défaut

BCC32.EXE comporte des options spécifiques qui sont activées par défaut. Pour désactiver une option par défaut ou redéfinir
les options d'un fichier de configuration, placez un signe moins (-) après l'option.

Les fichiers d'extension .CPP sont compilés comme des fichiers C++. Les fichiers d'extension .C, sans extension ou avec une
extension différente de .CPP, .OBJ, .LIB ou .ASM sont compilés comme des fichiers C.

Le compilateur essaie de lier avec un fichier de définition de module de même nom que l'exécutable, et l'extension .DEF.

Options générales de sortie du compilateur

Option Description Détails

-c Compile en .OBJ, Compile et assemble les fichiers .C, .CPP et .ASM nommés, mais n'exécute pas un lien sur
pas de liaison les fichiers .OBJ résultants.

-e Spécifie le nom Lie le fichier en utilisant <nomfichier> comme nom du fichier exécutable. Si vous ne
<nomfichier> du fichier spécifiez pas un nom d'exécutable avec cette option, le lieur crée un fichier exécutable basé
exécutable sur le nom du premier fichier source ou fichier objet mentionné dans la commande.

-l <x> Passe l'option au Utilisez cette option de la ligne de commande pour passer les options <x> au lieur à partir
lieur. d'une commande de compilation. Utilisez l'option de la ligne de commande -l-x pour
désactiver une option spécifique du lieur.
-M Crée un fichier Utilisez cette option du compilateur pour demander au lieur de créer un fichier map.
MAP
-o Compile en Compile le fichier source spécifié en <nomfichier>.OBJ
<nomfichier> <nomfichier>.OBJ
-P Compilation C++ Provoque la compilation C++ de tous les fichiers source quelle que soit leur extension.
Utilisez l'option -P- pour compiler tous les fichiers .CPP comme des fichiers source C++ et
tous les autres fichiers comme des fichiers source C.
L'option de la ligne de commande -Pext provoque la compilation de tous les fichiers source
comme des fichiers C++ en indiquant que ext est l'extension par défaut. Cette option est
fournie car certains programmeurs utilisent une autre extension par défaut pour le code
C++.
L'option -P-ext compile les fichiers selon leur extension (.CPP est compilé en C++, toutes
les autres extensions sont compilées en C) et définit l'extension par défaut (autre que
.CPP).
-tWM Génère une cible Crée un .EXE ou .DLL multithread. Cette option n'est pas nécessaire si vous incluez un
multithread fichier de définition de module (fichier .DEF) dans vos commandes de compilation et de
liaison spécifiant le type d'application 32 bits que vous voulez construire.
3

Règles de priorité des options du compilateur

Les compilateurs de la ligne de commande évaluent les options de la gauche vers la droite, et suivent les règles suivantes :

• Si vous dupliquez une option (à l'exception des options -D, -I, -L ou -U), la dernière option tapée redéfinit toute option
antérieure.
• Les options tapées sur la ligne de commande redéfinissent les options des fichiers de réponse et de configuration à

174
3.1 Référence C++ RAD Studio Utilitaires en ligne de commande

l'exception des options -D, -I, -L et -U, qui sont cumulatives.

Spécification des répertoires dans les options de la ligne de commande

Le compilateur CodeGear C++ peut rechercher les fichiers de bibliothèque et d'inclusion dans plusieurs répertoires. La syntaxe
de l'option des répertoires de bibliothèque (-L) et des répertoires d'inclusion (-I), (comme l'option #define (-D)), permet plusieurs
listages d'une option donnée. Voici la syntaxe de ces options :
-L <nomrépertoire> [<nomrépertoire>;...]
-I <nomrépertoire> [<nomrépertoire>;...]
Le paramètre <nomrépertoire> utilisé avec -L et -I peut correspondre à tout répertoire ou chemin de répertoire. Vous pouvez
entrer ces répertoires sur la ligne de commande de l'une des façons suivantes

• Vous pouvez empiler plusieurs entrées avec une seule option -L ou -I en les séparant par un point virgule : BCC32.EXE —L
nomrép1;nomrép2;nomrép3 —I include1;include2;include3 monfichier.c
• Vous pouvez placer plusieurs occurrences de chaque option sur la ligne de commande : BCC32.EXE —L nomrép1 —L
nomrép2 —L nomrép3 —I include1 —I include2 —I include3 monfichier.c
• Vous pouvez mélanger les styles : BCC32.EXE —L nomrép1;nomrép2 —Lnomrép3 —I include1;include2 —I
include3 monfichier.c
Si vous listez plusieurs options -L ou -I sur la ligne de commande, le résultat est cumulatif. Le compilateur recherche tous les
répertoires listés, de la gauche vers la droite.

Utilisation des fichiers de configuration du compilateur (fichiers .CFG)

Si vous utilisez de façon répétitive un certain nombre d'options, vous pouvez les énumérer dans un fichier de configuration au
lieu de les taper sans cesse sur la ligne de commande. Un fichier de configuration est un fichier texte ASCII standard qui
contient une ou plusieurs options de ligne de commande. Chaque option doit être séparée par un espace ou un retour chariot.

A chaque émission d'une commande de compilation, BCC32.EXE recherche le fichier de configuration BCC32.CFG. Le
compilateur recherche d'abord le fichier .CFG dans le répertoire d'où provient la commande de compilation, puis dans le
répertoire où se trouve le compilateur.

Vous pouvez créer et utiliser plusieurs fichiers de configuration en supplément du fichier .CFG par défaut.

Pour utiliser un fichier de configuration, utilisez la syntaxe suivante où vous placerez les options du compilateur :
+[chemin]nomfichier

Par exemple, vous pouvez utiliser la ligne de commande suivante pour le fichier de configuration MYCONFIG.CFG :
BCC32 +C:\MYPROJ\MYCONFIG.CFG mycode.cpp

Les options tapées sur la ligne de commande remplacent les paramètres stockés dans les fichiers de configuration, à l'exception
des options cumulatives -D, -I, -L et -U.

Utilisation des fichiers de réponse

Les fichiers de réponse vous permettent d'avoir la liste des options du compilateur et des noms de fichiers dans un seul fichier (à
l'inverse des fichiers de configuration qui ne contiennent que les options du compilateur). Un fichier de réponse est un fichier
texte au format ASCII standard contenant une ou plusieurs options de ligne de commande et/ou des noms de fichiers, les
3
entrées du fichier étant séparées par des espaces ou des retours chariot. En plus de simplifier les commandes du compilateur,
les fichiers de réponse permettent d'avoir une ligne de commande plus longue que ce qui est autorisé par la plupart des
systèmes d'exploitation.

Voici la syntaxe d'utilisation d'un seul fichier de réponse :

BCC32 @[chemin]respfile.txt

175
 Utilitaires en ligne de commande RAD Studio 3.1 Référence C++

Voici la syntaxe d'utilisation de plusieurs fichiers de réponse :

BCC32 @[chemin]respfile.txt @[chemin]otheresp.txt

Les fichiers de réponse ont généralement l'extension .RSP.

Les options tapées sur la ligne de commande remplacent toute option ou nom de fichier d'un fichier de réponse, à l'exception
des options -D, -I, -L et -U qui sont cumulatives.

Voir aussi
Utilisation des fichiers d'inclusion

Fichiers en-tête précompilés ( see page 219)

Utilisation des fichiers de définition de module ( see page 214)

RLINK32.DLL ( see page 220)

BRCC32.EXE ( see page 177)

3.1.1.2 BRC32, le Shell de ressources

Le compilateur de ressources Borland (BRC32) est un shell de compilateur de ressources. Il invoque BRCC32 et RLINK32,
selon la syntaxe de la ligne de commande.

Syntaxe de la ligne de commande

brc32 [options] <nomfichier>.RC [<nomfichier>.EXE]

Pour afficher l'aide de la ligne de commande, entrez :

brc32

Options de la ligne de commande

Option Description
-d<nom> Définit un symbole que vous pouvez tester avec la directive #IFDEF du préprocesseur.
[=<chaîne>]
-fo<nomfichier> Renomme le fichier .RES.
-fe<nomfichier> Renomme le fichier .EXE.
-i<chemin> Ajoute un ou plusieurs répertoires (séparés par des points-virgules) au chemin de recherche d'inclusion.
-k Désactive le préchargement contigu des segments et des ressources dans le fichier .EXE. Les segments
sont conservés dans l'ordre dans lequel ils apparaissent dans le fichier .DEF. Cette option s'applique
seulement aux ressources 16 bits et elle est désactivée quand l'option -r est effective.
-r Crée un fichier .RES uniquement. Le fichier .RES compilé n'est pas ajouté à l'.EXE.
-v Affiche des messages de progression (mode "bavard").
-x Indique au compilateur d'ignorer la variable d'environnement INCLUDE lors de la recherche de fichiers de
3 ressources ou d'inclusion.
-16 Construit des fichiers .RES 16 bits.
-32 Construit des fichiers .RES 32 bits.
-Vd.d Génère le fichier .EXE pour la version de Windows spécifiée (v3.1 est la version par défaut pour les
ressources 16 bits ; -v4.0 est la version par défaut pour les ressources 32 bits). Les options de version sont
énumérées dans le tableau suivant.

Options de version (utilisées avec l'option —Vd.d)

176
3.1 Référence C++ RAD Studio Utilitaires en ligne de commande

Option Bit Aspect résultant

3.1 16 Donne un arrière-plan blanc sans aspect 3-D pour Windows 3.1x, Windows 32s ou WinNT 3.1
4.0 16 Donne un aspect 3-D grisé pour Windows 95 et WinNT 3.51
3.1 32 Donne un arrière-plan blanc sans aspect 3-D pour Windows 32s ou WinNT 3.1
4.0 32 Donne un aspect 3-D grisé pour Windows 95 et WinNT 3.51

Options de compatibilité descendante

Option Description
-t Crée une application ne fonctionnant qu'en mode protégé (mode Windows standard ou 386 étendu).
-31 Génère des fichiers .RES compatibles Windows 3.1
-w32 Génère des fichiers .RES compatibles Win32.

Exemples de Shell de ressources

L'instruction suivante compile le fichier .RC, crée un fichier .RES et ajoute le fichier .RES au fichier exécutable :
brc32 <nomfichier>.RC <nomfichier>.EXE

BRC32 recherche automatiquement un fichier .EXE de même nom que le fichier .RC. Vous devez spécifier le fichier .EXE
seulement si son nom est différent de celui du fichier .RC.

L'instruction suivante crée un fichier .RES, mais pas un fichier .EXE. Si vous nommez un fichier .EXE dans la ligne de
commande, BRC l'ignore :
brc32 -r <nomfichier>.EXE

L'instruction suivante ajoute un fichier .RES existant à un fichier exécutable. Le nom du fichier .EXE est obligatoire seulement s'il
est différent du nom du fichier .RES :
brc32 <nomfichier>.RES <nomfichier>.EXE

Cet exemple utilise BRC32 pour construire un fichier .RES compatible Windows 3.1 16 bits :
brc32 -16 -v3.1 -fo<nomfichier>.RES <nomfichier>.RC

Voir aussi
RLINK32.DLL ( see page 220)

BRCC32.EXE ( see page 177)

3.1.1.3 BRCC32.EXE, le compilateur de ressources

BRCC32 est la version en ligne de commande du compilateur de ressources. Il accepte un fichier script de ressources (.RC) en
entrée et produit un fichier objet ressource (.RES) en sortie.

Syntaxe de la ligne de commande

3
BRCC32 [<options>] <nomfichier>

Pour afficher l'aide de la ligne de commande, entrez :

brcc32

Ou ajoutez l'indicateur d'aide :

brcc32 -h

177
 Utilitaires en ligne de commande RAD Studio 3.1 Référence C++

Options de la commande BRCC32

Option Description
@<fichrép> Prend les instructions dans le fichier de commande spécifié.
-c <pagecode> Utilise la page de code spécifiée pour la traduction des ressources. Si -c n'est pas utilisé, la page de
code ANSI par défaut est utilisée.
-d<nom>[=<chaîne>] Définit un symbole du préprocesseur.
-fo<nomfichier> Renomme le fichier .RES de sortie. Par défaut, BRCC32 crée le fichier .RES de sortie avec le même
nom que le fichier .RC d'entrée.
-i<chemin> Ajoute un ou plusieurs répertoires (séparés par des points-virgules) au chemin de recherche d'inclusion.
-l<langage> Spécifie le langage par défaut.
-m Indique que la page de code spécifiée à l'aide du commutateur -c contient des caractères du jeu de
caractères à deux octets (DBCS).
-r Ce commutateur est ignoré. Il n'est inclus que par compatibilité avec d'autres compilateurs de
ressources.
-v Affiche des messages de progression (mode "bavard").
-x Supprime le chemin d'inclusion en cours.
-h ou ? Affiche l'aide.
-16 Construit une ressource 16 bits.
-32 Construit une ressource 32 bits.

BRCC32 prédéfinit des constantes Windows liées aux ressources telles que WS_VISIBLE et BS_PUSHBUTTON. En outre,
deux symboles spéciaux liés au compilateur sont définis : RC_INVOKED et WORKSHOP_INVOKED. Ces symboles peuvent
être utilisés dans le texte source avec les instructions conditionnelles du préprocesseur pour contrôler la compilation.

Par exemple, la construction suivante peut accélérer de manière significative la compilation :

#ifndef WORKSHOP_INVOKED#include “windows.h”
#endif
Compatibilité descendante
La syntaxe et les options suivantes sont prises en charge à des fins de compatibilité descendante :

Option Description
-16 Construit des fichiers .RES 16 bits.
-32 Construit des fichiers .RES 32 bits.
-31 Construit des fichiers .RES compatibles Windows 3.1.
-w32 Construit des fichiers .RES compatibles Win32.

Voir aussi
3 BRC32.EXE ( see page 176)

3.1.1.4 COFF2OMF.EXE, l'outil de conversion d'une bibliothèque

d'importation
COFF2OMF convertit un fichier bibliothèque d'importation COFF (FichierEntrée) en un fichier bibliothèque d'importation OMF
correspondant (FichierSortie). COFF2OMF.EXE est situé dans le répertoire \bin de C++Builder.

178
3.1 Référence C++ RAD Studio Utilitaires en ligne de commande

Syntaxe de la ligne de commande

Coff2Omf [<options>] FichierEntrée FichierSortie

Pour afficher l'aide de la ligne de commande, entrez :

coff2omf

COFF2OMF convertit les symboles exportés publiquement dans la bibliothèque d'importation COFF en un jeu de symboles
correspondant dans la bibliothèque d'importation OMF. COFF2OMF permet aux utilisateurs de C++Builder d'établir un lien avec
des DLLs Microsoft et tierces qui utilisent le format COFF. COFF2OMF ne convertit pas les fichiers .OBJ.

Exécutez l'outil COFF2OMF sur une bibliothèque d'importation COFF créée pour une DLL spécifique et utilisez la bibliothèque
d'importation obtenue pour lier les fichiers DLL et EXE de format OMF à la DLL COFF.

Option de Description
la ligne de
commande

-q Mode silencieux. Convertit sans écrire les informations de l'outil et de copyright dans la sortie standard)
-v Affiche les symboles sélectionnés. Affiche les symboles convertis dans la sortie standard et pouvant être redirigés
vers un fichier de sortie.
-d Supprime le fichier de sortie s'il est vide. Supprime le fichier de sortie en cas d'erreur et si la conversion résulte en
un fichier vide.
-h ou -? Affiche l'aide.
-r Retire (supprime) le fichier de sortie s'il est vide.
-lib:xx Spécifie les options de la génération de la bibliothèque d'importation OMF. Vous pouvez définir les options xx
suivantes :
• ms — Autorise les entrées présentant un substantypage des noms MS C++. La valeur par défaut est Non.
• st — Normalise les noms au lieu de créer des alias de substantypage MS stdcall.
• ca — Ne crée pas d'alias MS cdecl. La valeur par défaut est la création d'alias.

3.1.1.5 CPP32.EXE, le préprocesseur du compilateur C

CPP32.EXE produit un fichier de listage d'un programme C ou C++, dans lequel tous les #define de macros et tous les #include
de fichiers ont été développés. Bien qu'il ne soit pas nécessaire d'utiliser le préprocesseur pour une compilation normale, ce
fichier de listage peut être utile à des fins de débogage.

Souvent, lorsque le compilateur signale une erreur dans une macro ou un fichier d'inclusion, vous pouvez obtenir davantage
d'informations sur la nature de l'erreur en consultant les fichiers d'inclusion ou les résultats du développement des macros. Avec
un grand nombre de compilateurs à plusieurs passes, ce travail est effectué par une passe séparée dont on peut examiner les
résultats. Puisque le compilateur CodeGear C++ est un compilateur à une seule passe, utilisez CPP32 pour obtenir les résultats
3
procurés par la première passe d'autres compilateurs.

Pour chaque fichier traité par CPP32, la sortie est écrite dans un fichier du répertoire en cours (ou du répertoire de sortie
désigné à l'aide de l'option -n) portant le nom du fichier source mais avec l'extension .I.

Ce fichier de sortie est un fichier texte contenant chaque ligne du fichier source et tous les fichiers d'inclusion. Les lignes
contenant des directives de prétraitement ont été retirées, de même que les lignes de texte conditionnel exclues de la
compilation. Si vous n'avez pas utilisé d'option de ligne de commande pour définir une autre spécification, les lignes de texte
sont préfixées par le nom de fichier et le numéro de ligne du fichier source ou du fichier d'inclusion dont elles proviennent. Dans

179
 Utilitaires en ligne de commande RAD Studio 3.1 Référence C++

chaque ligne de texte, les macros sont remplacées par leur texte développé. Utilisez l'option -Sr pour produire un fichier sans
numéros de ligne. Vous pouvez alors passer ce fichier au compilateur (utilisez l'option -P du compilateur pour imposer une
compilation C++).

Syntaxe de la ligne de commande

CPP32 [<options>] <nomfichier[s]>

Pour afficher l'aide de la ligne de commande, entrez :

cpp32 -h

CPP32 reconnaît les mêmes options que BCC32, à l'exception des ajouts suivants pour l'option -S (contrôle du format de sortie
prétraité) :

Option Description
-Sc Conserve les commentaires dans le fichier prétraité.
-Sd Conserve les définitions dans le fichier prétraité.
-Sk Conserve les sorties en cas d'erreur.
-Sr Rend les sorties lisibles en préservant les commentaires et les indentations.
-Ss Affiche les statistiques sur les noms de fichiers et les compteurs de lignes.

CPP32 en tant que préprocesseur de macros

CPP32 peut être utilisé comme un préprocesseur de macros ; le fichier .i résultant peut alors être compilé avec BCC32. Le
programme simple suivant illustre le prétraitement d'un fichier par CPP32.

Fichier source : HELLOFB.C

#define NAME “Frank CodeGear”
#define BEGIN {
#define END }
main()
BEGIN
printf(“%s\n”, NAME);p
END

Ligne de commande CPP32

CPP32 HELLOFB.C

Sortie (écrite dans HELLOFB.I)

/* HELLOFP.C 1: */
/* HELLOFP.C 2: */
3 /* HELLOFP.C 3: */
/* HELLOFP.C 4: */
/* HELLOFP.C 5: */main()
/* HELLOFP.C 6: */printf("%s\n", "Frank Borland");
/* HELLOFP.C 7: */}
/* HELLOFP.C 8: */}

180
3.1 Référence C++ RAD Studio Utilitaires en ligne de commande

Utilisation de MIDL avec CPP32

MIDL (Microsoft Interface Definition Language, langage de définition d'interface Microsoft) est un compilateur RPC. Afin d'utiliser
MIDL avec le préprocesseur C++ (CPP32.EXE), servez-vous de la commande MIDL suivante :

Option Description
-<cpp_cmd> Indique à MIDL le préprocesseur à utiliser lors du traitement d'un fichier .IDL ou .ACF. MIDL appelle le
{<CPP32>} préprocesseur pour développer les macros dans les fichiers source.
-<cpp_opt> Spécifie les options de ligne de commande pour le préprocesseur. L'option -Sr retire les informations nom
"{<options>}" de fichier et numéro de ligne dans chaque ligne de la sortie prétraitée. L'option -oCON indique que la
sortie prétraitée doit être acheminée vers la sortie standard, au lieu d'être enregistrée dans un fichier. La
bannière du préprocesseur et le fichier en cours de traitement ne sont pas transmis. L'inclusion de -oCON
dans un fichier .CFG traité par le préprocesseur provoque la transmission de la bannière.
{<options Transmet les options à CPP32.
CPP32>}
{<options MIDL>} Toutes les options de ligne de commande MIDL.
{<fichier .idl/.acf> Le fichier source traité par MIDL.

BCC32, CPP32 et UUIDs

Dans certains cas, CPP32 n'accepte pas des UUIDs valides. Une instruction UUID valide est, par exemple, de la forme :
uuid(5630EAA0-CA48-1067-B320-00DD010662DB)

Quand CPP32 rencontre 5630EAA0, il le considère comme un nombre à virgule flottante, et comme il ne s'agit pas d'un nombre
à virgule flottante valide, le pr