RAD Studio - Contributions [fr]

Présentation des tests unitaires

2023-06-27T05:02:29Z

Yukikoi : 1 révision importée : LOC-23437

Test des applications - Index

2023-06-27T05:02:28Z

Yukikoi : 1 révision importée : LOC-23437

{{Parent|Etapes du développement d'un projet}}
Le test unitaire fait partie intégrante du développement d'applications fiables. Les rubriques suivantes évoquent les caractéristiques des tests unitaires qui sont comprises dans {{Variables|Product}}.

==Rubriques==

*[[Présentation de DUnitX|Présentation de DUnitX]]
** [[Développement de tests avec DUnitX|Développement de tests avec DUnitX]]{{f|radstudio|
** [[Comment convertir les tests DUnit en DUnitX|Comment convertir les tests DUnit en DUnitX]]

* [[Présentation de DUnit|Présentation de DUnit]]

: {{Note| DUnitX est un framework de test unitaire moderne. Il est préférable d'utiliser DUnitX plutôt que DUnit. DUnitX utilise des fonctionnalités du langage Delphi qui ne sont pas prises en charge dans C++.}}

*
** [[Présentation des tests unitaires|Présentation des tests unitaires]]
** [[Développement de tests|Développement de tests]] }}

[[Category:Index des rubriques]]
[[Category:Utilisation de RAD Studio]]
[[Category:Delphi]]
[[Category:C++]]
[[Category:AMMigrate]]

Exécution et débogage de votre application Android sur un périphérique Android à distance

2023-06-27T05:02:28Z

Yukikoi : 1 révision importée : LOC-23437

{{Parent|Développement d'applications mobiles Android}}

__TOC__
Cette page explique comment déboguer une application Android sur un périphérique Android connecté en réseau. Cette méthode est également connue en tant que {{Code|ADB over network}} ou {{Code|TCP/IP debugging}}.
Vous devez avoir lu [[Développement d'applications mobiles Android|Développement d'applications mobiles Android]] et compris les étapes nécessaires pour configurer et utiliser un périphérique Android pour le développement.

Les avantages de cette méthode sont notamment les suivants :

* Connexion sans fil au périphérique Android, aucun câble USB nécessaire (lorsque les périphériques ne sont pas associés à une racine, le câble USB est nécessaire pour changer le mode de débogage).
* Simplifie le partage d'un périphérique Android pour le débogage entre développeurs.

:'''Remarque :''' Toutes les commandes ADB sur cette page fonctionnent si vous avez seulement un périphérique Android connecté à votre machine. Si vous avez plus d'un périphérique Android connecté, voir [http://developer.android.com/tools/help/adb.html#directingcommands Android Help: Directing Commands (EN)] pour connaître la méthode appropriée pour l'exécution des commandes ADB.

:'''Remarque :''' Les applications Android continuent à s'exécuter en arrière-plan, même si elles ne sont pas visibles pour les utilisateurs. Comme l'application continue à s'exécuter, on peut avoir l'impression que le débogueur est en panne alors qu'il s'est simplement déconnecté de l'application.

==Activation du débogage TCP/IP sur le périphérique Android==

===Exigences===

* Le périphérique Android doit être connecté à un réseau sans fil identique à (ou faisant partie de) celui auquel votre machine de développement est connectée.

Si votre périphérique Android '''n'est pas associé à une racine''', vous avez également besoin de ce qui suit :

* Une machine sur laquelle est installé le SDK Android.
* Un câble USB.
* Le périphérique Android doit être reconnu en tant que '''périphérique ADB''' sur la machine.

Si votre périphérique Android '''est associé à une racine''', vous avez besoin de ce qui suit :

* L'une des conditions suivantes :
** Un paramètre de menu activant l'option {{Code|TCP/IP debugging mode}} (disponible sur certaines ROM). Il se trouve généralement dans le menu des réglages du développeur, et il peut s'appeler {{Code|ADB over network}}).
** Une application émulateur de terminal installée sur votre périphérique (comme [https://play.google.com/store/apps/details?id=jackpal.androidterm&hl=en Terminal Emulator for Android]).
** Une application qui active l'option {{Code|TCP/IP debugging mode}} (par exemple [https://play.google.com/store/apps/details?id=net.wiagames.adbon&rdid=net.wiagames.adbon ADB over network]).

:'''Remarque :''' Votre machine de développement peut être connectée au réseau sans fil ou via un câble Ethernet, tant qu'elle se trouve sur le même réseau que le périphérique Android.

===Etapes===

Si votre périphérique Android '''n'est pas associé à une racine''' :

# Connectez le périphérique Android à la machine via un câble USB.
# Ouvrez un terminal, tel que {{Path|cmd.exe}}.
# Allez au dossier {{Path|platform-tools}} de votre SDK Android :
#: {{#tag:source|cd "{{PublicDocumentsPath}}\CatalogRepository\<dossier SDK Android>\platform-tools"|lang=winbatch|enclose=none}}
# Exécutez cette commande :
#: {{#tag:source|adb tcpip 5555|lang=winbatch|enclose=none}}
#:: '''Remarque :''' Remplacer {{Code|5555}} avec le port sur lequel le périphérique va écouter les connexions entrantes.
# Si vous le souhaitez, vous pouvez déconnecter le périphérique Android de la machine après avoir exécuté cette commande.

Si votre périphérique Android '''est associé à une racine''', effectuez l'une des actions suivantes pour activer le mode de débogage TCP/IP :

* Activez le {{Code|TCP/IP debugging mode}} dans le menu des réglages du développeur sur votre périphérique (cette option peut s'appeler {{Code|ADB over network}}).
* Exécutez le code suivant dans un émulateur de terminal :
*:<source lang="bash" enclose="none">su</source>
*:<source lang="bash" enclose="none">setprop service.adb.tcp.port 5555</source>
*:<source lang="bash" enclose="none">stop adbd</source>
*:<source lang="bash" enclose="none">start adbd</source>
* Utilisez une application qui active le débogage TCP/IP.

==Connexion au périphérique Android==

Pour connecter le périphérique Android à partir de votre machine de développement, exécutez la commande suivante dans le répertoire "platform-tools" de votre installation du SDK Android : {{Code|adb connect {{Placeholder|IPAddress}}:{{Placeholder|portNumber}}}} (par exemple : {{Code|adb connect 192.168.1.110:5555}}). {{Placeholder|IPAddress}} est l'adresse IP de votre périphérique. Voici plusieurs moyens de trouver l'adresse IP de votre périphérique :

* Accédez au menu de votre périphérique (généralement : {{Code| Settings > Wi-Fi > Advanced Wi-Fi}}, mais cela peut varier en fonction de la version du système d'exploitation de votre périphérique ou du fabricant).
* Exécutez la commande suivante dans le répertoire "platform-tools" de votre installation du SDK Android : {{Code|adb shell netcfg}}. Pour cela, votre périphérique doit être connecté via un câble USB.
* Trouvez l'adresse IP de votre périphérique dans la page des paramètres de votre routeur réseau.

Si la connexion réussit, la fenêtre de commande affiche : "connected to {{Placeholder|IPAddress}}:{{Placeholder|portNumber}}". Vous pouvez utiliser la commande {{Code|adb devices}} pour afficher une liste des périphériques ADB connectés. Le périphérique Android connecté doit maintenant apparaître dans la '''[[Fenêtre Projets|fenêtre Projets]]'''.

==Déconnexion à partir d'un périphérique Android à distance==

Si vous souhaitez vous déconnecter du périphérique Android, [[#Réinitialisaiton du mode débogage sur le périphérique Android|réinitialisez simplement le mode débogage]] sur le périphérique. Autrement, vous pouvez exécuter le code suivant sur la machine de développement : {{Code|adb disconnect {{Placeholder|IPAddress}}:{{Placeholder|portNumber}}}}.

==Réinitialisation du mode débogage sur le périphérique Android==

Sur un périphérique Android, le mode débogage est réinitialisé chaque fois que le périphérique est redémarré. Si vous souhaitez réinitialiser le mode débogage sans redémarrer le périphérique, procédez de l'une des manières suivantes :

<ul><li>Exécutez la commande {{Code|adb usb}} sur la machine distante à laquelle le périphérique Android est connecté via un câble USB. </li>
<li>Exécutez le code suivant dans un émulateur de terminal sur le périphérique :</li>
style="list-style: none; display: inline"

su
setprop service.adb.tcp.port -1
stop adbd
start adbd

</ul>

==Voir aussi==

* [[Création d'une app Android|Création d'une app Android]]
* [[Exécution de votre application Android sur un périphérique Android|Exécution de votre application Android sur un périphérique Android]]
* [[Débogage des applications multi-périphériques|Débogage des applications multi-périphériques]]
* [[Périphériques Android pris en charge pour le développement d'applications|Périphériques Android pris en charge pour le développement d'applications]]

[[Category:Android]]
[[Category:XE8]]
[[Category:AMMigrate]]

Présentation de DUnit

2023-06-27T05:02:25Z

Yukikoi : 1 révision importée : LOC-23437

{{Parent|Test des applications - Index}}
{{Attention| N'oubliez pas que '''DUnit ne prend pas en charge l'interface utilisateur graphique de {{FM}} ''' pour visualiser votre sortie ; utilisez à la place [[Présentation de DUnitX|DUnitX]].}}
{{Note|DUnitX utilise des fonctionnalités du langage Delphi qui ne sont pas prises en charge dans C++. Pour les développeurs C++, DUnit est le meilleur outil. C++ peut également être testé à l'aide d'autres frameworks comme Google Test, disponible via le [[Gestionnaire de packages GetIt|Gestionnaire de packages GetIt]].}}

DUnit est un framework de test unitaire open-source basé sur le framework de test JUnit. Le framework DUnit vous permet de construire et d'exécuter des tests sur des applications {{Delphi}} Win32. L'intégration du framework DUnit dans {{Variables|Product}} vous permet de développer et d'exécuter des tests sur des applications {{Delphi}} Win32 et {{CBuilder}}.

Le framework de test DUnit propose son propre ensemble de méthodes pour les conditions de test. Les méthodes représentent des assertions communes. Vous pouvez également créer vos propres assertions personnalisées. Vous pouvez utiliser les méthodes proposées pour tester un grand nombre de conditions.

Voir également la page d'accueil DUnit sur [http://dunit.sourceforge.net/ http://dunit.sourceforge.net/]

==Installation de DUnit==

Pour installer la fonctionnalité DUnit, procédez comme suit :

# Sélectionnez {{Menu|Outils > Gérer les plates-formes}} pour ouvrir le '''Gestionnaire de fonctionnalités'''.
# Sur l'onglet '''Autres options''', cochez la fonctionnalité Frameworks de test unitaire DUnit pour l'ajouter à votre installation de {{Product}}.
# Sélectionnez '''Appliquer''' pour appliquer les modifications sélectionnées.

Une fois les modifications appliquées, le '''[[Gestionnaire de fonctionnalités|Gestionnaire de fonctionnalités]]''' affiche un écran '''Opération terminée'''.

==Développement de tests DUnit {{Delphi}}==

Chaque test DUnit implémente une classe de type TTestCase.

L'exemple suivant de programme {{Delphi}} Win32 définit deux fonctions qui effectuent une simple addition et soustraction :<source lang="delphi">
unit CalcUnit;

interface

type

{ TCalc }

TCalc = class
public
function Add(x, y: Integer): Integer;
function Sub(x, y: Integer): Integer;
end;

implementation

{ TCalc }

function TCalc.Add(x, y: Integer): Integer;
begin
Result := x + y;
end;

function TCalc.Sub(X, Y: Integer): Integer;
begin
Result := x - y;
end;

end.</source>

L'exemple suivant montre le fichier squelette des cas de test qu'il est nécessaire de modifier pour tester les deux fonctions, Add et Sub, du code précédent.

<source lang="delphi">
unit TestCalcUnit;

interface

uses
TestFramework, CalcUnit;
type
// Test methods for class TCalc
TestTCalc = class(TTestCase)
strict private
aTCalc: TCalc;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestAdd;
procedure TestSub;
end;

implementation

procedure TestTCalc.SetUp;
begin
aTCalc := TCalc.Create;
end;

procedure TestTCalc.TearDown;
begin
aTCalc := nil;
end;

procedure TestTCalc.TestAdd;
var
_result: System.Integer;
y: System.Integer;
x: System.Integer;
begin
_result := aTCalc.Add(x, y);
// TODO: Add testcode here
end;

procedure TestTCalc.TestSub;
var
_result: System.Integer;
y: System.Integer;
x: System.Integer;
begin
_result := aTCalc.Sub(x, y);
// TODO: Add testcode here
end;

initialisation
// Register any test cases with the test runner
RegisterTest(TestTCalc.Suite);
end.</source>

==Développement de tests DUnit C++==

Chaque test DUnit implémente une classe de type TTestCase.

L'exemple suivant (programme et fichier d'en-tête C++ Win32) définit deux fonctions qui effectuent une simple addition et soustraction :

<source lang="cpp">
#ifndef Unit7H
#define Unit7H
//-------------------------------------------------

class TCalc
{
public:
int Add(int x, int y);
int Sub(int x, int y);
};

#endif</source>

L'exemple suivant (TestUnit7.cpp) contient un cas de test pour la classe TCalc. L'expert a généré cet exemple, mais l'utilisateur devrait écrire des tests à titre d'exercice des fonctions Add et Sub. L'exemple illustre la structure DUnit des tests unitaires.

<source lang="cpp">
#include <vcl.h>
#pragma hdrstop

#include <TestFramework.hpp>

class TTestTCalc : public TTestCase
{
public:
__fastcall virtual TTestTCalc(AnsiString name) : TTestCase(name) {}
virtual void __fastcall SetUp();
virtual void __fastcall TearDown();

__published:
void __fastcall TestAdd();
void __fastcall TestSub();
};

void __fastcall TTestTCalc::SetUp()
{
}

void __fastcall TTestTCalc::TearDown()
{
}

void __fastcall TTestTCalc::TestAdd()
{
// int Add(int x, int y)
}

void __fastcall TTestTCalc::TestSub()
{
// int Sub(int x, int y)
}

static void registerTests()
{
_di_ITestSuite iSuite;
TTestSuite* testSuite = new TTestSuite("Testing Unit7.h");
if (testSuite->GetInterface(iSuite)) {
testSuite->AddTests(__classid(TTestTCalc));
Testframework::RegisterTest(iSuite);
} else {
delete testSuite;
}
}
#pragma startup registerTests 33</source>

==Fonctions DUnit==

DUnit fournit un certain nombre de fonctions utilisables dans vos tests.

{| border="1" frame="hsides" rules="rows"
|-
! '''Fonction'''
! '''Description'''
|-
| style="text-align: left; vertical-align: top;" |
Check
| style="text-align: left; vertical-align: top;" |
Vérifie si une condition a été rencontrée.
|-
| style="text-align: left; vertical-align: top;" |
CheckEquals
| style="text-align: left; vertical-align: top;" |
Vérifie si deux éléments sont égaux.
|-
| style="text-align: left; vertical-align: top;" |
CheckNotEquals
| style="text-align: left; vertical-align: top;" |
Vérifie si les éléments ne sont pas égaux.
|-
| style="text-align: left; vertical-align: top;" |
CheckNotNull
| style="text-align: left; vertical-align: top;" |
Vérifie si un élément n'est pas null.
|-
| style="text-align: left; vertical-align: top;" |
CheckNull
| style="text-align: left; vertical-align: top;" |
Vérifie si un élément est null.
|-
| style="text-align: left; vertical-align: top;" |
CheckSame
| style="text-align: left; vertical-align: top;" |
Vérifie si deux éléments ont la même valeur.
|-
| style="text-align: left; vertical-align: top;" |
EqualsErrorMessage
| style="text-align: left; vertical-align: top;" |
Vérifie si un message d'erreur émis par l'application correspond à un message d'erreur spécifié.
|-
| style="text-align: left; vertical-align: top;" |
Fail
| style="text-align: left; vertical-align: top;" |
Vérifie si une routine échoue.
|-
| style="text-align: left; vertical-align: top;" |
FailEquals
| style="text-align: left; vertical-align: top;" |
Vérifie si un échec correspond à une condition d'échec spécifiée.
|-
| style="text-align: left; vertical-align: top;" |
FailNotEquals
| style="text-align: left; vertical-align: top;" |
Vérifie si une condition d'échec est différente d'une condition d'échec spécifiée.
|-
| style="text-align: left; vertical-align: top;" |
FailNotSame
| style="text-align: left; vertical-align: top;" |
Vérifie si deux conditions d'échec ne sont pas identiques.
|-
| style="text-align: left; vertical-align: top;" |
NotEqualsErrorMessage
| style="text-align: left; vertical-align: top;" |
Vérifie si deux messages d'erreur ne sont pas identiques.
|-
| style="text-align: left; vertical-align: top;" |
NotSameErrorMessage
| style="text-align: left; vertical-align: top;" |
Vérifie si un message d'erreur ne correspond pas à un message d'erreur spécifié.
|}

Pour plus d'informations sur la syntaxe et l'utilisation de ces fonctions et des autres fonctions DUnit, voir les fichiers d'aide DUnit dans \source\dunit\doc (EN).

==Lanceurs de tests DUnit.==

Un lanceur de test vous permet d'exécuter vos tests indépendamment de votre application. Dans un projet test DUnit, le code du lanceur de test du framework DUnit est directement compilé dans l'exécutable généré, transformant ainsi le projet test lui-même en lanceur de test. Le framework DUnit intégré fournit deux lanceurs de tests :

* ''Le lanceur de test en mode GUI''. Affiche les résultats de test de manière interactive dans une fenêtre de l'interface utilisateur graphique, avec les résultats codés en couleur indiquant la réussite ou l'échec des tests.
* ''Le lanceur de test en mode console''. Oriente la sortie des tests vers la console.

Le lanceur de test DUnit en mode GUI est très utile pour développer de manière interactive les tests unitaires pour le code testé. Le lanceur de test DUnit en mode GUI affiche une barre verte sur un test qui s'est terminé avec succès, une barre rouge sur un test qui a échoué et une barre jaune sur un test qui a été ignoré.

Le lanceur de test DUnit en mode console est utile lorsque vous voulez exécuter du code achevé et des tests à partir de scripts construits de manière automatisée.

==Voir aussi==

*[[Présentation des tests unitaires|Présentation des tests unitaires]]
*[[Développement de tests|Développement de tests]]
* [http://dunit.sourceforge.net/README.html Documentation DUnit sur SourceForge (EN)]
* [https://lists.sourceforge.net/lists/listinfo/dunit-interest Groupe d'intérêt DUnit (EN)]

[[Category:Utilisation de RAD Studio]]
[[Category:Delphi]]
[[Category:C++]]

Développement de tests

2023-06-27T05:02:22Z

Yukikoi : 1 révision importée : LOC-23437

{{Parent|Présentation de DUnit}}

{{Note|DUnitX utilise des fonctionnalités du langage Delphi qui ne sont pas prises en charge dans C++. Pour les développeurs C++, DUnit est le meilleur outil. C++ peut également être testé à l'aide d'autres frameworks comme Google Test, disponible via le [[Gestionnaire de packages GetIt|Gestionnaire de packages GetIt]].}}

'''Nouveauté pour 2010 !''' [http://www.youtube.com/watch?v=nm_yq9jYckc Vidéo : {{Delphi}} Unit Tests, par Mike Rozlog] (EN)

La structure d'un test unitaire dépend en grande partie de la fonctionnalité de la classe et de la méthode que vous testez. Les experts de test unitaire génèrent des templates squelette pour le projet de test, les méthodes setup et teardown, et les cas de test de base. Vous pouvez ensuite modifier les templates, en ajoutant la logique de test spécifique permettant de tester vos méthodes particulières.

La section suivante décrit les procédures de création d'un projet de test unitaire et d'un cas de test unitaire. Suivez ces procédures dans l'ordre spécifié. Vous devez créer le projet de test unitaire avant la création des cas de test associés. '''L'expert Cas de test unitaire''' est seulement disponible si le projet actif en cours est un projet de test unitaire.

'''Pour créer un projet de test'''

# Choisissez '''Fichier > Nouveau > Autre'''.
# Ouvrez le dossier '''Test unitaire'''.
# Double-cliquez sur l'élément '''Projet de test''' de la galerie. Cela démarre '''l'expert Projet de test''' et affiche la page '''Détails du projet de test'''.
# Remplissez les informations appropriées ou acceptez les valeurs par défaut. Entrez les informations suivantes :
#* '''Projet :''' Entrez le nom du nouveau projet de test ou acceptez la valeur par défaut. La valeur par défaut est le nom du projet actif avec le mot ''Tests'' ajouté à la fin du nom. En l'absence d'un projet actif, la valeur par défaut sera ''UnitTest'' avec un numéro de séquence ajouté à la fin du nom.
#* '''Emplacement :''' Entrez le nom complet du dossier dans lequel sera créé le projet de test ou acceptez la valeur par défaut. La valeur par défaut est un sous-dossier nommé ''test'', sous le dossier du projet actif. En l'absence d'un projet actif, la valeur par défaut sera alors le dossier par défaut des projets. Vous pouvez cliquer sur les points de suspension ('''...''') pour afficher une boîte de dialogue '''Parcourir''' dans laquelle vous pouvez sélectionner l'emplacement.
#* '''Personnalité : '''Sélectionnez la personnalité (langage de code) dans la liste déroulante ou acceptez la valeur par défaut. La valeur par défaut est la personnalité du projet actif.
# Si vous ne voulez pas que le projet de test soit ajouté à votre groupe de projets, désactivez la case à cocher '''Ajouter au groupe de projets'''.
# Cliquez sur '''Suivant''' pour continuer ou sur '''Terminer''' pour accepter les valeurs par défaut restantes. Si le bouton '''Terminer''' est disponible, vous pouvez cliquer dessus à partir de n'importe quel endroit pour accepter les valeurs par défaut des champs restants et générer immédiatement le nouveau projet de test. Sinon, cliquez sur '''Suivant''' pour accéder à la page '''Options du framework de test'''.
# Remplissez les informations appropriées ou acceptez les valeurs par défaut. Entrez ce qui suit :
#* '''Framework de test :''' Pour les personnalités {{Delphi}} et C++, seul le framework DUnit est pris en charge. Vous ne pouvez donc pas modifier cette valeur.
#* '''Lanceur de test :''' Choisissez '''GUI''' ou '''Console''' dans la liste déroulante. Le lanceur de test en mode console oriente la sortie vers la console. Le lanceur de test en mode GUI affiche les résultats de manière interactive dans une fenêtre de l'interface utilisateur graphique, avec les résultats codés en couleur indiquant la réussite ou l'échec des tests.
# Cliquez sur '''Terminer'''. '''L'expert Projet de test''' génère le template de projet de test. Pour {{Delphi}}, les références nécessaires du source sont également ajoutées dans le template de projet de test ; vous pouvez ignorer l'étape suivante. Pour {{CBuilder}}, vous devez lier manuellement le projet de test aux classes C++ que vous voulez tester ; passez à l'étape suivante.
#'''Pour {{CBuilder}} seulement :''' Liez le nouveau projet de test au source à tester. Pour {{CBuilder}}, vous devez lier manuellement le projet de test au code C++ que vous voulez tester. Vous pouvez utiliser l'une des techniques suivantes, comme il convient :
#* Ajouter le code C++ directement au projet de test.
#* Ajouter un fichier .obj au projet de test.
#* Ajouter un fichier .lib (une bibliothèque statique ou une bibliothèque d'importation pour une DLL) au projet de test.
#* Inclure le fichier en-tête qui implémente la classe à tester. Pour obtenir des instructions, consultez la section suivante '''Ajout de fichiers à un projet de test'''.

'''Ajout de fichiers à un projet de test'''

# Ouvrez le fichier projet de test et activez-le. Pour activer le fichier, sélectionnez-le dans le '''Gestionnaire de projets''' et cliquez sur le bouton '''Activer'''.
# Dans le '''Gestionnaire de projets''', cliquez avec le bouton droit sur le nom du projet de test. Cela affiche un menu déroulant des opérations de projet.
# Choisissez Ajouter.... Cela affiche le navigateur de fichiers '''Ajouter au projet''', à partir duquel vous pouvez sélectionner le fichier à inclure dans votre projet de test.
# Sélectionnez le fichier à ajouter et cliquez sur '''OK'''. Cette action ajoute le fichier sélectionné au projet de test.

'''Pour créer un cas de test'''

# Cliquez sur l'onglet '''Code''' du fichier contenant les classes que vous souhaitez tester. Cela active le fichier dans '''l'éditeur de code'''.
# Choisissez '''Fichier > Nouveau > Autre'''.
# Ouvrez le dossier '''Test unitaire'''.
# Double-cliquez sur l'élément de la galerie '''Cas de test'''. Cela démarre '''l'expert Cas de test''' et affiche la page '''Sélection des méthodes à tester'''.
# Entrez le nom du fichier source contenant les classes que vous souhaitez tester. Vous pouvez cliquer sur les points de suspension ('''...''') pour afficher une boîte de dialogue '''Ouvrir''' dans laquelle vous pouvez sélectionner le fichier.
# Sélectionnez les classes et les méthodes pour lesquelles vous voulez créer des tests. Dans la liste '''Classes et méthodes disponibles''', cliquez sur la case à cocher en regard d'un élément pour le sélectionner ou le désélectionner. Par défaut, toutes les classes et méthodes sont sélectionnées. Vous pouvez désélectionner individuellement des méthodes dans la liste. L'expert génère des templates de cas de test uniquement pour les méthodes cochées (sélectionnées). Si vous désélectionnez une classe, l'expert ignore la classe entière et toutes ses méthodes, même si vous ne désélectionnez pas les méthodes. Si vous sélectionnez une classe mais ne sélectionnez pas les méthodes de cette classe, l'expert génère un cas de test pour la classe, mais ne génère aucune méthode de test pour cette classe.
# Cliquez sur '''Suivant''' pour continuer ou sur '''Terminer''' pour accepter les valeurs par défaut restantes. Si le bouton '''Terminer''' est disponible, vous pouvez cliquer dessus à partir de n'importe quel endroit pour accepter les valeurs par défaut des champs restants et générer immédiatement le nouveau cas de test. Sinon, cliquez sur '''Suivant''' pour accéder à la page '''Détails du cas de test'''.
# Remplissez les informations appropriées ou acceptez les valeurs par défaut.
#* '''Projet de test :''' Sélectionnez le projet de test dans la liste déroulante. La valeur par défaut est le projet de test actif. Si vous venez de créer un projet de test à l'aide de '''l'expert Projet de test''', le nouveau projet de test devient alors la valeur par défaut.
#* '''Fichier :''' Entrez un nom de fichier pour le cas de test que vous avez créé ou acceptez la valeur par défaut. La valeur par défaut est le nom du fichier source à tester, avec le préfixe ''Test'' ajouté à la fin du nom.
#* '''Framework de test : '''Pour les personnalités {{Delphi}} pour Win32 et C++, seul le framework DUnit est pris en charge. Vous ne pouvez donc pas modifier cette valeur.
#* '''Classe de base :''' Sélectionnez la classe de base dans la liste déroulante ou acceptez la valeur par défaut. La valeur par défaut est '''TTestCase''', c'est-à-dire la classe de base '''TestCase''' par défaut. Dans la plupart des cas, vous pouvez utiliser la valeur par défaut. Toutefois, vous pouvez spécifier une classe '''TTestCase''' personnalisée que vous avez créée. En outre, si vous testez une hiérarchie d'objets, vous pouvez dériver le nouveau cas de test de la classe '''TestCase''' d'un objet de base de l'objet en cours de test. Cela permet à une classe dérivée d'hériter d'un test créé pour le type de base de cette classe.
# Cliquez sur '''Terminer'''. L'expert génère un fichier cas de test portant le nom spécifié.

'''Pour écrire un cas de test'''

# Ajoutez du code aux méthodes SetUp et TearDown dans les templates de cas de test, si nécessaire.
# Ajoutez des assertions aux méthodes de test.

'''Pour exécuter un cas de test dans le lanceur de test en mode GUI'''

# Activez le fichier contenant les classes à exécuter. Sélectionnez le fichier dans le '''Gestionnaire de projets''', puis cliquez sur le bouton '''Activer'''.
# Choisissez '''Exécuter > Exécuter'''. Le '''lanceur de test en mode GUI''' démarre immédiatement au lancement de votre application.
# Sélectionnez un ou plusieurs tests dans la liste des tests.
# Cliquez sur le bouton '''Exécuter'''. Les résultats des tests apparaissent dans la fenêtre '''Résultats de test'''. Tous les tests signalés au moyen d'une barre verte ont été exécutés avec succès. Tous les tests signalés en rouge ont échoué. Tous les tests signalés en jaune ont été ignorés.
# Examinez les résultats des tests.
# Corrigez les erreurs et réexécutez les tests.

==Voir aussi==

*[[Présentation des tests unitaires|Présentation des tests unitaires]]
*[[Présentation de DUnit|Présentation de DUnit]]
*[http://www.youtube.com/watch?v=nm_yq9jYckc Vidéo : {{Delphi}} Unit Tests, par Mike Rozlog] (EN)

[[Category:Utilisation de RAD Studio]]
[[Category:Delphi]]
[[Category:C++]]

Périphériques Android pris en charge pour le développement d'applications

2023-06-27T05:02:22Z

Yukikoi : 1 révision importée : LOC-23437

{{Parent|Développement d'applications mobiles Android}}

==Exigences logicielles Android==

{{Variables|Product}} prend en charge le développement sur les périphériques ARMv7 et AArch64 qui exécutent les versions du système d'exploitation Android présentées dans [[Plates-formes cible prises en charge|Plates-formes cible prises en charge]].

==Exigences matérielles Android==

La plupart des matériels Android sont pris en charge. Les exigences spécifiques sont les suivantes :

* [http://www.arm.com/products/processors/cortex-a/index.php Processeur de série ARM Cortex-A ]
* Instructions ARMv7 ou ARM64
* Technologie NEON
* GPU

RAD Studio cible l'architecture de CPU la plus courante pour des performances optimales sur le plus grand nombre de périphériques possible.

'''Informations détaillées :''' Les CPU basés sur des instructions ARM sont créés par un grand nombre de fabricants en fonction de différents ensembles de spécifications. ARM est la technologie dominante pour les matériels mobiles. Le jeu d'instructions (ou coeur) ARMv7 spécifie la micro-architecture utilisée par le CPU. La famille de CPU implémentant des instructions ARMv7 est appelée Cortex-A. La plupart de ces CPU incluent également la technologie NEON.
Certains périphériques Android utilisent à la place l'architecture Intel ATOM, qui est incompatible avec FireMonkey. Les applications RAD Studio requièrent cette architecture de CPU spécifique car les apps RAD Studio recompilent le code machine pour des performances optimales. En cela elles diffèrent des autres apps Android qui sont développées avec Java et recompilent en bytecode Dalvik, puis s'exécutent sur la machine virtuelle Dalvik.
La plupart des périphériques Android ont un GPU (Graphics Processing Unit). Il arrive souvent que le GPU soit combiné au CPU dans une configuration SoC (système sur puce). Toutes ces configurations sont normalement prises en charge.

===Périphériques Android basés sur Intel===

Android KitKat et les versions supérieures s'exécutant sur les périphériques Android avec des CPU Intel incluent une bibliothèque d'émulation appelée '''libhoudini'''. La bibliothèque de traduction est invoquée automatiquement par le système d'exploitation, et permet au CPU Intel d'interpréter et d'exécuter des binaires compilés pour les CPU ARM.

Les applications FireMonkey sont généralement compatibles avec la bibliothèque '''libhoudini'''. Aucun travail supplémentaire n'est nécessaire pour ajouter la prise en charge pour l'émulation.

===Débogage===

Nous recommandons les périphériques suivants pour le débogage des applications Android 64 bits. Les fabricants et les types de périphériques Android sont nombreux. Par conséquent, tous les périphériques ne présentent pas la même capacité à déboguer une application. Nous vous conseillons de tester un périphérique pour vérifier s'il prend en charge le débogage. En général, les périphériques Android disponibles en stock, non modifiés et fournis par les principaux fournisseurs le font. Par contre, les périphériques Android ayant subi des modifications matérielles inhabituelles peuvent ne pas prendre correctement en charge le débogage. Nous recommandons la liste non exhaustive de périphériques suivants pour le débogage des applications Android 64 bits.

Pour déboguer une application 64 bits, votre périphérique doit exécuter une version 64 bits du système d'exploitation Android.

{{Note| Le fait qu'un périphérique apparaisse dans cette liste ne garantit pas qu'il prend en charge le débogage. En effet, cette capacité varie d'un périphérique à l'autre, en fonction des systèmes d'exploitation et des releases.}}

{|
|-
! Périphérique
! Version Android
! Nombre de bits du système d'exploitation
! Débogage des apps 32 bits
! Débogage des apps 64 bits
|-
|
'''Nexus 7''' (version 2)
|
6.0.1
|
32 bits
|
{{V}}
|
N/A
|-
|
'''Nexus 9'''
|
5.0.1
|
64 bits
|
{{V}}
|
{{V}}
|-
|
'''Nexus 9'''
|
7.1.1
|
64 bits
|
{{V}}
|
{{V}}
|-
|
'''Pixel''' (release originale)
|
10
|
64 bits
|
{{V}}
|
{{V}}
|-
|
'''Essential Phone 1'''
|
10
|
64 bits
|
{{V}}
|
{{V}}
|-
|
'''Nexus 6P'''
|
8.1.0
|
64 bits
|
{{V}}
|
{{V}}
|-
|
'''Pixel 3XL'''
|
10
|
64 bits
|
{{V}}
|
{{V}}
|-
|
'''Nexus 5'''
|
6.0.1
|
32 bits
|
{{V}}
|
N/A
|}

===Apps 64 bits sur matériel 32 bits===

Pour exécuter des applications Android 64 bits sur votre périphérique, ce dernier doit remplir deux conditions :

# Le téléphone doit être équipé d'un CPU 64 bits
# La version installée d'Android doit être 64 bits. Android version 5 et supérieure prennent en charge 64 bits.

Cependant, certains périphériques ne sont pas configurés pour utiliser le mode 64 bits. Si le périphérique ne prend pas en charge une application 64 bits native, un message d'erreur s'affiche.

Lorsque vous tentez de déboguer une app 64 bits depuis l'EDI sur un périphérique cible qui ne prend pas en charge une application 64 bits, un message d'erreur s'affiche.

===Comment vérifier que votre périphérique Android peut exécuter des apps 64 bits ?===

Si vous voulez vérifier que le CPU de votre périphérique Android peut exécuter des apps 64 bits, vous pouvez utiliser des applications existantes dans le Google Play Store, par exemple :

* [https://play.google.com/store/apps/details?id=com.finalwire.aida64 AIDA64] - Vérifie la page CPU
* [https://play.google.com/store/apps/details?id=com.cpuid.cpu_z CPU-Z] - Vérifie la page Système

Si elle indique que votre CPU comporte un jeu d'instructions ARMv8-A 64 bits, mais qu'il est configuré en mode 32 bits, cela implique que la version Android n'est pas 64 bits. En cas de non-concordance, le message d'erreur INSTALL_FAILED_NO_MATCHING_ABIS s'affiche.

==Test pour savoir si votre périphérique Android est pris en charge==

L'appli '''AIDA64''' fournit un moyen rapide et facile de tester la compatibilité de votre système. Si vous n'êtes pas certain que votre périphérique a les fonctionnalités requises, vous pouvez la télécharger depuis le Google Play Store et l'exécuter sur votre périphérique : [https://play.google.com/store/apps/details?id=com.finalwire.aida64 AIDA64]
'''AIDA64''' est une appli gratuite (avec publicités) et ne requiert pas de privilèges spéciaux pour son exécution.

Pour la partie CPU, vous devriez voir un écran similaire à celui-ci :

[[File:AIDA64.png|300px|link=]]

'''AIDA64''' vous informe précisément des fonctionnalités de CPU prises en charge par votre périphérique. Spécifiquement, '''AIDA64''' liste toutes les fonctionnalités CPU possibles, fournit les définitions de ces fonctionnalités, et indique si votre périphérique particulier prend en charge chacune d'elles.

Si vous voyez :

* ABI pris en charge affichant ARMv7 ou ARM64 AArch64
* Version de système d'exploitation répertoriée dans [[Plates-formes cible prises en charge|Plates-formes cible prises en charge]] (voir la section relative à Android)
* NEON est indiqué comme étant pris en charge

Alors le périphérique devrait fonctionner.

Pourquoi utiliser '''AIDA64''' ? Certaines applications peuvent uniquement être exécutées avec des chipsets spécifiques, tandis que d'autres requièrent la prise en charge de NEON pour s'exécuter correctement. Vous pouvez désormais tester votre périphérique de manière à disposer des informations dont vous avez besoin pour prendre d'autres décisions d'achat d'apps.

Par ailleurs, si vous êtes un développeur écrivant des apps Android dépendant de NEON, vous voudrez peut-être orienter vos utilisateurs vers cette app pour qu'ils puissent découvrir si leur périphérique particulier prend en charge NEON avant d'acheter votre app. Vous pourrez ainsi contribuer à réduire la confusion de l'utilisateur et les demandes de retour.

{{Attention|Embarcadero n'a pas d'informations sur l'origine de l'application et ne peut pas garantir que les apps ne contiennent pas de programme malveillant.}}

==Voir aussi==

* [[Prérequis de plate-forme FireMonkey|Prérequis de plate-forme {{FM}}]]
* [[Configuration de votre système pour détecter votre périphérique Android|Configuration de votre système pour détecter votre périphérique Android]]
* [[Exécution de votre application Android sur un périphérique Android|Exécution de votre application Android sur un périphérique Android]]
* [[Plates-formes cible prises en charge|Plates-formes cible supportées]]

[[Category:XE5]]
[[Category:Android]]
[[Category:AMMigrate]]

Présentation des tests unitaires

2023-06-27T05:02:16Z

Yukikoi : LOC-23437

Test des applications - Index

2023-06-27T05:02:16Z

Yukikoi : LOC-23437

Exécution et débogage de votre application Android sur un périphérique Android à distance

2023-06-27T05:02:16Z

Yukikoi : LOC-23437

Présentation de DUnit

2023-06-27T05:02:16Z

Yukikoi : LOC-23437

Développement de tests

2023-06-27T05:02:16Z

Yukikoi : LOC-23437

Périphériques Android pris en charge pour le développement d'applications

2023-06-27T05:02:16Z

Yukikoi : LOC-23437

Moteur de bases de données Borland

2023-06-27T02:35:46Z

Yukikoi : Yukikoi a déplacé la page Moteur de bases de données Borland vers BDE

#REDIRECTION [[BDE]]

BDE

2023-06-27T02:35:46Z

Yukikoi : Yukikoi a déplacé la page Moteur de bases de données Borland vers BDE

{{Parent|Déploiement des applications BDE}}

<blockquote>Avertissement :
* [http://www.embarcadero.com/rad-in-action/migration-upgrade-center http://www.embarcadero.com/rad-in-action/migration-upgrade-center]
* [http://edn.embarcadero.com/article/29106 EDN: "Migrating BDE Applications to dbExpress"]
* [http://blog.marcocantu.com/blog/BDE_to_dbExpress.html Marco Cantu's Blog entries]
* [http://stackoverflow.com/questions/9161583/delphi-migrating-from-bde-to-dbexpress-tutorial Q&A: "{{Delphi}}: Migrating from BDE to DBExpress Tutorial"]
</blockquote>

Vous pouvez utiliser le moteur de bases de données Borland (BDE) pour que les composants de données standard {{Delphi}} aient accès aux bases de données. Consultez le document BDEDEPLOY pour obtenir les restrictions et les droits spécifiques sur la redistribution du BDE (voir C:\Program Files\Common Files\Borland Shared\BDE).

Vous devez utiliser InstallAware Express (ou un autre programme d'installation certifié) pour l'installation du BDE. InstallAware Express crée les entrées de registre nécessaires et définit les alias nécessaires à l'application. Il est important d'utiliser un programme certifié pour déployer les fichiers BDE car :

* Une installation incorrecte du BDE ou des sous-ensembles BDE peut empêcher le fonctionnement d'autres applications utilisant le BDE. Ces applications sont des produits {{Company}}, mais également des programmes tiers utilisant le BDE.
* Sous Windows 32 bits 95/NT ou plus, les informations de configuration BDE sont stockées dans les registres Windows et non pas dans des fichiers .ini, comme c'était le cas avec Windows 16 bits. La création ou la suppression de ces entrées lors de l'installation ou de la désinstallation est une tâche complexe.

Il est possible de n'installer que la partie du BDE nécessaire à une application. Si, par exemple, une application n'utilise que des tables Paradox, il est seulement nécessaire d'installer la partie du BDE indispensable à l'accès aux tables Paradox. Cela réduit l'espace disque nécessaire à une application. Les programmes d'installation certifiés, comme InstallAware Express, sont capables d'effectuer une installation partielle du BDE. Il faut prendre garde à laisser intact les fichiers système BDE inutilisés par l'application installée mais nécessaires à d'autres programmes déjà installés.

==Voir aussi==

* [[Présentation de BDE|Présentation de BDE]]
* [[Utilisation du BDE|Utilisation du BDE]]
* [[Composants dbExpress|Composants dbExpress]]

{{DEFAULTSORT:Moteur de bases de donnees Borland}}
[[Category:Guide du développeur Windows]]
[[Category:C++]]
[[Category:Delphi]]

[[en:BDE]]
[[de:Borland Database Engine]]
[[ja:ボーランドデータベースエンジン]]

Tableaux sécurisés

2021-06-25T03:29:59Z

Yukikoi : LOC-23362

{{Parent|Utilisation de la syntaxe Delphi ou RIDL}}

COM requiert que les tableaux soient transmis via un type de données spécial appelé SafeArray. Vous pouvez créer et détruire les SafeArrays en appelant des fonctions COM particulières, et tous les éléments d'un SafeArray doivent être de [[Types autorisés|types compatibles automation-valides]]. Le compilateur {{Delphi}} dispose d'informations intégrées sur les SafeArrays COM et appellera automatiquement l'API COM pour créer, copier et détruire des SafeArrays.

'''{{Delphi}}:'''
<source lang="delphi">
procedure HighLightLines(Lines: PSafeArray);
</source><l e="delphi" /><l s="cpp" />'''C++:'''
<source lang="cpp">
HRESULT STDMETHODCALLTYPE HighlightLines(LPSAFEARRAY Lines)
</source><l e="cpp" />

Dans '''l'éditeur de bibliothèques de types''', un ''SafeArray'' doit spécifier le type de ses éléments. Par exemple, la ligne suivante de la page Texte déclare une méthode avec un paramètre ''SafeArray'' avec un élément de type Integer :

<source lang="delphi">
HRESULT _stdcall HighlightLines(SAFEARRAY(long) Lines);
</source>

<blockquote>{{Note| Même si vous devez spécifier le type de l'élément lors de la déclaration d'un type ''SafeArray'' dans '''l'éditeur de bibliothèques de types''', la déclaration du fichier unité _TLB généré n'indique pas le type de l'élément.}}</blockquote>

==Voir Aussi==

*[[Types autorisés|Types autorisés]]

[[Category:Guide du développeur Windows]]
[[Category:Delphi]]
[[Category:C++]]

Tableaux sécurisés

2021-06-25T03:28:43Z

Yukikoi : 1 révision importée : LOC-23362

Méthodes (Delphi)

2020-08-26T10:14:48Z

Yukikoi : LOC-RS82965

{{Parent|Classes et objets - Index}}
__TOC__
<ideTag id="reintroduce"></ideTag>
<ideTag id="overload"></ideTag>
<ideTag id="abstract"></ideTag>
<ideTag id="virtual"></ideTag>
<ideTag id="dynamic"></ideTag>
<ideTag id="register"></ideTag>
<ideTag id="pascal"></ideTag>
<ideTag id="cdecl"></ideTag>
<ideTag id="stdcall"></ideTag>
<ideTag id="safecall"></ideTag>
<ideTag id="platform"></ideTag>
<ideTag id="deprecated"></ideTag>
<ideTag id="library"></ideTag>
<ideTag id="inherited"></ideTag>
<ideTag id="Self"></ideTag>
<ideTag id="static"></ideTag>
<ideTag id="override"></ideTag>
<ideTag id="final"></ideTag>
<ideTag id="class"></ideTag>
<ideTag id="read"></ideTag>
<ideTag id="write"></ideTag>
<ideTag id="constructor"></ideTag>
<ideTag id="nill"></ideTag>
<ideTag id="if"></ideTag>
<ideTag id="destructor"></ideTag>
<ideTag id="message"></ideTag>
<ideTag id="DefaultHandler"></ideTag>
<ideTag id="Dispatch"></ideTag>
Une méthode est une procédure ou une fonction associée à une classe. Un appel de méthode spécifie l'objet (ou la classe si c'est une méthode de classe) sur lequel la méthode agit. Par exemple, SomeObject.Free appelle la méthode Free de SomeObject.

Cette rubrique couvre les sujets suivants :

* Déclarations et implémentations de méthodes
* Liaison de méthodes
* Surcharge de méthodes
* Constructeurs et destructeurs
* Méthodes de messages

==A propos des méthodes==

Au sein d'une déclaration de classe, les méthodes apparaissent comme des en-têtes de procédures ou de fonctions qui fonctionnent comme les déclarations '''forward'''. Quelque part après la déclaration de classe, mais à l'intérieur du même module, chaque méthode doit être implémentée par une déclaration de définition. Si; par exemple, la déclaration de TMyClass contient une méthode appelée DoSomething :

<source lang="delphi">
type
TMyClass = class(TObject)
...
procedure DoSomething;
...
end;
</source>

Une déclaration de définition pour DoSomething doit apparaître plus loin dans le module :

<source lang="delphi">
procedure TMyClass.DoSomething;
begin
...
end;
</source>

Si une classe peut être déclarée dans la section interface ou la section implementation d'une unité, les déclarations de définition des méthodes de classe doivent se trouver dans la section implementation.

Dans l'en-tête d'une déclaration de définition, le nom de la méthode est toujours qualifié par le nom de la classe à laquelle elle appartient. L'en-tête peut répéter la liste de paramètres depuis la déclaration de classe ; si c'est le cas, l'ordre, le type et le nom des paramètres doivent correspondre exactement et, si la méthode est une fonction, la valeur de retour doit aussi correspondre.

Les déclarations des méthodes peuvent inclure des directives spéciales qui ne sont pas utilisées par d'autres fonctions ou procédures. Les directives doivent apparaître uniquement dans la déclaration de classe et pas dans la déclaration de définition, et doivent toujours être dans l'ordre suivant :

'''reintroduce'''; '''overload'''; [[#Liaison de méthode|liaison]]; [[Procédures et fonctions (Delphi)#Conventions d'appel|convention d'appel]]; '''abstract'''; [[Déclarations et instructions (Delphi)#Directives de conseil|avertissement]]

Où :

* [[#Liaison de méthode|liaison]] correspond à '''virtual''', '''dynamic''' ou '''override''' ;
* [[Procédures et fonctions (Delphi)#Conventions d'appel|convention d'appel]] correspond à '''register''', '''pascal''', '''cdecl''', '''stdcall''', or '''safecall''';
* [[Déclarations et instructions (Delphi)#Directives de conseil|avertissement]] correspond à '''platform''', '''deprecated''' ou '''library'''. Pour plus d'informations sur ces directives d'avertissement (de conseil), voir [[Déclarations et instructions (Delphi)#Directives de conseil|Directives de conseil]].

Toutes les directives {{Delphi}} sont listées dans [[Eléments syntaxiques fondamentaux (Delphi)#Directives|Directives]].

===Inherited===

Le mot réservé '''inherited''' joue un rôle particulier dans l'implémentation de comportements polymorphiques. Il peut apparaître dans une définition de méthode avec ou sans identificateur à la suite.

Si '''inherited''' est suivi par le nom d'un membre, il représente un appel de méthode normal ou une référence à une propriété ou à un champ, sauf que la recherche du membre référencé commence avec l'ancêtre immédiat de la classe de la méthode englobante. Par exemple, quand l'instruction :

<source lang="delphi">
inherited Create(...);
</source>

apparaît dans la définition d'une méthode, elle appelle la méthode Create héritée.

Quand '''inherited''' est utilisé sans être suivi d'un identificateur, il désigne la méthode héritée portant le même nom que la méthode en cours ou, si la méthode en cours est un gestionnaire de message, le gestionnaire de message hérité pour le même message. Dans ce cas, '''inherited''' ne prend pas de paramètres explicites, mais transmet à la méthode héritée les paramètres utilisés pour l'appel de la méthode englobante. Par exemple :

<source lang="delphi">
inherited;
</source>

apparaît fréquemment dans l'implémentation des constructeurs. Cette instruction appelle le constructeur hérité avec les mêmes paramètres que ceux transmis au descendant.

===Self===

Au sein de l'implémentation d'une méthode, l'identificateur '''Self''' référence l'objet dans lequel la méthode est appelée. Voici, par exemple, l'implémentation de la méthode Add de TCollection dans l'unité Classes :

<source lang="delphi">
function TCollection.Add: TCollectionItem;
begin
Result := FItemClass.Create(Self);
end;
</source>

La méthode Add appelle la méthode Create de la classe référencée par le champ FItemClass, qui est toujours un descendant de TCollectionItem. TCollectionItem.Create ne prend qu'un seul paramètre de type TCollection, donc Add le transmet à l'objet instance de TCollection où Add est appelée. Cela est illustré dans le code suivant :

<source lang="delphi">
var MyCollection: TCollection;
...
MyCollection.Add // MyCollection is passed to the
// TCollectionItem.Create method
</source>

'''Self''' est utile pour diverses raisons. Par exemple, un identificateur de membre déclaré dans un type classe peut être redéclaré dans le bloc de l'une des méthodes de la classe. Dans ce cas, vous pouvez accéder à l'identificateur du membre d'origine en utilisant Self.Identifier.

Pour plus d'informations sur '''Self''' dans les méthodes de classe, voir "Opérateurs de classes" dans [[Références de classes|Références de classes]].

==Liaison de méthode==

Les liaisons de méthodes peuvent être '''statiques''' (par défaut), '''virtuelles''' ou '''dynamiques'''. Les méthodes virtuelles et dynamiques peuvent être redéfinies et elles peuvent être abstraites. Ces désignations jouent un rôle quand une variable d'un type classe contient une valeur d'un type classe descendant. Elles déterminent quelle implémentation est activée lors de l'appel d'une méthode.

===Méthodes statiques===

Par défaut les méthodes sont statiques. Quand une méthode statique est appelée, le type déclaré (à la compilation) de la variable classe ou objet utilisé dans l'appel de la méthode détermine l'implémentation à activer. Dans l'exemple suivant, les méthodes Draw sont statiques :

<source lang="delphi">
type
TFigure = class
procedure Draw;
end;

TRectangle = class(TFigure)
procedure Draw;
end;
</source>

Etant donné ces déclarations, le code suivant illustre l'effet de l'appel d'une méthode statique. Dans le second appel à Figure.Draw, la variable Figure référence un objet de classe TRectangle, mais l'appel invoque l'implémentation de Draw dans TFigure, car le type déclaré de la variable Figure est TFigure :

<source lang="delphi">
var
Figure: TFigure;
Rectangle: TRectangle;

begin
Figure := TFigure.Create;
Figure.Draw; // calls TFigure.Draw
Figure.Destroy;
Figure := TRectangle.Create;
Figure.Draw; // calls TFigure.Draw

TRectangle(Figure).Draw; // calls TRectangle.Draw

Figure.Destroy;
Rectangle := TRectangle.Create;
Rectangle.Draw; // calls TRectangle.Draw
Rectangle.Destroy;
end;
</source>

===Méthodes virtuelles et dynamiques===

Pour rendre une méthode '''virtuelle''' ou '''dynamique''', incluez la directive '''virtual''' ou '''dynamic''' dans sa déclaration. Les méthodes dynamiques et virtuelles, à la différence des méthodes statiques, peuvent être redéfinies dans les classes descendantes. Quand une méthode redéfinie est appelée, le type réel (à l'exécution) de la classe ou de l'objet utilisé dans l'appel de la méthode, et non pas le type déclaré de la variable, détermine l'implémentation à activer.

Pour redéfinir une méthode, redéclarez-la avec la directive '''override'''. Une déclaration '''override''' doit correspondre à la déclaration de l'ancêtre dans l'ordre et le type de ses paramètres, ainsi que dans son type de résultat (le cas échéant).

Dans l'exemple suivant, la méthode Draw déclarée dans TFigure est redéfinie dans deux classes descendantes :

<source lang="delphi">
type
TFigure = class
procedure Draw; virtual;
end;

TRectangle = class(TFigure)
procedure Draw; override;
end;

TEllipse = class(TFigure)
procedure Draw; override;
end;
</source>

Etant donné ces déclarations, le code suivant illustre l'effet de l'appel d'une méthode virtuelle via une variable dont le type réel change à l'exécution :

<source lang="delphi">
var
Figure: TFigure;

begin
Figure := TRectangle.Create;
Figure.Draw; // calls TRectangle.Draw
Figure.Destroy;
Figure := TEllipse.Create;
Figure.Draw; // calls TEllipse.Draw
Figure.Destroy;
end;
</source>

Seules les méthodes '''virtuelles''' et '''dynamiques''' peuvent être redéfinies. Par contre, toutes les méthodes peuvent être surchargées ; voir [[#Surcharge des méthodes|Surcharge des méthodes]].

====Méthodes finales====

Le compilateur {{Delphi}} prend aussi en charge le concept de méthodes virtuelles et dynamiques '''finales'''. Les déclarations des méthodes finales ont la forme suivante :

function|procedure FunctionName; virtual|dynamic; final;

Ici, la syntaxe <code>virtual|dynamic</code> (deux mots clé et le symbole <code>|</code> entre les mots clés) est utilisée pour spécifier qu'un seul des mots clés '''virtual''' ou '''dynamic''' doit être utilisé. Seul le mot clé '''virtual''' ou '''dynamic''' n'a de sens; le symbole de tuyau lui-même doit être supprimé.

Seul le mot clé '''final''' est appliqué à une méthode virtuelle ou dynamique, aucune classe descendante ne peut redéfinir cette methode. L'usage du mot clé '''final''' est une décision de conception importante qui permet de définir l'utilisation de la classe. Il peut aussi donner au compilateur des conseils lui permettant d'optimiser le code produit.

<blockquote>'''Remarque :''' Les mots clés '''virtual''' ou '''dynamic''' doivent être écrits avant le mot clé '''final'''.</blockquote>

'''Exemple'''
<source lang="delphi">
type
Base = class
procedure TestProcedure; virtual;
procedure TestFinalProcedure; virtual; final;
end;

Derived = class(Base)
procedure TestProcedure; override;
//Ill-formed: E2352 Cannot override a final method
procedure TestFinalProcedure; override;
end;
</source>

====Comparaison des méthodes virtuelles et des méthodes dynamiques====

Dans {{Delphi}} pour Win32, d'un point de vue sémantique, les méthodes virtuelles et les méthodes dynamiques sont équivalentes. Toutefois, elles diffèrent dans l'implémentation de la répartition de l'appel de méthode à l'exécution : les méthodes virtuelles optimisent la rapidité alors que les méthodes dynamiques optimisent la taille du code.

En général, les méthodes virtuelles constituent la manière la plus efficace d'implémenter un comportement polymorphique. Les méthodes dynamiques sont utiles quand une classe de base déclare de nombreuses méthodes pouvant être redéfinies qui sont héritées par de nombreuses classes descendantes d'une application, mais rarement redéfinies.

<blockquote>'''Remarque :''' N'utilisez les méthodes dynamiques que s'il existe un avantage clair et visible de le faire. Utilisez habituellement les méthodes virtuelles.</blockquote>

====Redéfinition ou dissimulation====

Si une déclaration de méthode spécifie le même identificateur de méthode et la même signature de paramètre qu'une méthode héritée, sans spécifier '''override''', la nouvelle déclaration masque ou dissimule simplement la méthode héritée sans la redéfinir. Les deux méthodes existent alors dans la classe descendante, où le nom de méthode est lié statiquement. Par exemple :

<source lang="delphi">
type
T1 = class(TObject)
procedure Act; virtual;
end;

T2 = class(T1)
procedure Act; // Act is redeclared, but not overridden
end;

var
SomeObject: T1;

begin
SomeObject := T2.Create;
SomeObject.Act; // calls T1.Act
end;
</source>

====Reintroduce====

La directive '''reintroduce''' supprime les avertissements du compilateur informant qu'une méthode virtuelle précédemment déclarée est masquée. Par exemple :

<source lang="delphi">
procedure DoSomething; reintroduce; // The ancestor class also
// has a DoSomething method
</source>

Utilisez '''reintroduce''' quand vous voulez masquer une méthode virtuelle héritée par une nouvelle méthode.

====Méthodes abstraites====

Une méthode abstraite est une méthode virtuelle ou dynamique n'ayant pas d'implémentation dans la classe où elle est déclarée. Son implémentation est déléguée à une classe descendante. Les méthodes abstraites doivent être déclarées en spécifiant la directive '''abstract''' après '''virtual''' ou '''dynamic'''. Par exemple :

<source lang="delphi">
procedure DoSomething; virtual; abstract;
</source>

Vous ne pouvez appeler une méthode '''abstraite''' que dans une classe ou une instance d'une classe dans laquelle la méthode a été redéfinie.

==Méthodes de classe==

La plupart des méthodes sont appelées méthodes d'instance, car elles opèrent sur une instance individuelle d'un objet. Une méthode de classe est une méthode (autre qu'un constructeur) qui agit sur des classes et pas sur des objets. Il existe deux types de méthodes de classe : les méthodes de classe ordinaires et les méthodes statiques de classe.

===Méthodes de classe ordinaires===

La définition d'une méthode de classe doit commencer par le mot réservé '''class'''. Par exemple :

<source lang="delphi">
type
TFigure = class
public
class function Supports(Operation: string): Boolean; virtual;
class procedure GetInfo(var Info: TFigureInfo); virtual;
...
end;
</source>

La déclaration de définition d'une méthode de classe doit aussi commencer par '''class'''. Par exemple :

<source lang="delphi">
class procedure TFigure.GetInfo(var Info: TFigureInfo);
begin
...
end;
</source>

Dans la déclaration de définition d'une méthode de classe, l'identificateur '''Self''' représente la classe où la méthode est appelée (ce peut être un descendant de la classe dans laquelle elle est définie). Si la méthode est appelée dans la classe C, alors '''Self''' est de type class of C. Vous ne pouvez donc pas utiliser '''Self''' pour accéder à des champs d'instance, des propriétés d'instance et des méthodes normales (objet). Vous pouvez utiliser '''Self''' pour appeler les constructeurs ou d'autres méthodes de classe, ou pour accéder aux propriétés de classe et aux champs de classe.

Une méthode de classe peut être appelée via une référence de classe ou une référence d'objet. Quand elle est appelée via une référence d'objet, la classe de l'objet devient la valeur de '''Self'''.

===Méthodes statiques de classe===

Comme les méthodes de classe, les méthodes statiques de classe peuvent être accessibles sans une référence d'objet. A la différence des méthodes de classe ordinaires, les méthodes statiques de classe n'ont pas de paramètre '''Self'''. Elles ne peuvent pas accéder aux membres d'instance. Elles peuvent toujours accéder aux champs de classe, aux propriétés de classe et aux méthodes de classe. En outre, contrairement aux méthodes de classe, les méthodes statiques de classe ne peuvent pas être déclarées '''virtual'''.

Pour rendre une méthode de classe statique, ajoutez le mot '''static''' à leur déclaration, par exemple :

<source lang="delphi">
type
TMyClass = class
strict private
class var
FX: Integer;

strict protected
// Note: Accessors for class properties
// must be declared class static.
class function GetX: Integer; static;
class procedure SetX(val: Integer); static;

public
class property X: Integer read GetX write SetX;
class procedure StatProc(s: String); static;
end;
</source>

Comme pour une méthode de classe, vous pouvez appeler une méthode statique de classe par l'intermédiaire du type de la classe (par exemple, sans référence d'objet), comme suit :

<source lang="delphi">
TMyClass.X := 17;
TMyClass.StatProc('Hello');
</source>

==Surcharge des méthodes==

Une méthode peut être redéclarée en utilisant la directive '''overload'''. Dans ce cas, si la méthode redéclarée a une signature de paramètre différente de celle de son ancêtre, elle surcharge la méthode héritée sans la cacher. L'appel de la méthode dans une classe descendante active l'implémentation qui correspond aux paramètres de l'appel.

Si vous surchargez une méthode virtuelle, utilisez la directive '''reintroduce''' quand vous la redéclarez dans les classes descendantes. Par exemple :

<source lang="delphi">
type
T1 = class(TObject)
procedure Test(I: Integer); overload; virtual;
end;

T2 = class(T1)
procedure Test(S: string); reintroduce; overload;
end;
...

SomeObject := T2.Create;
SomeObject.Test('Hello!'); // calls T2.Test
SomeObject.Test(7); // calls T1.Test
</source>

Dans une classe, vous ne pouvez pas publier plusieurs méthodes surchargées portant le même nom. La maintenance des informations de type à l'exécution requiert un nom unique pour chaque membre '''publié''' :

<source lang="delphi">
type
TSomeClass = class
published
function Func(P: Integer): Integer;
function Func(P: Boolean): Integer; // error
...
</source>

Les méthodes qui servent de spécificateurs de '''lecture''' ou d''''écriture''' de propriétés ne peuvent pas être surchargées.

L'implémentation d'une méthode surchargée doit répéter la liste des paramètres depuis la déclaration de classe. Pour davantage d'informations sur la surcharge, voir [[Procédures et fonctions (Delphi)#Surcharge de procédures et de fonctions|Surcharge de procédures et de fonctions]] dans [[Procédures et fonctions (Delphi)|Procédures et fonctions (Delphi)]].

==Constructeurs==

Un constructeur est une méthode spéciale qui crée et initialise des instances d'objet. La déclaration d'un constructeur ressemble à celle d'une procédure, sauf qu'elle commence par le mot '''constructor'''. Exemples :

<source lang="delphi">
constructor Create;
constructor Create(AOwner: TComponent);
</source>

Les constructeurs doivent utiliser la convention d'appel '''register''' par défaut. Bien que la déclaration ne spécifie pas de valeur de retour, un constructeur renvoie une référence à l'objet qu'il a créé ou qui est appelé.

Une classe peut avoir plusieurs constructeurs mais doit en avoir au moins un. L'habitude veut qu'on appelle le constructeur Create.

Pour créer un objet, appelez la méthode constructeur sur un type classe. Par exemple :

<source lang="delphi">
MyObject := TMyClass.Create;
</source>

Cette instruction alloue le stockage pour le nouvel objet, définit la valeur de tous les champs ordinaux sur zéro, assigne '''nil''' à tous les champs de type pointeur ou de type classe, et une chaîne vide à tous les champs chaîne. Les autres actions spécifiées dans l'implémentation du constructeur sont effectuées ensuite. Généralement, les objets sont initialisés en fonction des valeurs transmises comme paramètres au constructeur. Enfin, le constructeur renvoie une référence à l'objet qui vient d'être créé et initialisé. Le type de la valeur de retour est le même que le type classe spécifié dans l'appel du constructeur.

Si une exception est déclenchée lors de l'exécution d'un constructeur invoqué sur une référence de classe, le destructeur Destroy est appelé automatiquement pour détruire l'objet inachevé.

Quand un constructeur est appelé en utilisant une référence d'objet (au lieu d'une référence de classe), il ne crée pas d'objet. Le constructeur agit à la place sur l'objet spécifié, en n'exécutant que les instructions de l'implémentation du constructeur et renvoie ensuite une référence à l'objet. Un constructeur est typiquement invoqué sur une référence d'objet en conjonction avec le mot réservé '''inherited''' afin d'exécuter un constructeur hérité.

Voici un exemple du type classe et de son constructeur :

<source lang="delphi">
type
TShape = class(TGraphicControl)
private
FPen: TPen;
FBrush: TBrush;
procedure PenChanged(Sender: TObject);
procedure BrushChanged(Sender: TObject);
public
constructor Create(Owner: TComponent); override;
destructor Destroy; override;
...
end;

constructor TShape.Create(Owner: TComponent);
begin
inherited Create(Owner); // Initialize inherited parts
Width := 65; // Change inherited properties
Height := 65;
FPen := TPen.Create; // Initialize new fields
FPen.OnChange := PenChanged;
FBrush := TBrush.Create;
FBrush.OnChange := BrushChanged;
end;
</source>

Généralement, la première action d'un constructeur est d'appeler le constructeur hérité afin d'initialiser les champs hérités de l'objet. Le constructeur initialise ensuite les champs introduits dans la classe descendante. Comme un constructeur efface toujours le stockage alloué à un nouvel objet, tous les champs contiennent au départ zéro (pour les types ordinaux), '''nil''' (types pointeur et classe), chaîne vide (types chaîne) ou Unassigned (variants). Il n'est donc pas nécessaire que l'implémentation du constructeur initialise les champs sauf ceux devant contenir une valeur non nulle ou non vide.

Quand il est invoqué par le biais d'un identificateur de type classe, un constructeur déclaré comme '''virtual''' est équivalent à un constructeur statique. Quand ils sont combinés avec des types référence de classe, les constructeurs virtuels permettent une construction polymorphique des objets, c'est-à-dire la construction d'objets dont le type est inconnu à la compilation. (Voir [[Références de classes|Références de classes]].)

==Destructeurs==

Un destructeur est une méthode spéciale qui détruit l'objet à l'endroit de son appel et libère sa mémoire. La déclaration d'un destructeur ressemble à celle d'une procédure, mais elle commence par le mot '''destructor'''. Exemple :

<source lang="delphi">
destructor SpecialDestructor(SaveData: Boolean);
destructor Destroy; override;
</source>

Les destructeurs sur Win32 doivent utiliser la convention d'appel '''register''' par défaut. Même si une classe peut avoir plusieurs destructeurs, il est conseillé que chaque classe redéfinisse la méthode Destroy héritée et ne déclare pas d'autres destructeurs.

Pour appeler un destructeur, vous devez référencer une instance d'objet. Par exemple :

<source lang="delphi">
MyObject.Destroy;
</source>

Lors de l'appel d'un destructeur, les actions spécifiées dans l'implémentation du destructeur sont d'abord exécutées. Typiquement, cela consiste à détruire les objets incorporés et à libérer les ressources allouées par l'objet. Ensuite, le stockage alloué à l'objet est libéré.

Voici un exemple d'implémentation d'un destructeur :

<source lang="delphi">
destructor TShape.Destroy;
begin
FBrush.Free;
FPen.Free;
inherited Destroy;
end;
</source>

Typiquement, la dernière action de l'implémentation d'un destructeur est l'appel du destructeur hérité afin de détruire les champs hérités de l'objet.

Quand une exception est déclenchée lors de la création d'un objet, Destroy est appelée automatiquement afin de libérer l'objet inachevé. Cela signifie que Destroy doit être préparé à libérer des objets partiellement construits. Comme un constructeur définit les champs d'un nouvel objet sur zéro ou sur des valeurs vides avant d'effectuer d'autres actions, les champs de type classe ou pointeur d'un objet partiellement construit sont toujours définis sur '''nil'''. Un destructeur doit donc tester les valeurs '''nil''' avant d'agir sur des champs de type classe ou pointeur. L'appel de la méthode '''Free''' (définie dans TObject) au lieu de Destroy, permet de tester facilement les valeurs '''nil''' avant de détruire un objet.

==Constructeurs de classes==

Un constructeur de classe est une méthode de classe spéciale qui n'est pas accessible aux développeurs. Les appels des constructeurs de classes sont automatiquement insérés par le compilateur dans la section d'initialisation de l'unité où la classe est définie. Normalement, les constructeurs de classes sont utilisés pour initialiser les champs statiques de la classe ou effectuer un type d'initialisation, nécessaire avant que la classe ou toute instance de classe puisse fonctionner correctement. Bien que le même résultat puisse être obtenu en plaçant le code d'initialisation de la classe dans la section ''initialization'', les constructeurs de classes ont l'avantage d'aider le compilateur à déterminer les classes qui doivent être incluses dans le fichier binaire final et celles qui doivent être retirées.

L'exemple suivant illustre la façon habituelle d'initialiser les champs de classes :

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
end;

implementation

initialization
{ Initialize the static FList member }
TBox.FList := TList<Integer>.Create();

end.
</source>

Cette méthode a un gros désavantage : même si une application peut inclure l'unité dans laquelle '''TBox''' est déclaré, elle ne peut jamais réellement utiliser la classe '''TBox'''. Dans l'exemple en cours, la classe TBox est incluse dans le binaire résultant, car elle est référencée dans la section initialization. Pour alléger ce problème, considérons l'utilisation des constructeurs de classes :

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
class constructor Create;
end;

implementation

class constructor TBox.Create;
begin
{ Initialize the static FList member }
FList := TList<Integer>.Create();
end;

end.
</source>

Dans ce cas, le compilateur vérifie si TBox est réellement utilisé quelque part dans l'application, et en cas d'utilisation, un appel au constructeur de classe est ajouté automatiquement à la section initialization de l'unité.

'''Remarque :''' Même si le compilateur fait attention à l'ordre d'initialisation des classes, l'ordre peut devenir aléatoire dans certains scénarios complexes. Cela se produit quand le constructeur d'une classe dépend de l'état d'une autre classe qui, à son tour, dépend de la première classe.

'''Remarque :''' Le constructeur de classe relatif à un enregistrement ou une classe générique peut s'exécuter plusieurs fois. Le nombre exact de fois que le constructeur de classe est exécuté dans ce cas dépend du nombre de versions spécialisées du type générique. Par exemple, le constructeur de classe pour une classe ''TList<String>'' spécialisée peut s'exécuter plusieurs fois dans la même application.

==Destructeurs de classes==

Les destructeurs de classes sont l'opposé des constructeurs de classes, dans le fait qu'ils réalisent la finalisation de la classe. Les destructeurs de classes présentent les mêmes avantages que les constructeurs de classes, à l'exception des fonctions de ''finalisation''.

L'exemple suivant est construit sur l'exemple présenté dans les constructeurs de classes et il introduit la routine de finalisation :

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
class constructor Create;
class destructor Destroy;
end;

implementation

class constructor TBox.Create;
begin
{ Initialize the static FList member }
FList := TList<Integer>.Create();
end;

class destructor TBox.Destroy;
begin
{ Finalize the static FList member }
FList.Free;
end;

end.
</source>

'''Remarque :''' Le destructeur de classe relatif à un enregistrement ou une classe générique peut s'exécuter plusieurs fois. Le nombre exact de fois que le destructeur de classe est exécuté dans ce cas dépend du nombre de versions spécialisées du type générique. Par exemple, le destructeur de classe pour une classe ''TList<String>'' spécialisée peut s'exécuter plusieurs fois dans la même application.

==Méthodes de messages==

Les méthodes de messages implémentent des réponses à des messages répartis dynamiquement. La syntaxe des méthodes de messages est supportée sur toutes les plates-formes. <f s="vcl" t="span" />La VCL utilise des méthodes de messages pour répondre aux messages Windows. <f e="vcl" t="span" />

Une méthode de message est créée en incluant la directive '''message''' dans une déclaration de méthode, suivie d'une constante entière comprise entre 1 et 49151 qui spécifie l'identificateur du message. <f s="vcl" t="span" /> Pour les méthodes de messages des contrôles VCL, la constante entière peut être l'un des identificateurs de messages Win32, avec les types d'enregistrements correspondants, dans l'unité Messages. <f e="vcl" t="span" /> Une méthode de message doit être une procédure qui n'attend qu'un seul paramètre '''var'''.

Par exemple :

<source lang="delphi">
type
TTextBox = class(TCustomControl)
private
procedure WMChar(var Message: TWMChar); message WM_CHAR;
...
end;
</source>

Une méthode de message n'a pas besoin d'inclure la directive '''override''' pour redéfinir une méthode de message héritée. En fait, il n'est pas nécessaire de spécifier le même nom de méthode ou type de paramètre que la méthode qu'elle redéfinit. L'identificateur du message détermine seul les messages auxquels la méthode répond et s'il s'agit d'une redéfinition.

===Implémentation des méthodes de messages===

L'implémentation d'une méthode de message peut appeler la méthode de message héritée, comme dans l'exemple suivant :

<source lang="delphi">
procedure TTextBox.WMChar(var Message: TWMChar);
begin
if Message.CharCode = Ord(#13) then
ProcessEnter
else
inherited;
end;
</source>

L'instruction '''inherited''' effectue une recherche arrière dans la hiérarchie des classes et invoque la première méthode de message ayant le même identificateur que la méthode en cours, et lui transmet automatiquement l'enregistrement message. Si aucune classe ancêtre n'implémente de méthode de message pour l'identificateur spécifié, '''inherited''' appelle la méthode DefaultHandler définie initialement dans TObject.

L'implémentation de DefaultHandler dans TObject rend simplement le contrôle sans rien faire. En redéfinissant DefaultHandler, une classe peut implémenter sa propre gestion par défaut des messages. Sous Win32, la méthode DefaultHandler pour les contrôles appelle DefWindowProc de l'API Win32.

===Répartition des messages===

Les gestionnaires de messages sont rarement appelés directement. A la place, les messages sont répartis sur un objet en utilisant la méthode Dispatch héritée de TObject :

<source lang="delphi">
procedure Dispatch(var Message);
</source>

Le paramètre Message transmis à Dispatch doit être un enregistrement dont la première entrée est un champ de type '''Word''' contenant un identificateur de message.

Dispatch effectue une recherche arrière dans la hiérarchie des classes, en commençant par la classe de l'objet où elle est appelée, et invoque la première méthode de message pour l'identificateur qui lui a été transmis. Si aucune méthode de message n'est trouvée pour l'identificateur donné, Dispatch appelle DefaultHandler.

==Voir aussi==

*[[Classes et objets (Delphi)|Classes et objets (Delphi)]]
*[[Champs (Delphi)|Champs (Delphi)]]
*[[Propriétés (Delphi)|Propriétés (Delphi)]]
*[[Déclarations de types imbriqués|Déclarations de types imbriquées]]
*[[Références de classes|Références de classes]]
*[[Exceptions (Delphi)|Exceptions (Delphi)]]
*[[Surcharge d'opérateurs (Delphi)|Surcharge d'opérateurs (Delphi)]]
*[[Assistances de classes et d'enregistrements (Delphi)|Assistances de classes et d'enregistrements (Delphi)]]
* [[Procédures et fonctions (Delphi)|Procédures et fonctions (Delphi)]]
* [[Contrôle des programmes (Delphi)|Contrôle des programmes (Delphi)]]

[[Category:Delphi]]
[[Category:Guide du langage Delphi]]
[[Category:AMMigrate]]

Méthodes (Delphi)

2020-08-26T10:14:41Z

Yukikoi : 1 révision importée : LOC-RS82965

Plates-formes cible prises en charge

2020-07-30T09:56:36Z

Yukikoi : LOC-23340

{{Parent|Développement des applications multi-périphériques}}

{{Product}} {{Version}} prend en charge les plates-formes cible suivantes :

{| class="wikitable"
|-
! rowspan="2" |
Système
! rowspan="2" |
Versions prises en charge
! rowspan="2" |
Plate-forme cible 
(noeud '''[[Fenêtre Projets|Fenêtre Projet]]''')
! colspan="2" |
Langages pris en charge
! colspan="2" {{fr|vcl}} |
Frameworks d'UI pris en charge
|-
! [[Guide du langage Delphi - Index|{{Delphi}}]]
! [[Guide du langage C++ - Index|C++]]
! {{fr|vcl}} | [[FireMonkey|FireMonkey]]
! {{fr|vcl}} | [[VCL|VCL]]
|- valign="center"
| rowspan="2" |
Windows
| rowspan="2" |
Windows 10, Windows 8.1, Windows 7 (SP1+), Windows Server 2016 et Windows Server 2012 R2
|
Windows 32 bits
|
{{V}}
|
{{V}}
| {{fr|vcl}} |
{{V}}
| {{fr|vcl}} |
{{V}}
|- valign="center"
|
Windows 64 bits
|
{{V}}
|
{{V}}
| {{fr|vcl}} |
{{V}}
| {{fr|vcl}} |
{{V}}
|- valign="center"
| rowspan="2" |
macOS
| rowspan="2" |
10.15 Catalina, 10.14 Mojave, 10.13 High Sierra, et 10.12 Sierra
|
macOS 32 bits
|
{{V}}
|
{{V}}
| {{fr|vcl}} |
{{V}}
| {{fr|vcl}} |
|- valign="center"
|
macOS 64 bits
|
{{V}}
|
|
{{V}}
|
|- valign="center"
| rowspan="3" |
iOS
| rowspan="3" |
iOS 13, iOS 12, iOS 11, et iOS 10
|
Périphérique iOS 32 bits
|
{{V}}
|
{{V}}
| {{fr|vcl}} |
{{V}}
| {{fr|vcl}} |
|- valign="center"
|
Périphérique iOS 64 bits
|
{{V}}
|
{{V}}
| {{fr|vcl}} |
{{V}}
| {{fr|vcl}} |
|- valign="center"
|
Simulateur iOS
|
{{V}}
|
| {{fr|vcl}} |
{{V}}
| {{fr|vcl}} |
|- valign="center"
| rowspan="2" |
Android <ref>{{Product}} ne prend en charge que les périphériques réels (aucune prise en charge des émulateurs Android) par l'intermédiaire de la prise en charge [http://www.arm.com/products/processors/technologies/neon.php NEON].
</ref>
| rowspan="2" |
10, 9, 8, 7, 6, et 5.1
|
Android 32 bits
|
{{V}}
|
{{V}}
| {{fr|vcl}} |
{{V}}
| {{fr|vcl}} |
|- valign="center"
|
Android 64 bits
|
{{V}}
|
|
{{V}}
|
|- valign="center"
|
Linux
|
Ubuntu 18.04 LTS, Ubuntu 16.04 LTS, Ubuntu 14.04 LTS et RedHat Enterprise Linux (version 7)
|
Linux 64 bits
|
{{V}}
|
|
{{V}} <ref>Utilisation de [[FireMonkey pour Linux|FireMonkey pour Linux]].</ref>
|
|}

<references />

Vous pouvez définir les plates-formes cible prises en charge par vos projets sur le noeud '''[[Fenêtre Projets#Menu contextuel du noeud Plates-formes cible|Plates-formes cible]]''' du '''Gestionnaire de projets'''.

==Voir aussi==

* [[Présentation des plates-formes cible|Présentation des plates-formes cible]]
* [[Applications multi-périphériques - Index|Applications multi-périphériques - Index]]
* [[Travailler avec un Mac et un PC|Travailler avec un Mac et un PC]]
* [https://developer.apple.com/programs/ios/distribute.html App Distribution Information from Apple (EN) ]
* [[Périphériques Android pris en charge pour le développement d'applications|Périphériques Android pris en charge pour le développement d'applications]]
* [[Fonctions RTL standard relatives aux chemins sur les plates-formes cible prises en charge|Fonctions RTL standard relatives aux chemins sur les plates-formes cible prises en charge]]
* [[FireMonkey|FireMonkey]]
* [[Application multi-périphérique|Application multi-périphérique]]{{f|vcl|
* [[Introduction à la bibliothèque des composants visuels (VCL)|Introduction à la bibliothèque des composants visuels (VCL)]] }}

[[Category:Rio]]
[[Category:Multi-périphérique]]
[[Category:AMMigrate]]

Systèmes de gestion de base de données supportés par dbExpress

2020-07-30T09:56:36Z

Yukikoi : LOC-23340

{{Parent|Framework dbExpress}}{{DISPLAYTITLE:Systèmes de gestion de base de données pris en charge par dbExpress}}

'''[[Framework dbExpress|dbExpress]]''' fournit une prise en charge intégrée des systèmes de gestion de base de données (SGBD) suivants :

{| class="wikitable"
|-
! rowspan="2" | Système de gestion de bases de données
! rowspan="2" | Versions prises en charge
! rowspan="2" | [[Plates-formes cible prises en charge|Plates-formes prises en charge]]
! colspan="2" | Bibliothèques requises
! rowspan="2" | Paramètre DriverID
|- valign="top"
! Pilote
! Client**
|- valign="top"
| rowspan="2" | ASA (Sybase SQL Anywhere)
| rowspan="2" | 12 11 10 9 8*
| Windows 32 bits Windows 64 bits
| dbxasa.dll
| dbodbc*.dll
| rowspan="2" | ASA
|- valign="top"
| macOS
| libsqlasa.dylib
| libdbodbc12.dylib
|- valign="top"
| rowspan="2" | ASE (Sybase ASE)
| rowspan="2" | 12.5
| Windows 32 bits
| rowspan="2" | dbxase.dll
| libct.dll libcs.dll
| rowspan="2" | ASE
|- valign="top"
| Windows 64 bits
| libsybct64.dll libsybcs64.dll
|- valign="top"
| rowspan="2" | DB2
| rowspan="2" | 9.5 9.1 8.x* 7.x*
| rowspan="2" | Windows 32 bits Windows 64 bits
| rowspan="2" | dbxdb2.dll
| db2cli.dll
| rowspan="2" | DB2
|- valign="top"
| db2cli64.dll
|- valign="top"
| rowspan="4" | DataSnap
| rowspan="4" |
| Windows 32 bits
| colspan="2" | midas.dll
| rowspan="4" | DataSnap
|- valign="top"
| Windows 64 bits
| colspan="2" | midas.dll
|- valign="top"
| Android 32 bits Android 64 bits iOS Device 32 bits iOS Device 64 bits
| colspan="2" | libmidas.a
|- valign="top"
| macOS
| colspan="2" | libmidas.dylib
|- valign="top"
| rowspan="2" | Firebird
| rowspan="2" | 2.5 2.1 1.5
| Windows 32 bits Windows 64 bits
| dbxfb.dll
| fbclient.dll
| rowspan="2" | Firebird
|- valign="top"
| macOS
| libsqlfb.dylib
| /Library/Frameworks/Firebird.framework/Firebird
|- valign="top"
| rowspan="4" | IBLite/ToGo
| rowspan="4" | XE3
| Windows 32 bits
| rowspan="2" | dbxint.dll
| ibtogo.dll
| rowspan="4" | IBLite/ToGo
|- valign="top"
| Windows 64 bits
| ibtogo64.dll
|- valign="top"
| Android 32 bits Android 64 bits iOS Device 32 bits iOS Device 64 bits
| Fonctionnalité fournie par l'unité Data.DBXInterBase.
| libibtogo.a (liée statiquement, déploiement inutile)
|- valign="top"
| iOS Simulator macOS
| libsqlib.dylib
| libibtogo.dylib
|- valign="top"
| rowspan="2" | Informix
| rowspan="2" | 9.x
| Windows 32 bits Windows 64 bits
| dbxinf.dll
| isqlb09a.dll
| rowspan="2" | Informix
|- valign="top"
| macOS
| libsqlinf.dylib
| libifcli.dylib
|- valign="top"
| rowspan="3" | InterBase Server
| rowspan="3" | XE3 XE 2009 2007 7.5.1 7.1* 8.0* 6.5*
| Windows 32 bits
| rowspan="2" | dbxint.dll
| gds32.DLL
| rowspan="3" | InterBase Server
|- valign="top"
| Windows 64 bits
| ibclient64.dll
|- valign="top"
| iOS Simulator macOS
| libsqlib.dylib
| libgds.dylib
|- valign="top"
| rowspan="2" | MSSQL (Microsoft SQL Server)
| rowspan="2" | 2008 2005 2000
| rowspan="2" | Windows 32 bits Windows 64 bits
| dbxmss.dll
| sqlncli10.dll
| rowspan="2" | MSSQL
|- valign="top"
| dbxmss9.dll
| sqlncli.dll
|- valign="top"
| rowspan="2" | MySQL
| rowspan="2" | 5.1 5.0.27 4.1*
| Windows 32 bits Windows 64 bits
| dbxmys.dll
| libmysql.dll
| rowspan="2" | MySQL
|- valign="top"
| macOS
| libsqlmys.dylib
| libmysqlclient.dylib
|- valign="top"
| ODBC (pont vers plusieurs systèmes de gestion de bases de données)
|
| Windows 32 bits Windows 64 bits
| Fonctionnalité fournie par l'unité Data.DBXOdbc.
|
| Odbc
|- valign="top"
| rowspan="2" | Oracle
| rowspan="2" | 11g 10g 9.2.0* 9.1.0*
| Windows 32 bits Windows 64 bits
| dbxora.dll
| oci.dll
| rowspan="2" | Oracle
|- valign="top"
| macOS
| libsqlora.dylib
| libociei.dylib
|- valign="top"
| rowspan="5" | SQLite
| rowspan="5" | 3.x
| Windows 32 bits Windows 64 bits
| rowspan="5" | Fonctionnalité fournie par l'unité Data.DbxSqlite.
| sqlite3.dll
| rowspan="5" | SQLite
|- valign="top"
| Android 32 bits Android 64 bits
| sqlite.so (fournie par le système, déploiement inutile)
|- valign="top"
| Périphérique iOS 32 bits Périphérique iOS 64 bits
| rowspan="2" | libsqlite3.dylib (fournie par le système, déploiement inutile)
|- valign="top"
| Simulateur iOS
|- valign="top"
| macOS
| libsqlite3.dylib
|}

:'''Remarques :'''
:* Les pilotes ne sont pas totalement certifiés avec les versions des systèmes de gestion de bases de données marquées par un caractère *.
:* Les clients sont disponibles en téléchargement sur les sites Web des éditeurs.
:* Toutes les éditions de RAD Studio ne prennent pas en charge tous les systèmes de gestion de bases de données ci-dessus.
:* Des éditeurs tiers peuvent fournir des pilotes dbExpress qui prennent en charge d'autres systèmes de gestion de bases de données.

==Voir aussi==

* [[Informations spécifiques aux bases de données DbExpress|Informations spécifiques aux bases de données DbExpress]]
* [[Déploiement des applications de base de données dbExpress|Déploiement des applications de base de données dbExpress]]
* [[Mappage des types de données dbExpress pour les bases de données prises en charge|Mappage des types de données dbExpress pour les bases de données prises en charge]]
* [[Prise en charge du framework et du pilote dbExpress pour SQL Anywhere 11|Prise en charge du framework et du pilote dbExpress pour SQL Anywhere 11]]
* [[Prise en charge du framework et du pilote dbExpress pour SQL Anywhere 12|Prise en charge du framework et du pilote dbExpress pour SQL Anywhere 12]]
* [[InterBase ToGo avec dbExpress|InterBase ToGo avec dbExpress]]

* [[Compatibilité du framework dbExpress|Compatibilité du framework dbExpress]]
* [[Présentation des fonctionnalités dbExpress|Présentation des fonctionnalités dbExpress]]

* [[Tutoriel mobile : Utilisation de InterBase ToGo avec dbExpress (iOS et Android)|Tutoriel mobile : Utilisation de InterBase ToGo avec dbExpress (iOS et Android)]]
* [[Tutoriel mobile : Utilisation de dbExpress et SQLite (iOS et Android)|Tutoriel mobile : Utilisation de dbExpress et SQLite (iOS et Android)]]

[[Category:Delphi]]
[[Category:C++]]

Plates-formes cible prises en charge

2020-07-30T09:56:23Z

Yukikoi : 1 révision importée : LOC-23340

Systèmes de gestion de base de données supportés par dbExpress

2020-07-30T09:56:22Z

Yukikoi : 1 révision importée : LOC-23340

Ajout d'un SDK Android

2020-07-30T09:46:53Z

Yukikoi : LOC-23340

{{Parent|Développement d'applications mobiles Android}}

Un '''[[Gestionnaire de SDK|kit de développement logiciel (SDK)]]''' fournit un ensemble de fichiers qui sont utilisés pour construire des applications pour une plate-forme cible. Quand vous développez des applications pour Android, le '''SDK''' et le '''NDK Android''' sont requis sur votre système de développement. Ils ont tous les deux besoin d'être connus par le '''[[Gestionnaire de SDK|Gestionnaire de SDK]]'''.

=={{Product}} fournit un SDK Android==

Pendant [[Installation|l'installation de {{Product}}]], l'installateur ajoute les outils de développement Android requis à votre système et configure un SDK Android sur le '''Gestionnaire de SDK''' qui les utilise.

Pour utiliser une version différente des outils de développement Android précédemment installés sur votre système de développement, il vous suffit d'ajouter un SDK Android à {{Product}} tel qu'expliqué [[#Ajout d'un SDK Android à {{Product}}|ci-dessous]].

==Ajout d'un SDK Android à {{Product}}==

Pour ajouter un SDK Android à {{Product}} :

# Sélectionnez {{Menu|Outils > Options > Déploiement > [[Gestionnaire de SDK|Gestionnaire de SDK]]}} et cliquez sur le bouton '''Ajouter'''.
# Sur la boîte de dialogue '''[[Ajouter un nouveau SDK|Ajouter un nouveau SDK]]''', sélectionnez '''Android''' dans la liste déroulante '''Sélectionner une plate-forme'''.
# Sur la liste déroulante '''Sélectionner une version SDK''', sélectionnez '''Ajouter nouveau''' et suivez les étapes de l'expert '''[[Créer un nouveau SDK Android|Créer un nouveau SDK Android]]''' :
## Dans les champs '''Chemin de base du SDK Android''' et '''Chemin de base du NDK Android''', naviguez et sélectionnez vos emplacements SDK et NDK, respectivement.
## L'expert '''Créer un nouveau SDK Android''' remplit maintenant le reste des champs ici et sur la page '''Emplacements des outils Android'''. Patientez un moment jusqu'à ce que ce processus se termine.
## Pour les champs qui ne sont pas remplis automatiquement ou sont marqués par [[File:YellowBang.png]], cliquez sur le champ d'entrée et naviguez jusqu'à l'emplacement installé de cette bibliothèque sur votre système.
## Sélectionnez '''Terminer''' pour terminer la création de votre nouveau SDK.
# Cochez la case '''Rendre actif le SDK sélectionné''' pour que le nouveau SDK soit le SDK par défaut pour Android.
# Cliquez sur '''OK''' pour continuer.

La version de votre SDK Android est maintenant listée dans le '''[[Gestionnaire de SDK|Gestionnaire de SDK]]''' :

:[[File:SDK versions.png|=link]]

La version du SDK Android doit maintenant être incluse dans votre plate-forme cible Android dans le Gestionnaire de projets :

:[[File:Android sdk.png|=link]]

==Voir aussi==

* [[Gestionnaire de SDK|Gestionnaire de SDK]]

[[Category:Android]]
[[Category:XE5]]
[[Category:AMMigrate]]

Ajout d'un SDK Android

2020-07-30T09:46:39Z

Yukikoi : 1 révision importée : LOC-23340

Exceptions natives du SE

2020-07-30T09:42:02Z

Yukikoi : LOC-23340

{{Parent|Débogueurs Embarcadero}}

{{Menu|Outils > Options > Options du débogueur > Débogueurs {{Company}} > Exceptions natives du SE}}

Utilisez cette boîte de dialogue pour déterminer la façon dont les exceptions sont gérées par le débogueur. Sélectionnez une exception dans la liste et modifiez les options '''Gérées par''' et '''A la reprise'''.

{| border="1" frame="hsides" rules="rows"
|-
! '''Elément'''
! '''Description'''
|- valign="top"
|
Ajouter
|
Affiche la boîte de dialogue '''[[Ajout d'une étendue d'exception|Ajout d'une étendue d'exception]]''', dans laquelle vous pouvez ajouter des exceptions définies par l'utilisateur devant être gérées par le débogueur.
|- valign="top"
|
Retirer
|
Retire l'exception définie par l'utilisateur sélectionnée de la liste. Les exceptions natives du système d'exploitation ne peuvent pas être retirées.
|- valign="top"
|
Exceptions
|
Répertorie les exceptions natives du système d'exploitation, ainsi que toutes les exceptions définies par l'utilisateur. Les groupes d'exceptions suivants sont répertoriés :
* Des exceptions du SE Windows 32 bits
* Des exceptions du SE Windows 64 bits (pour les applications multi-périphériques)
* Des exceptions et des signaux Linux 64 bits
* Des exceptions et des signaux Android 32 bits (pour les applications multi-périphériques)
* Des exceptions et des signaux Android 64 bits (pour les applications multi-périphériques)
* Des exceptions et des signaux iOS 64 bits (pour les applications multi-périphériques)

* Des exceptions et des signaux iOS 32 bits (pour les applications multi-périphériques)
* Des exceptions et des signaux macOS Mach 32 bits (pour les applications multi-périphériques)
|- valign="top"
|
Gérées par
|
Spécifie si l'exception sera gérée par le débogueur ou par votre programme. Si vous avez ajouté à votre projet la gestion des exceptions, sélectionnez '''Programme utilisateur'''.
|- valign="top"
|
A la reprise
|
Spécifie si le produit continuera à gérer les exceptions, ou si le projet s'exécutera alors qu'elles sont non gérées.
|}

==Voir aussi==

* [[Exceptions du langage|Exceptions du langage]]
* [http://msdn.microsoft.com/en-us/library/5b2yeyab.aspx Handling and Throwing Exceptions (MSDN) (EN)]
* [http://developer.apple.com/library/mac/#documentation/Darwin/Conceptual/KernelProgramming/Mach/Mach.html Mach Overview (EN)]

[[Category:Référence RAD Studio]]
[[Category:AMMigrate]]

Exceptions natives du SE

2020-07-30T09:41:48Z

Yukikoi : 1 révision importée : LOC-23340

Prérequis de plate-forme FireMonkey

2020-07-30T09:23:05Z

Yukikoi : LOC-23340

{{Parent|Guide des applications FireMonkey}}

==Plates-formes prises en charge==

{{FM}} s'exécute sur les plates-formes suivantes :

{|
|-
! '''Plates-formes'''
! '''Applications'''
|-
|
Windows 32 bits
|
Applications {{FM}} 32 bits
|-
|
Windows 64 bits
|
Applications {{FM}} 64 bits
|-
|
macOS, noyau 32 bits (Delphi et C++) ou 64 bits (Delphi uniquement)
|
Applications {{FM}} 32 bits
|-
|
Périphérique iOS - 32 bits (C++ et {{Delphi}}) ou simulateur ({{Delphi}})
|
Applications {{FM}} 32 bits
|-
|
Périphérique iOS - 64 bits
|
Applications {{FM}} 64 bits
|-
|
Android 32 bits, ciblant les périphériques Android
|
Applications {{FM}} 32 bits
|-
|
Android 64 bits, ciblant les périphériques Android (Delphi)
|
Applications {{FM}} 64 bits
|-
|
[[FireMonkey pour Linux|Linux - 64 bits (Delphi)]]
|
Applications {{FM}} 64 bits
|}

* L'EDI de {{Variables|Product}} est une application Windows 32 bits. Il nécessite donc l'environnement de développement Windows (32 bits ou 64 bits).
* Le serveur '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' est nécessaire pour le développement multi-périphérique pour macOS ou iOS (périphérique ou simulateur).

==Exigences matérielles et du système d'exploitation pour la plate-forme cible et les systèmes de développement==

Toutes les applications {{FM}} nécessitent une unité de traitement des graphiques ('''GPU''') à la fois sur la plate-forme cible et le système de développement. L'unité GPU est accessible directement ou par le biais de la virtualisation.

===Exigences Windows===

* GPU de base :
** Toute classe DirectX 11.0 fournisseur ou supérieur
** Pour les graphiques 3D, Direct3D 11.1 ou supérieur (nuanceur de pixels de niveau 5) est préféré, mais la version installée de Direct3D sera utilisée
*** Vous pouvez télécharger Direct3D depuis [http://msdn.microsoft.com/en-us/library/windows/desktop/hh404562(v=vs.85).aspx http://msdn.microsoft.com/en-us/library/windows/desktop/hh404562(v=vs.85).aspx (EN)] (fichiers Windows6.1-KB2670838-x64.msu ou Windows6.1-KB2670838-x86.msu)
*** Exigences de mémoire supplémentaire pour 3D : le système doit autoriser des ressources dont la taille est supérieure à 4 Go, tout en conservant les index de toutes les ressources en 32 bits
* Microsoft Windows 10
* Microsoft Windows 8.1
* Microsoft Windows 7 SP1
* Microsoft Windows Server 2012 R2
* Microsoft Windows Server 2016

===Exigences macOS===

Votre Mac comporte une unité GPU qualifiée s'il s'exécute sur l'un des systèmes d'exploitation suivants :

* macOS 10.12 Sierra
* macOS 10.13 High Sierra
* macOS 10.14 Mojave
* macOS 10.15 Catalina

Pour le développement d'applications macOS, les logiciels suivants doivent être installés sur le Mac :

* Xcode 8, Xcode 9, Xcode 10 ou Xcode 11. Voir [[Installation de Xcode sur un Mac|Installation de Xcode]]

===Exigences iOS===

Vous devez connecter un périphérique iOS à votre Mac via un port USB afin d'exécuter une app iOS sur un périphérique iOS. Les périphériques iOS suivants sont pris en charge :

* iPod Touch, iPhone ou iPad
* iOS 10
* iOS 11
* iOS 12
* iOS 13

Pour le développement d'applications iOS, les éléments suivants doivent être installés sur le Mac :

* iOS 10.3.x SDK, iOS 11 SDK, iOS 12 SDK, ou iOS 13 SDK
* Xcode 8, Xcode 9, ou Xcode 10. Voir [[Installation de Xcode sur un Mac|Installation de Xcode]]

===Exigences Android===

Vous devez connecter un périphérique Android physique à votre système de développement via un port USB afin d'exécuter une app sur un périphérique Android. 
'''{{Variables|Product}}''' prend en charge le développement d'applications pour les périphériques Android s'exécutant sur un processeur ARMv7 supportant [http://www.arm.com/products/processors/technologies/neon.php NEON (EN)].

Pour une liste des versions Android prises en charge, voir '''[[Périphériques Android pris en charge pour le développement d'applications|Périphériques Android pris en charge pour le développement d'applications]]'''.

Lors de l'installation du produit, {{Product}} installe le SDK Android Tools Revision {{AndroidToolsRevision}} et le NDK Android. Il inclut :

* La version du système d'exploitation Android {{AndroidSDKVersion}} (Niveau API {{AndroidAPILevel}})
* Le NDK Android ({{AndroidNDKVersion}})

{{Avertissement|{{Product}} prend en charge ces outils de développement Android. N'utilisez pas d'autres versions ou mettez-les à jour indépendamment de {{Product}}.}}

==Voir aussi==

* [[Travailler avec un Mac et un PC|Travailler avec un Mac et un PC]]
* [[Création d'une application FireMonkey|Création d'une application FireMonkey]]
* [[Développement d'applications OS X|Développement d'applications MacOS]]
* [[Développement d'applications mobiles iOS|Développement d'applications mobiles iOS]]
* [[Développement d'applications mobiles Android|Développement d'applications mobiles Android]]

[[Category:XE4]]
[[Category:FMX]]
[[Category:AMMigrate]]

Débogage des applications multi-périphériques

2020-07-30T09:23:05Z

Yukikoi : LOC-23340

{{Parent|Applications multi-périphériques - Index|Applications multi-périphériques}}
__TOC__

==Architecture du débogage des applications multi-périphériques==

===Débogage des applications macOS===

[[File:785px-Debub Macok.png|600 px]] 

Sur la plate-forme macOS, le débogueur nécessite des permissions de fichier. Le débogage sur macOS est une opération privilégiée ; seul un processus avec des droits d'accès adéquats peut agir en tant que débogueur. Pour de plus amples informations, voir '''[[Acquisition de la permission permettant de prendre en charge le débogage sur un Mac|Acquisition de la permission permettant de supporter le débogage sur un Mac]]'''.

Pour des détails sur le développement des applications macOS, voir '''[[Développement d'applications OS X|Développement d'applications macOS]]'''.

===Débogage des apps iOS===

[[File:IOS Debugging1.png|800px]] 

* Pour le débogage sur les plates-formes cible '''Simulateur iOS''', '''Périphérique iOS - 32 bits''' et '''Périphérique iOS - 64 bits''', certaines fonctionnalités traditionnelles du débogueur ne sont pas disponibles. Pour de plus amples informations, voir '''[[Débogage des apps iOS|Débogage des apps iOS]].'''

* Pour des détails sur le développement des apps iOS, voir '''[[Développement d'applications mobiles iOS|Développement d'applications mobiles iOS]]'''.

===Débogage des applications Android===

[[File:Android Debugging.png|600 px]] 

* Pour des détails sur le développement des apps Android, voir '''[[Développement d'applications mobiles Android|Développement d'applications mobiles Android]]'''.

==Le débogueur intégré de {{Product}}==

Le débogueur {{Variables|Product}} intégré vous permet de déboguer une application qui cible toute [[Plates-formes cible prises en charge|plate-forme cible prise en charge]]. Le débogueur intégré supporte typiquement les applications {{Delphi}} et C++, excepté pour les plates-formes C++ Windows 64 bits, {{Delphi}} iOS et Android.

{{Variables|Product}} prend en charge les débogueurs suivants, qui s'exécutent sur la plate-forme cible spécifique :

* '''Débogueur {{Company}} Win64 pour {{Delphi}}''' (sur un PC fonctionnant sous un système d'exploitation Windows 64 bits)
* '''Débogueur {{Company}} Win64 pour C++''' (sur un PC fonctionnant sous un système d'exploitation Windows 64 bits)
* '''Débogueur 32 bits macOS {{Company}}''' (sur un Mac fonctionnant sous une version 32 bits de macOS)
* '''Débogueur 64 bits macOS {{Company}}''' (sur un Mac fonctionnant sous une version 64 bits de macOS)
* '''Débogueur {{Company}} iOS pour le simulateur iOS''' (sur un Mac)
* '''Débogueur {{Company}} iOS32 pour le périphérique iOS 32 bits''' (sur un périphérique iOS 32 bits et 64 bits connecté)
* '''Débogueur {{Company}} iOS64 pour le périphérique iOS 64 bits''' (sur un périphérique iOS 64 bits connecté)
* '''Débogueur Android {{Company}} pour le périphérique Android 32 bits''' (sur un périphérique Android 32 bits ou 64 bits connecté)
* '''Débogueur Android {{Company}} pour le périphérique Android 64 bits''' (sur un périphérique 64 bits connecté)

Les débogueurs {{Company}} appropriés sont installés quand vous préparez votre environnement de développement comme décrit dans l'aide. Par exemple, quand vous suivez les étapes du [[Développement d'applications OS X|développement d'applications macOS]], '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' et le débogueur macOS sont installés sur votre Mac. De même, quand vous suivez les étapes du [[Développement d'applications mobiles iOS|développement d'applications mobiles iOS]], PAServer et le débogueur iOS de {{Variables|Product}} sont installés sur votre Mac en tant que plate-forme intermédiaire qui prend en charge votre plate-forme cible (iOS). Les débogueurs {{Company}} qui sont recensés sur votre système sont listés dans '''Outils > Options > [[Options du débogueur|Options du débogueur]]'''.

{{Note|Les bibliothèque partagées supplémentaires sont chargées dans le '''débogueur''' '''iOS64'''. Ces bibliothèques partagées sont contrôlées par le débogueur et peuvent être ignorées. Voici certaines de ces bibliothèques : <code>__lldb_apple_objc_v2_get_dynamic_class_info, __lldb_caller_function, __lldb_apple_objc_v2_get_shared_cache_class_info, and __lldb_caller_function</code>.}}
{{Note|Des threads supplémentaires sont parfois exécutés dans le '''débogueur''' '''iOS64'''. Ces threads sont contrôlés par le débogueur et peuvent être ignorés.}}
{{Note|La '''nouvelle solution de débogage''' décrite dans cette rubrique est la solution recommandée pour le débogage d'applications multi-périphériques pour macOS, iOS, Android et Windows 64 bits (à partir d'un système de développement Windows 32 bits). Dans ce scénario, vous utilisez le débogueur multi-périphérique spécifique (exécuté sur la plate-forme cible) conjointement au débogueur intégré dans l'EDI.
Bien que la [[Débogage distant - Procédures d'ancien style|solution de débogage distant d'ancien style]] soit toujours prise en charge, et qu'elle puisse être utilisée facultativement pour installer et exécuter les débogueurs multi-périphériques, l'utilisation de cette solution pour les applications multi-périphériques n'est pas actuellement documentée.}}

{{Note|Avec le débogage Win32 distant, vous pouvez, si vous le souhaitez, continuer à utiliser le '''débogueur distant (d'ancien style) pré-existant''' pour toutes les opérations de débogage distant de bureau. N'oubliez pas cependant que vous devrez copier manuellement les fichiers sur la plate-forme cible, comme auparavant. Pour obtenir des instructions sur l'utilisation du débogueur distant d'ancien style, voir [[Présentation du débogage distant|Présentation du débogage distant]] et les [[Débogage distant - Procédures d'ancien style|procédures]] associées. La solution de débogage distant d'ancien style peut être utilisée pour le débogage Win32 distant (comme auparavant) et pour le débogage des applications Win64 et macOS. Toutefois, l'aide ne donne pas encore de détails sur la procédure d'utilisation du débogueur distant d'ancien style pour le débogage multi-périphérique.}}

{{Note|Lors de la tentative de lancement d'une application Android 64 bits sur un périphérique Android 32 bits, le message suivant apparaît à la place d'un message indiquant une incompatibilité : Impossible de démarrer le noyau LLDB : ‘./lldb-server[17]: syntax error: unexpected ‘)’.}}

==Exigences relatives au débogage multi-périphérique dans {{Product}}==

* Si une application est exécutée sur une plate-forme cible '''macOS''', '''Périphérique iOS - 32 bits''', '''Périphérique iOS - 64 bits''' ou '''Simulateur iOS''', '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' et un '''[[Gestionnaire de profils de connexion|profil de connexion]]''' sont requis pour établir une session de débogage.
*: La plate-forme cible '''Android''' et la plate-forme cible Win64 système ne nécessitent ni Platform Assistant ni profil de connexion.
* Certaines plates-formes cible requièrent l'ajout d'un '''SDK''' comme décrit dans la section suivante [[#Exigences pour le débogage multi-périphérique dans {{Product}}|Exigences pour le débogage multi-périphérique]].

Typiquement, le débogueur et le processus débogué s'exécutent sur la plate-forme cible. C'est le cas du périphérique iOS et du périphérique Android.
Mais dans chaque cas, le débogueur signale le statut et interagit avec vous sur le PC de développement dans l'EDI de {{Variables|Product}}. Cela signifie que l'utilisation de l'un des débogueurs multi-périphériques est très similaire à celle du débogueur intégré pour les applications Win32. Pour des informations communes plus détaillées sur le débogage, voir [[Présentation du débogage|Présentation du débogage]].

Pour effectuer un débogage multi-périphérique :

* Votre application doit avoir une '''[[Activation et configuration de la plate-forme cible|plate-forme cible]]''' activée :
** Windows 64 bits (depuis un PC de développement Windows 32 bits)
** macOS
** iOS (Delphi prend en charge le simulateur iOS ou les deux plates-formes périphérique iOS ; C++ ne prend en charge que les deux plates-formes périphérique iOS)
** Android (périphérique Android)
** Windows 32 bits et 64 bits à distance.
* Selon la plate-forme cible :
**Pour les plates-formes '''macOS''' et '''iOS''' :
*** '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' doit être [[Exécution de Platform Assistant sur un Mac|exécuté sur le Mac]].
*** Votre application doit être approvisionnée, avoir le code signé et un '''[[Gestionnaire de profils de connexion|profil de connexion]]''' associé.
**:{{Note|Il n'est pas nécessaire d'effectuer l'approvisionnement et la signature de code des applications '''macOS'''.}}
*** Votre système de développement doit avoir une connexion dynamique au Mac (c'est-à-dire que '''Tester connexion''' doit réussir sur la fenêtre [[Gestionnaire de profils de connexion|Gestionnaire de profils de connexion]]).
***: Cette connexion vous permet d'utiliser le débogueur intégré et le '''Gestionnaire de déploiement'''.
*** En outre, pour les deux plates-formes '''Périphérique iOS''', un périphérique iOS approvisionné doit être connecté au Mac par un câble USB.
**:{{Note|Vous ne pouvez pas utiliser le débogueur intégré pour déboguer une application iOS compilée avec la configuration de plate-forme '''Magasin d'applications'''.}}
**Pour la plate-forme '''Windows 32 bits''' :
*** Vous n'avez pas besoin d'utiliser Platform Assistant car votre environnement de débogage est en machine, et le débogueur intégré s'exécute automatiquement. Cependant, si vous souhaitez déboguer à distance une application '''Windows 32 bits''', vous devez définir l'option '''Inclure les symboles de débogage distant''' sur {{True}} dans {{Menu|Projet > Options > Compilateur Delphi > Liaison}}.
**Pour la plate-forme '''Windows 64 bits''' :
***Si vous êtes connecté à un PC 64 bits distant :
**** Vous devez utiliser Platform Assistant et un profil de connexion.
**** Votre système de développement doit avoir une connexion dynamique au PC 64 bits distant (c'est-à-dire que l'action '''Tester connexion''' doit réussir dans la fenêtre [[Gestionnaire de profils de connexion|Gestionnaire de profils de connexion]]). Cette connexion vous permet d'utiliser le débogueur intégré et le '''Gestionnaire de déploiement'''.
***Si votre système de développement est un PC fonctionnant sous un système d'exploitation Windows 64 bits :
**** Vous n'avez pas besoin d'utiliser Platform Assistant car votre environnement de débogage est en machine, et le débogueur intégré s'exécute automatiquement.
**** Vous pouvez néanmoins choisir d'utiliser facultativement Platform Assistant et un profil de connexion, comme vous le feriez pour un système cible Windows 64 bits distant. Cela vous permet d'utiliser le '''[[Gestionnaire de déploiement|Gestionnaire de déploiement]]'''.
** Un SDK est '''requis''' (sur le [[Gestionnaire de SDK|Gestionnaire de SDK]]) pour les plates-formes et types d'applications suivants :
*** Les applications multi-périphériques {{FM}} C++ pour la plate-forme '''macOS'''.
*** Les applications multi-périphériques {{FM}} {{Delphi}} pour les plates-formes '''Périphérique iOS - 32 bits''' et '''Périphérique iOS - 64 bits'''
*** Les applications multi-périphériques {{FM}} {{Delphi}} pour la plate-forme '''Android'''

==Débogage avec {{CBuilder}} Windows 64 bits==

Pour le débogage d'applications C++ Windows 64 bits, certaines fonctionnalités du débogueur ne sont pas disponibles.

Pour de plus amples informations, voir '''[[Débogage des applications C++ Builder Windows 64 bits|Débogage des applications C++ Builder Windows 64 bits]]'''.

==Démarrage du débogueur avec une commande 'Exécuter'==

Quand toutes les [[#Exigences relatives au débogage multi-périphérique dans {{Product}}|exigences relatives au débogage multi-périphérique]] sont satisfaites, l'entrée de la commande '''Exécuter''' :

* Copie les fichiers nécessaires entre le PC hôte et la machine cible spécifiée dans le profil de connexion.
* Exécute l'application dans le débogueur approprié requis pour la plate-forme.

Par exemple, si '''macOS''' est la plate-forme cible active, l'exécutable est copié sur le Mac.

Vous pouvez utiliser l'une des commandes '''Exécuter''' standard pour démarrer le débogage d'une application multi-périphérique (pour macOS ou Win64) :

* '''Exécuter > [[Exécuter|Exécuter]]''' ('''F9''') (compile et exécute l'application dans le débogueur intégré)
* '''Exécuter > [[Pas à pas|Pas à pas]]''' ('''F8''')
* '''Exécuter > [[Pas à pas approfondi|Pas à pas approfondi]]''' ('''F7''')
* '''Exécuter > [[Exécuter jusqu'au curseur et Exécuter jusqu'au retour|Exécuter jusqu'au retour]]''' ('''Maj+F8''')
*'''Exécuter > [[Exécuter jusqu'au curseur et Exécuter jusqu'au retour|Exécuter jusqu'au curseur]]''' ('''F4''')
*: '''Remarque :''' La commande Exécuter jusqu'au curseur n'est pas prise en charge pour le lancement du débogueur sur la plate-forme Android.

==Démarrage du débogueur avec 'Attacher au processus' et 'Charger un processus distant'==

Pour exécuter et déboguer un binaire compilé sur une machine exécutant le serveur Platform Assistant (un PC distant ou un Mac), vous pouvez utiliser :

*'''[[Attacher au processus|Attacher au processus]]''' pour déboguer un processus en cours d'exécution qui est soit local, soit distant. L'utilisation de [[PAServer, l'application serveur Platform Assistant|Platform Assistant et d'un profil de connexion]] est recommandée ici. Certaines plates-formes ne sont pas prises en charge comme indiqué dans la boîte de dialogue [[Attacher au processus|Attacher au processus]].
*: {{Note|L'attachement à un processus en cours d'exécution n'est pas pris en charge pour le '''débogueur {{Company}} Périphérique iOS32''', le '''débogueur {{Company}} Périphérique iOS64''' ou le '''débogueur {{Company}} Android'''.}}
*'''[[Charger un processus Local|Charger un processus Local]]''' pour charger un processus débogué local.
*: {{Note|L'attachement à un processus en cours d'exécution n'est pas pris en charge pour le '''débogueur {{Company}} Périphérique iOS32''', le '''débogueur {{Company}} Périphérique iOS64''' ou le '''débogueur {{Company}} Android'''.}}
*'''[[Charger un processus distant|Charger un processus Distant]]''' pour charger un processus débogué et l'exécuter sur une machine distante, avec quelques restrictions concernant les profils de connexion. Certaines plates-formes ne sont pas prises en charge, comme indiqué dans la boîte de dialogue [[Charger un processus distant|Charger un processus distant]].
*:{{Note|Le chargement d'un processus distant n'est pas pris en charge pour le '''débogueur Android {{Company}}'''.}}
*:L'utilisation de [[PAServer, l'application serveur Platform Assistant|Platform Assistant]] et d'un [[Gestionnaire de profils de connexion|profil de connexion]] est recommandée ici.

===Problèmes de minutage avec Charger un processus===

Si vous rencontrez des problèmes lors du débogage d'une app '''macOS''', c'est-à-dire que celle-ci se bloque immédiatement après que vous l'ayez exécutée à l'aide de '''Charger un processus''', essayez de sélectionner l'option '''Ne pas exécuter''' ou '''Exécuter jusqu'au point d'entrée du programme''' (ces deux options sont disponibles sous la zone "Après le chargement"). Ces options peuvent résoudre les problèmes de minutage qui surviennent lorsque l'app est exécutée et accède à des événements de débogage, alors que le débogueur est configuré et prêt à gérer les événements. Ces problèmes de minutage peuvent provoquer l'arrêt intempestif du débogueur.

==Voir aussi==

* [[Présentation du débogage|Présentation du débogage]]
* [[Débogage des applications - Index|Comment utiliser le débogueur]]
* [[Débogage distant - Procédures d'ancien style|Débogage distant - Procédures d'ancien style]]
* [[Création et test d'un profil de connexion sur le PC de développement|Création et test d'un profil de connexion sur le PC de développement]]
* [[PAServer, l'application serveur Platform Assistant|PAServer, l'application serveur Platform Assistant]]
* [[Débogage des applications C++ Builder Windows 64 bits|Débogage des applications C++ Builder Windows 64 bits]]
* [[Débogage des apps iOS|Débogage des apps iOS]]
* [[Exécution et débogage de votre application Android sur un périphérique Android à distance|Exécution et débogage de votre application Android sur un périphérique Android à distance]]
* [[Acquisition de la permission permettant de prendre en charge le débogage sur un Mac|Acquisition de la permission permettant de prendre en charge le débogage sur un Mac]]
* [http://blogs.msdn.com/b/ntdebugging/archive/2009/01/09/challenges-of-debugging-optimized-x64-code.aspx Debugging optimized Win64 code (EN)]

[[Category:XE2]]
[[Category:Multi-périphérique]]
[[Category:AMMigrate]]

Prérequis de plate-forme FireMonkey

2020-07-30T09:22:52Z

Yukikoi : 1 révision importée : LOC-23340

Débogage des applications multi-périphériques

2020-07-30T09:22:52Z

Yukikoi : 1 révision importée : LOC-23340

Fichiers de packages créés lors d'une compilation

2020-07-30T09:03:22Z

Yukikoi : LOC-23340

{{Parent|Compilation de packages}}

Lorsque vous [[Compilation de packages|construisez un package]], {{Product}} génère un jeu de fichiers différent selon la plate-forme cible et le langage de programmation de votre package.

==Windows 32 bits==

<l s="delphi" />

'''{{Delphi}} :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier unité compilé Delphi|{{Placeholder|unité}}.dcu]]
|
{{Product}} génère un fichier unité compilé {{Delphi}} pour chaque [[Unité|unité]] de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpl, *.dylib, *.so)|{{Placeholder|package}}.bpl]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier package compilé Delphi|{{Placeholder|package}}.dcp]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpi)|{{Placeholder|package}}.bpi]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .bpi C/C++ (bibliothèques d'importation de packages)''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|{{Placeholder|package}}.lib]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .obj/.lib C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête C++|{{Placeholder|package}}.hpp]] 
{{Placeholder|unité}}.hpp 
(facultatif)
|
{{Product}} génère un en-tête C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\hpp}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .hpp C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.obj]] 
{{Placeholder|unité}}.obj 
(facultatif)
|
{{Product}} génère un fichier objet C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .obj/.lib C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
|
|
|- valign="top"
|
[[API (*.rsm)|{{Placeholder|package}}.rsm]] 
(facultatif)
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Vous n'avez pas besoin d'un fichier de symboles de débogage de package pour déboguer les packages.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.

Pour basculer la génération de ce fichier facultatif, utilisez l'option '''Inclure les symboles de débogage distant''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Liaison (Delphi)|Liaison]]}}.
|
|
|- valign="top"
|
[[Fichier de chaînes de ressources Delphi (*.drc)|{{Placeholder|package}}.drc]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.

Pour activer la génération de ce fichier facultatif, effectuez l'une des opérations suivantes :
* Utilisez la valeur "Détaillé" de l'option '''Fichier map''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Liaison}}.
* Activez l'option '''Générer le fichier .drc de chaînes de ressources''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Liaison}}.
|
|
|- valign="top"
|
[[API (*.map)|{{Placeholder|package}}.map]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.

Pour activer la génération de ce fichier facultatif, utilisez l'une des valeurs autre que "Désactivé" de l'option '''Fichier map''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Liaison}}.
|
|
|- valign="top"
|
[[API (*.tds)|{{Placeholder|package}}.tds]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.

Pour basculer la génération de ce fichier facultatif, utilisez l'option '''Placer les informations de débogage dans un fichier TDS distinct''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Liaison}}.
|
|
|- valign="top"
|
[[Déclarations globales de sortie XML du compilateur|{{Placeholder|package}}.xml]] 
{{Placeholder|unité}}.xml 
(facultatif)
|
{{Product}} génère une représentation XML des sources compilés de votre package et de chaque unité de votre package. Voir [[Documentation XML pour le code Delphi|Documentation XML pour le code {{Delphi}}]].

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\hpp}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie de la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > [[Compilation#Autres options|Autres options]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > Autres options}}.
|
|
|}

<l e="delphi" />
<l s="cpp" />
'''C++ :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.obj]] 
{{Placeholder|unité}}.obj
|
{{Product}} génère deux fichiers objet C++ pour votre package et pour chaque unité de votre package : un fichier objet dynamique et un fichier objet statique.

Répertoire de sortie par défaut :
* Fichiers objet dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers objet statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpl, *.dylib, *.so)|{{Placeholder|package}}.bpl]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > [[C++ (options partagées)|C++ (options partagées)]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.map)|{{Placeholder|package}}.map]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'informations de dépendance de package C++ (*.pdi)|{{Placeholder|package}}.pdi]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.tds)|{{Placeholder|package}}.tds]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête précompilé C++ (*.pch)|{{Placeholder|package}}.pch]] 
(facultatif)
|
Dossier de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de chemin de fichier de sortie, utilisez l'option '''Fichier PCH''' de {{Menu|Projet > Options > Compilateur C++ > [[En-têtes précompilés du compilateur C++|En-têtes précompilés]]}}.

Pour désactiver la génération de ce fichier facultatif, utilisez l'une des valeurs suivantes pour l'option '''Usage PCH''' de {{Menu|Projet > Options > Compilateur C++ > En-têtes précompilés}} :
* Ne pas utiliser
* Utiliser mais ne pas générer
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de type de débogage C++|{{Placeholder|package}}.#{{Placeholder|nn}}]] 
(facultatif)
|
Dossier de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Le chemin de ces fichiers est basé sur le chemin du [[Fichier d'en-tête précompilé C++ (*.pch)|fichier d'en-tête précompilé]] — {{Product}} remplace l'extension de fichier {{Path|pch}} par {{Path|#{{Placeholder|nn}}}}. 
Utilisez l'option '''Fichier PCH''' de {{Menu|Projet > Options > Compilateur C++ > En-têtes précompilés}} pour changer le chemin de fichier de sortie du fichier d'en-tête précompilé.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Fichiers de types externes''' de {{Menu|Projet > Options > Compilateur C++ > En-têtes précompilés}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'état du lieur C++ (*.ilc, *.ild, *.ilf, *.ilr, *.ils)|{{Placeholder|package}}.ilc]] 
{{Placeholder|package}}.ild 
{{Placeholder|package}}.ilf 
{{Placeholder|package}}.ils 
(facultatif)
|
Fichiers d'état du lieur pour la liaison incrémentielle.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > [[C++ (options partagées)|C++ (options partagées)]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Désactiver la liaison incrémentielle''' de {{Menu|Projet > Options > [[Lieur C++|Lieur C++]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpi)|{{Placeholder|package}}.bpi]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la bibliothèque d'importation''' de {{Menu|Projet > Options > Lieur C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|{{Placeholder|package}}.lib]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer une bibliothèque de packages statiques (.lib)''' de {{Menu|Projet > Options > Lieur C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de chaînes de ressources Delphi (*.drc)|{{Placeholder|package}}.drc]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer un fichier .drc''' de {{Menu|Projet > Options > Lieur C++}}.
|
|
|}

<l e="cpp" />

==Windows 64 bits==

<l s="delphi" />

'''{{Delphi}} :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier unité compilé Delphi|{{Placeholder|unité}}.dcu]]
|
{{Product}} génère un fichier unité compilé {{Delphi}} pour chaque [[Unité|unité]] de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpl, *.dylib, *.so)|{{Placeholder|package}}.bpl]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier package compilé Delphi|{{Placeholder|package}}.dcp]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|{{Placeholder|package}}.a]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .obj/.lib C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpi)|{{Placeholder|package}}.bpi]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .bpi C/C++ (bibliothèques d'importation de packages)''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête C++|{{Placeholder|package}}.hpp]] 
{{Placeholder|unité}}.hpp 
(facultatif)
|
{{Product}} génère un en-tête C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\hpp}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .hpp C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.rsm)|{{Placeholder|package}}.rsm]] 
(facultatif)
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Vous n'avez pas besoin d'un fichier de symboles de débogage de package pour déboguer les packages.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.

Pour basculer la génération de ce fichier facultatif, utilisez l'option '''Inclure les symboles de débogage distant''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Liaison (Delphi)|Liaison]]}}.
| style="vertical-align: middle;" | {{V}}
|
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unit}}.o 
(facultatif)
|
{{Product}} génère un fichier objet C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .obj/.lib C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
|
|
|- valign="top"
|
[[Fichier de chaînes de ressources Delphi (*.drc)|{{Placeholder|package}}.drc]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.

Pour activer la génération de ce fichier facultatif, effectuez l'une des opérations suivantes :
* Utilisez la valeur "Détaillé" de l'option '''Fichier map''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Liaison (Delphi)|Liaison]]}}.
* Activez l'option '''Générer le fichier .drc de chaînes de ressources''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Liaison}}.
|
|
|- valign="top"
|
[[API (*.map)|{{Placeholder|package}}.map]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.

Pour activer la génération de ce fichier facultatif, utilisez l'une des valeurs autre que "Désactivé" de l'option '''Fichier map''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Liaison}}.
|
|
|- valign="top"
|
[[Déclarations globales de sortie XML du compilateur|{{Placeholder|package}}.xml]] 
{{Placeholder|unité}}.xml 
(facultatif)
|
{{Product}} génère une représentation XML des sources compilés de votre package et de chaque unité de votre package. Voir [[Documentation XML pour le code Delphi|Documentation XML pour le code {{Delphi}}]].

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\hpp}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie de la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > [[Compilation#Autres options|Autres options]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > Autres options}}.
|
|
|}

<l e="delphi" />
<l s="cpp" />
'''C++ :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unité}}.o
|
{{Product}} génère deux fichiers objet C++ pour votre package et pour chaque unité de votre package : un fichier objet dynamique et un fichier objet statique.

Répertoire de sortie par défaut :
* Fichiers objet dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers objet statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpl, *.dylib, *.so)|{{Placeholder|package}}.bpl]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > [[C++ (options partagées)|C++ (options partagées)]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.map)|{{Placeholder|package}}.map]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'informations de dépendance de package C++ (*.pdi)|{{Placeholder|package}}.pdi]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de dépendance C++|{{Placeholder|package}}.d]] 
{{Placeholder|unité}}.d
|
{{Product}} génère un fichier de dépendance C++ pour chaque [[Fichier objet C++|fichier objet C++]].

Les fichiers de dépendance C++ sont générés sur le même répertoire que les fichiers objet C++, avec l'extension de fichier {{Path|o}} remplacée par {{Path|d}}. 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête précompilé C++ (*.pch)|{{Placeholder|package}}PCH1.pch]] 
(facultatif)
|
{{Product}} génère deux fichiers d'en-tête précompilés C++ pour votre package et pour chaque unité de votre package : un fichier d'en-tête précompilé dynamique et un fichier d'en-tête précompilé statique.

Répertoire de sortie par défaut :
* Fichiers d'en-tête précompilés dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers d'en-tête précompilés statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Compilateur C++ > Répertoires et Conditions}}.

Pour désactiver la génération de ce fichier facultatif, utilisez l'une des valeurs suivantes pour l'option '''Usage PCH''' de {{Menu|Projet > Options > Compilateur C++ > [[En-têtes précompilés du compilateur C++|En-têtes précompilés]]}} :
* Ne pas utiliser
* Utiliser mais ne pas générer
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|{{Placeholder|package}}.a]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > [[C++ (options partagées)|C++ (options partagées)]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer une bibliothèque de packages statiques (.lib)''' de {{Menu|Projet > Options > [[Lieur C++|Lieur C++]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpi)|{{Placeholder|package}}.bpi]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la bibliothèque d'importation''' de {{Menu|Projet > Options > Lieur C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de chaînes de ressources Delphi (*.drc)|{{Placeholder|package}}.drc]] 
(facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer un fichier .drc''' de {{Menu|Projet > Options > Lieur C++}}.
|
|
|}

<l e="cpp" />

==macOS==

<l s="delphi" />

'''{{Delphi}} :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier unité compilé Delphi|{{Placeholder|unité}}.dcu]]
|
{{Product}} génère un fichier unité compilé {{Delphi}} pour chaque [[Unité|unité]] de votre package.

Répertoire de sortie par défaut:{{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Destination de l'unité''' de {{Menu|Projet > Options > Construction > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpl, *.dylib, *.so)|bpl{{Placeholder|package}}.dylib]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des droits d'application Apple (*.entitlements)|{{Placeholder|package}}.entitlements]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers de droits d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des informations d'application Apple (*.info.plist)|{{Placeholder|package}}.info.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers d'informations d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier package compilé Delphi|{{Placeholder|package}}.dcp]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|{{Placeholder|package}}.a]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .obj/.lib C/C++ ''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Construction > Compilateur %Dlphi% > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpi)|{{Placeholder|package}}.bpi]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .bpi C/C++''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Sortie - C/C++}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Construction > Compilateur %Dlphi% > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête C++|{{Placeholder|package}}.hpp]] 
{{Placeholder|unité}}.hpp 
(facultatif)
|
{{Product}} génère un en-tête C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut:{{Path|{{PublicDocumentsPath}}\hpp}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .hpp C/C++''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Sortie - C/C++}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Construction > Compilateur %Dlphi% > Sortie - C/C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.rsm)|bpl{{Placeholder|package}}.dylib.rsm]] 
(facultatif)
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Vous n'avez pas besoin d'un fichier de symboles de débogage de package pour déboguer les packages.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.

Pour basculer la génération de ce fichier facultatif, utilisez l'option '''Inclure les symboles de débogage distant''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > [[Liaison (Delphi)|Liaison]]}}.
| style="vertical-align: middle;" | {{V}}
|
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unit}}.o 
(facultatif)
|
{{Product}} génère un fichier objet C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut: {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .obj/.lib C/C++ ''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Construction > Compilateur %Dlphi% > Sortie - C/C++}}.
|
|
|- valign="top"
|
[[Fichier de chaînes de ressources Delphi (*.drc)|{{Placeholder|package}}.drc]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.

Pour activer la génération de ce fichier facultatif, effectuez l'une des opérations suivantes :
* Utilisez la valeur "Détaillé" de l'option '''Fichier map''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > [[Liaison (Delphi)|Liaison]]}}.
* Activez l'option '''Générer le fichier .drc de chaînes de ressources''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Liaison}}.
|
|
|- valign="top"
|
[[API (*.map)|bpl{{Placeholder|package}}.dylib.map]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.

Pour activer la génération de ce fichier facultatif, utilisez l'une des valeurs autre que "Désactivé" de l'option '''Fichier map''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Liaison}}.
|
|
|- valign="top"
|
[[Déclarations globales de sortie XML du compilateur|{{Placeholder|package}}.xml]] 
{{Placeholder|unité}}.xml 
(facultatif)
|
{{Product}} génère une représentation XML des sources compilés de votre package et de chaque unité de votre package. Voir [[Documentation XML pour le code Delphi|Documentation XML pour le code {{Delphi}}]].

Répertoire de sortie par défaut:{{Path|{{PublicDocumentsPath}}\hpp}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie de la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > [[Compilation#Autres Options|Autres Options]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la documentation XML''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Compilation > Autres options}}.
|
|
|}

<l e="delphi" />
<l s="cpp" />
'''C++ :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unité}}.o
|
{{Product}} génère deux fichiers objet C++ pour votre package et pour chaque unité de votre package : un fichier objet dynamique et un fichier objet statique.

Répertoire de sortie par défaut :
* Fichiers objet dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers objet statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Construction > Compilateur C++> [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpl, *.dylib, *.so)|bpl{{Placeholder|package}}.dylib]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > [[C++ (options partagées)|C++ (options partagées)]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des droits d'application Apple (*.entitlements)|{{Placeholder|package}}.entitlements]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers de droits d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des informations d'application Apple (*.info.plist)|{{Placeholder|package}}.info.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers d'informations d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.map)|{{Placeholder|package}}.map]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'informations de dépendance de package C++ (*.pdi)|{{Placeholder|package}}.pdi]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.tds)|bpl{{Placeholder|package}}.tds]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des droits d'application Apple (*.entitlements)|{{Placeholder|package}}.entitlements]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers de droits d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option'''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des informations d'application Apple (*.info.plist)|{{Placeholder|package}}.info.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers d'informations d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option'''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête précompilé C++ (*.pch)|{{Placeholder|package}}.pch]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de chemin de fichier de sortie, utilisez l'option '''Fichier PCH''' de {{Menu|Projet > Options > Construction > Compilateur C++ > [[En-têtes précompilés du compilateur C++|En-têtes précompilés]]}}.

Pour désactiver la génération de ce fichier facultatif, utilisez l'une des valeurs suivantes pour l'option '''Usage PCH''' de {{Menu|Projet > Options > Construction > Compilateur C++ > En-têtes précompilés}}:
* Ne pas utiliser
* Utiliser mais ne pas générer
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de type de débogage C++|{{Placeholder|package}}.#{{Placeholder|nn}}]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Le chemin de ces fichiers est basé sur le chemin du [[Fichier d'en-tête précompilé C++ (*.pch)|fichier d'en-têtes précompilé]] — {{Product}} remplace l'extension de fichier {{Path|pch}} par {{Path|#{{Placeholder|nn}}}}. 
Pour changer de chemin du fichier de sortie de ces fichiers, utilisez l'option '''Fichier PCH ''' de {{Menu|projet > Options > Construction > Compilateur C++ > En-têtes précompilés}} pour changer le chemin do ficher de sortie du fichier d'en-têtes précompilé.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Fichiers de types externes''' de {{Menu|Projet > Options > Construction > Compilateur C++ > En-têtes précompilés}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'état du lieur C++ (*.ilc, *.ild, *.ilf, *.ilr, *.ils)|{{Placeholder|package}}.ilc]] 
{{Placeholder|package}}.ild 
{{Placeholder|package}}.ilf 
{{Placeholder|package}}.ilr 
{{Placeholder|package}}.ils 
(facultatif)
|
Fichiers d'état du lieur pour la liaison incrémentielle.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > [[C++ (options partagées)|C++ (options partagées)]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Désactiver la liaison incrémentielle''' de {{Menu|Projet > Options > Construction > [[Lieur C++|Lieur C++]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|{{Placeholder|package}}.a]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option'''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer une bibliothèque de packages statiques (.lib)''' de {{Menu|Projet > Options > Construction > Lieur C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpi)|{{Placeholder|package}}.bpi]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option'''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la bibliothèque d'importation''' de {{Menu|Projet > Options > Construction > Lieur C++}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de chaînes de ressources Delphi (*.drc)|{{Placeholder|package}}.drc]] 
(facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer un fichier .drc''' de {{Menu|Projet > Options > Construction > Lieur C++}}.
|
|
|}

<l e="cpp" />

==Périphérique iOS 32 bits et 64 bits==

<l s="delphi" />

'''{{Delphi}} :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier unité compilé Delphi|{{Placeholder|unité}}.dcu]]
|
{{Product}} génère un fichier unité compilé {{Delphi}} pour chaque [[Unité|unité]] de votre package.

Répertoire de sortie par défaut:{{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Destination de l'unité''' de {{Menu|Projet > Options > Construction > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unité}}.o
|
{{Product}} génère un fichier objet C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des droits d'application Apple (*.entitlements)|{{Placeholder|package}}.entitlements]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers de droits d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des informations d'application Apple (*.info.plist)|{{Placeholder|package}}.info.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers d'informations d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des règles de ressources d'application Apple|ResourceRules.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers des règles de ressources d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|lib{{Placeholder|package}}.a]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier package compilé Delphi|{{Placeholder|package}}.dcp]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête C++|{{Placeholder|package}}.hpp]] 
{{Placeholder|unité}}.hpp 
(facultatif)
|
{{Product}} génère un en-tête C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut: {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .hpp C/C++''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, effectuez l'une des opérations suivantes :
* Activez l'option '''Générer un fichier .hpp''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Sortie - C/C++}}.
* Utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" pour l'option '''Génération des fichiers de sortie C/C++''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Sortie - C/C++}}.
|
|
|- valign="top"
|
[[Déclarations globales de sortie XML du compilateur|{{Placeholder|package}}.xml]] 
{{Placeholder|unité}}.xml 
(facultatif)
|
{{Product}} génère une représentation XML des sources compilés de votre package et de chaque unité de votre package. Voir [[Documentation XML pour le code Delphi|Documentation XML pour le code {{Delphi}}]].

Répertoire de sortie par défaut: {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie de la documentation XML''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Compilation > [[Compilation#Autres options|Autres options]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la documentation XML''' de {{Menu|Projet > Options > Construction > Compilateur {{Delphi}} > Compilation > Autres options}}.
|
|
|}

<l e="delphi" />
<l s="cpp" />
'''C++ :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unité}}.o
|
{{Product}} génère deux fichiers objet C++ pour votre package et pour chaque unité de votre package : un fichier objet dynamique et un fichier objet statique.

Répertoire de sortie par défaut :
* Fichiers objet dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers objet statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options >Construction > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.bpl, *.dylib, *.so)|bpl{{Placeholder|package}}.dylib]]
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > [[C++ (options partagées)|C++ (options partagées)]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de dépendance C++|{{Placeholder|package}}.d]] 
{{Placeholder|unité}}.d
|
{{Product}} génère un fichier de dépendance C++ pour chaque [[Fichier objet C++|fichier objet C++]].

Les fichiers de dépendance C++ sont générés sur le même répertoire que les fichiers objet C++, avec l'extension de fichier {{Path|o}} remplacée par {{Path|d}}. 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Construction > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des droits d'application Apple (*.entitlements)|{{Placeholder|package}}.entitlements]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers de droits d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > [[C++ (options partagées)|C++ (options partagées)]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des informations d'application Apple (*.info.plist)|{{Placeholder|package}}.info.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers d'informations d'application Apple.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des règles de ressources d'application Apple|ResourceRules.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers des règles de ressources d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des droits d'application Apple (*.entitlements)|{{Placeholder|package}}.entitlements]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers de droits d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option'''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des informations d'application Apple (*.info.plist)|{{Placeholder|package}}.info.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers d'informations d'application Apple.

Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option'''Sortie BPI/LIB''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des règles de ressources d'application Apple|ResourceRules.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers des règles de ressources d'application Apple.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête précompilé C++ (*.pch)|{{Placeholder|package}}PCH1.pch]] 
(facultatif)
|
{{Product}} génère deux fichiers d'en-tête précompilés C++ pour votre package et pour chaque unité de votre package : un fichier d'en-tête précompilé dynamique et un fichier d'en-tête précompilé statique.

Répertoire de sortie par défaut :
* Fichiers d'en-tête précompilés dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers d'en-tête précompilés statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Construction > Compilateur C++> [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.

Pour désactiver la génération de ce fichier facultatif, utilisez l'une des valeurs suivantes pour l'option '''Usage PCH''' de {{Menu|Projet > Options > Construction > Compilateur C++ > [[En-têtes précompilés du compilateur C++|En-têtes précompilés]]}}:
* Ne pas utiliser
* Utiliser mais ne pas générer
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|lib{{Placeholder|package}}.a]] 
(facultatif)
|
Les packages RAD Studio sont statiquement liés sur iOS.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > [[C++ (options partagées)|C++ (options partagées)]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer une bibliothèque de packages statiques (.lib)''' de {{Menu|Projet > Options > Construction > [[Lieur C++|Lieur C++]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[http://en.wikipedia.org/wiki/File_shortcut#Microsoft_Windows {{Placeholder|package (EN)}}] 
(raccourci de fichier, facultatif)
|
Répertoire de sortie par défaut: {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|platform}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > Construction > C++ (options partagées)}}.

Pour basculer la génération de ce fichier facultatif, utilisez l'option '''Retirer le fichier lieur .lnk temporaire après la liaison''' de {{Menu|Projet > Options > Construction > Lieur C++}}.
|
|
|}

<l e="cpp" />

==Simulateur iOS==

<l s="delphi" />

'''{{Delphi}} :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier unité compilé Delphi|{{Placeholder|unité}}.dcu]]
|
{{Product}} génère un fichier unité compilé {{Delphi}} pour chaque [[Unité|unité]] de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des droits d'application Apple (*.entitlements)|{{Placeholder|package}}.entitlements]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers de droits d'application Apple.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier des informations d'application Apple (*.info.plist)|{{Placeholder|package}}.info.plist]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers d'informations d'application Apple.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier package compilé Delphi|{{Placeholder|package}}.dcp]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête C++|{{Placeholder|package}}.hpp]] 
{{Placeholder|unité}}.hpp 
(facultatif)
|
{{Product}} génère un en-tête C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .hpp C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
|
|
|- valign="top"
|
[[Déclarations globales de sortie XML du compilateur|{{Placeholder|package}}.xml]] 
{{Placeholder|unité}}.xml 
(facultatif)
|
{{Product}} génère une représentation XML des sources compilés de votre package et de chaque unité de votre package. Voir [[Documentation XML pour le code Delphi|Documentation XML pour le code {{Delphi}}]].

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie de la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > [[Compilation#Autres options|Autres options]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > Autres options}}.
|
|
|}

<l e="delphi" />
<l s="cpp" />
'''C++ :''' Non pris en charge.
<l e="cpp" />

==Android 32 bits et 64 bits==

<l s="delphi" />

'''{{Delphi}} :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier unité compilé Delphi|{{Placeholder|unité}}.dcu]]
|
{{Product}} génère un fichier unité compilé {{Delphi}} pour chaque [[Unité|unité]] de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unité}}.o
|
{{Product}} génère un fichier objet C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier manifest d'application Android (AndroidManifest.xml)|AndroidManifest.xml]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie des packages''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|lib{{Placeholder|package}}.a]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier package compilé Delphi|{{Placeholder|package}}.dcp]]
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie DCP''' de {{Menu|Projet > Options > Compilateur {{Delphi}}}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête C++|{{Placeholder|package}}.hpp]] 
{{Placeholder|unité}}.hpp 
(facultatif)
|
{{Product}} génère un en-tête C++ pour votre package et pour chaque unité de votre package.

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie .hpp C/C++''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > [[Sortie - C/C++|Sortie - C/C++]]}}.

Pour activer la génération de ce fichier facultatif, utilisez la valeur "Générer tous les fichiers C++Builder (y compris les bibliothèques de packages)" de l'option '''Génération des fichiers de sortie C/C++''' dans {{Menu|Projet > Options > Compilateur {{Delphi}} > Sortie - C/C++}}.
|
|
|- valign="top"
|
[[Déclarations globales de sortie XML du compilateur|{{Placeholder|package}}.xml]] 
{{Placeholder|unité}}.xml 
(facultatif)
|
{{Product}} génère une représentation XML des sources compilés de votre package et de chaque unité de votre package. Voir [[Documentation XML pour le code Delphi|Documentation XML pour le code {{Delphi}}]].

Répertoire de sortie par défaut : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie de la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > [[Compilation#Autres options|Autres options]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer la documentation XML''' de {{Menu|Projet > Options > Compilateur {{Delphi}} > Compilation > Autres options}}.
|
|
|}

<l e="delphi" />
<l s="cpp" />
'''C++ :'''

{| class="wikitable"
|-
! rowspan="2" | Fichiers
! rowspan="2" | Description
! colspan="2" | Généré par défaut ?
|- valign="top"
! Debug
! Release
|- valign="top"
|
[[Fichier objet C++|{{Placeholder|package}}.o]] 
{{Placeholder|unité}}.o
|
{{Product}} génère deux fichiers objet C++ pour votre package et pour chaque unité de votre package : un fichier objet dynamique et un fichier objet statique.

Répertoire de sortie par défaut :
* Fichiers objet dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers objet statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier de dépendance C++|{{Placeholder|package}}.d]] 
{{Placeholder|unité}}.d
|
{{Product}} génère un fichier de dépendance C++ pour chaque [[Fichier objet C++|fichier objet C++]].

Les fichiers de dépendance C++ sont générés sur le même répertoire que les fichiers objet C++, avec l'extension de fichier {{Path|o}} remplacée par {{Path|d}}. 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier manifest d'application Android (AndroidManifest.xml)|AndroidManifest.xml]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers manifest d'application Android.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > [[C++ (options partagées)|C++ (options partagées)]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier manifest d'application Android (AndroidManifest.xml)|AndroidManifest.xml]]
|
: '''Remarque :''' Vous pouvez ignorer ce fichier. Les packages ne requièrent pas les fichiers manifest d'application Android.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > C++ (options partagées)}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[Fichier d'en-tête précompilé C++ (*.pch)|{{Placeholder|package}}PCH1.pch]] 
(facultatif)
|
{{Product}} génère deux fichiers d'en-tête précompilés C++ pour votre package et pour chaque unité de votre package : un fichier d'en-tête précompilé dynamique et un fichier d'en-tête précompilé statique.

Répertoire de sortie par défaut :
* Fichiers d'en-tête précompilés dynamiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}}
* Fichiers d'en-tête précompilés statiques : {{Path|{{ProjectsPath}}\{{Placeholder|projet}}\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}\staticobjs}}

Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie du fichier objet''' de {{Menu|Projet > Options > Compilateur C++ > [[Répertoires et Conditions du compilateur C++|Répertoires et Conditions]]}}.

Pour désactiver la génération de ce fichier facultatif, utilisez l'une des valeurs suivantes pour l'option '''Usage PCH''' de {{Menu|Projet > Options > Compilateur C++ > [[En-têtes précompilés du compilateur C++|En-têtes précompilés]]}} :
* Ne pas utiliser
* Utiliser mais ne pas générer
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[[API (*.lib, *.a)|lib{{Placeholder|package}}.a]] 
(facultatif)
|
Les packages RAD Studio sont statiquement liés sur Android.

Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\DCP\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Sortie BPI/LIB''' de {{Menu|Projet > Options > [[C++ (options partagées)|C++ (options partagées)]]}}.

Pour basculer la génération de ces fichiers facultatifs, utilisez l'option '''Générer une bibliothèque de packages statiques (.lib)''' de {{Menu|Projet > Options > [[Lieur C++|Lieur C++]]}}.
| style="vertical-align: middle;" | {{V}}
| style="vertical-align: middle;" | {{V}}
|- valign="top"
|
[http://en.wikipedia.org/wiki/File_shortcut#Microsoft_Windows {{Placeholder|package (EN)}}] 
(raccourci de fichier, facultatif)
|
Répertoire de sortie par défaut : {{Path|{{PublicDocumentsPath}}\Bpl\{{Placeholder|plate-forme}}\{{Placeholder|configuration de construction}}}} 
Pour changer de répertoire de sortie, utilisez l'option '''Répertoire de sortie final''' de {{Menu|Projet > Options > C++ (options partagées)}}.

Pour basculer la génération de ce fichier facultatif, utilisez l'option '''Retirer le fichier lieur .lnk temporaire après la liaison''' de {{Menu|Projet > Options > Lieur C++}}.
|
|
|}

<l e="cpp" />

==Voir aussi==

* [[Utilisation des packages et des composants - Présentation|Utilisation des packages et des composants - Présentation]]

* [[Compilation de packages|Compilation de packages]]
* [[Compilation et liaison à partir de la ligne de commande|Compilation et liaison à partir de la ligne de commande]]

* [[Déploiement des packages|Déploiement des packages]]

[[Category:Guide du développeur Windows]]
[[Category:XE7]]

Fichiers de packages créés lors d'une compilation

2020-07-30T09:03:11Z

Yukikoi : 1 révision importée : LOC-23340

Utilisation de Box2D dans les applications Delphi

2020-07-30T06:32:57Z

Yukikoi : LOC-23340

{{Parent|Box2D}}

Cette rubrique explique comment utiliser Box2D dans les applications {{Delphi}}.

==Configuration de votre application pour utiliser Box2D==

{{Product}} ne fournit pas de fichiers {{Path|.dcu}} préconstruits pour les unités Box2D {{Delphi}}. Pour pouvoir construire un projet {{Delphi}} contenant des unités Box2D dans la clause <source lang="delphi" enclose="none">uses</source>, vous devez configurer le chemin de recherche de votre projet de manière que {{Product}} trouve les unités Box2D.

Pour configurer le chemin de recherche de votre projet {{Delphi}} de manière que {{Product}} trouve les unités Box2D :

# Sélectionnez {{Menu|Projet > Options > [[Compilateur Delphi|Compilateur {{Delphi}}]]}}.
# Ajoutez {{Path|${BDS)\source\FlatBox2D}} au champ '''Chemin de recherche'''.

Vous pouvez maintenant [[Ajouter une référence d'unité|ajouter des références à ces unités]] dans votre code de manière à pouvoir [[#Utilisation de Box2D|utiliser Box2D]].

==Utilisation de Box2D==

Les liaisons {{Delphi}} pour Box2D sont basées sur [http://www.learn-cocos2d.com/api-ref/1.0/Box2D/html/index.html l'API C++ (EN)]. Il existe toutefois des différences notables.

: '''Remarque :''' Pour utiliser les liaisons {{Delphi}} pour Box2D, vous devez être familier des [[Pointeurs et types pointeur (Delphi)|pointeurs]] et des [[Eléments syntaxiques fondamentaux (Delphi)#Identificateurs étendus|identificateurs étendus]].

===Mappage {{Delphi}} des classes Box2D===

Les liaisons {{Delphi}} pour Box2D exposent les classes Box2D de l'une des manières suivantes :

* En tant qu'enregistrement avec le nom d'origine de la classe Box2D. Voir [[#Utilisation des enregistrements Box2D|Utilisation des enregistrements Box2D]].
* En tant qu'enregistrement avec le nom d'origine de la classe Box2D suivi du suffixe {{Code|Wrapper}}. Par exemple, le wrapper de {{Code|b2World}} serait {{Code|b2WorldWrapper}}. Voir [[#Utilisation des enregistrements wrapper Box2D|Utilisation des enregistrements wrapper Box2D]].

Dans les deux cas, contrairement aux enregistrements {{Delphi}} habituels, il ne suffit pas de déclarer ces enregistrements Box2D pour les créer. Vous devez appeler leur procédure {{Code|Create}} pour vous assurer que leurs membres ont les valeurs par défaut appropriées. Si vous déclarez un enregistrement et que vous n'appelez pas {{Code|Create}}, les valeurs par défaut de ses membres peuvent ne pas correspondre à celles définies par Box2D.

<source lang="delphi">
groundBodyDef := b2BodyDef.Create;
</source>

====Utilisation des enregistrements Box2D====

Les liaisons {{Delphi}} pour Box2D fournissent la plupart des classes Box2D sous forme d'enregistrements. Les seules exceptions sont les [[#Utilisation des enregistrements wrapper Box2D|classes exposées sous forme d'enregistrements wrapper]] et les [[#Définition des écouteurs Box2D|classes écouteur]].

====Utilisation des enregistrements wrapper Box2D====

Les liaisons {{Delphi}} pour Box2D fournissent les enregistrements wrapper suivants :

* {{Code|b2BlockAllocatorWrapper}}
* {{Code|b2BodyWrapper}}
* {{Code|b2BroadPhaseWrapper}}
* {{Code|b2ChainAndCircleContactWrapper}}
* {{Code|b2ChainAndPolygonContactWrapper}}
* {{Code|b2ChainShapeWrapper}}
* {{Code|b2CircleContactWrapper}}
* {{Code|b2CircleShapeWrapper}}
* {{Code|b2ContactWrapper}}
* {{Code|b2ContactManagerWrapper}}
* {{Code|b2ContactSolverWrapper}}
* {{Code|b2DistanceJointWrapper}}
* {{Code|b2DrawWrapper}}
* {{Code|b2DynamicTreeWrapper}}
* {{Code|b2EdgeAndCircleContactWrapper}}
* {{Code|b2EdgeAndPolygonContactWrapper}}
* {{Code|b2EdgeShapeWrapper}}
* {{Code|b2FrictionJointWrapper}}
* {{Code|b2GearJointWrapper}}
* {{Code|b2IslandWrapper}}
* {{Code|b2JointWrapper}}
* {{Code|b2MotorJointWrapper}}
* {{Code|b2MouseJointWrapper}}
* {{Code|b2PolygonAndCircleContactWrapper}}
* {{Code|b2PolygonContactWrapper}}
* {{Code|b2PolygonShapeWrapper}}
* {{Code|b2PrismaticJointWrapper}}
* {{Code|b2PulleyJointWrapper}}
* {{Code|b2RevoluteJointWrapper}}
* {{Code|b2RopeWrapper}}
* {{Code|b2RopeJointWrapper}}
* {{Code|b2ShapeWrapper}}
* {{Code|b2StackAllocatorWrapper}}
* {{Code|b2WeldJointWrapper}}
* {{Code|b2WheelJointWrapper}}
* {{Code|b2WorldWrapper}}

====Libération des enregistrements et des wrappers d'enregistrements Box2D====

Les seuls enregistrements ou wrappers d'enregistrements Box2D que vous devez libérer sont des instances de {{Code|b2WorldWrapper}}. Le destructeur de {{Code|b2WorldWrapper}} libère la mémoire allouée par les corps, les fixtures ou les jointures dans l'objet {{Code|b2WorldWrapper}}.

Les exceptions à cette règle sont :

* les ShapeWrappers,
* d'autres wrappers que vous construisez explicitement et qui sont détruits dans C++.

<source lang="delphi">
world.Destroy;
</source>

[[#Définition des écouteurs Box2D| Les écouteurs Box2D]] sont également une exception à cette règle.

===Définition des écouteurs Box2D===

Box2D définit certaines classes écouteur. Lorsque vous [[Utilisation de Box2D dans les applications C++Builder|utilisez C++]], vous pouvez créer une sous-classe d'écouteur, créer une instance de votre sous-classe et recenser votre objet écouteur dans un objet Box2D, par exemple un monde ({{Code|b2World}}).

Pour créer un objet écouteur Box2D d'un certain type dans {{Delphi}}, vous devez définir une classe personnalisée qui implémente l'interface de la classe écouteur Box2D cible. L'interface d'une classe écouteur Box2D est nommée comme la classe écouteur Box2D mais est préfixée d'un {{Code|I}} majuscule. Par exemple, {{Code|Ib2ContactListener}} est l'interface de la classe écouteur Box2D {{Code|b2ContactListener}}.

<source lang="delphi">
TMyContactListener = class (TInterfacedObject, Ib2ContactListener)
public
procedure BeginContact(contact: NativeUInt); cdecl;
procedure EndContact(contact: NativeUInt); cdecl;
procedure PostSolve(contact: NativeUInt; impulse: Pb2ContactImpulse); cdecl;
procedure PreSolve(contact: NativeUInt; oldManifold: Pb2Manifold); cdecl;
end;
</source>

Une fois que vous disposez d'une classe qui implémente l'interface écouteur cible, vous devez créer une instance de cette classe.

<source lang="delphi">
myContactListener := TMyContactListener.Create;
</source>

Les accesseurs en écriture d'un écouteur ne peuvent pas gérer votre objet écouteur directement. A la place, vous devez obtenir un délégué (de type <source lang="delphi" enclose="none">NativeUInt</source>) pour votre objet écouteur et transmettre ce délégué à l'accesseur en écriture de l'écouteur. Utilisez {{Code|Create_{{placeholder|listener class}}_delegate}} pour créer un délégué de votre objet écouteur.

<source lang="delphi">
myContactListenerHandle := Create_b2ContactListener_delegate(myContactListener);
world.SetContactListener(myContactListenerHandle);
</source>

Après avoir détruit le monde Box2D, vous pouvez détruire votre objet écouteur en transmettant son handle à {{Code|Destroy_{{placeholder|listener class}}_delegate}}.

<source lang="delphi">
world.Destroy;
Destroy_b2ContactListener_delegate(myContactListenerHandle);
</source>

==Déploiement de votre application==

Sur les plates-formes de bureau, vous devez distribuer la bibliothèque dynamique Box2D de {{Product}} en même temps que votre application.

Le fichier de la bibliothèque dynamique Box2D de {{Product}} est disponible dans :

* '''Windows 32 bits :''' {{Path|{{InstallPath}}\bin\FlatBox2DDyn.dll}}
* '''Windows 64 bits :''' {{Path|{{InstallPath}}\bin64\FlatBox2DDyn.dll}}
* '''macOS 32 bits:''' {{Path|{{InstallPath}}\binosx32\libFlatBox2DDyn.dylib}}
* '''macOS 64 bits:''' {{Path|{{InstallPath}}\binosx64\libFlatBox2DDyn.dylib}}

[[Gestionnaire de déploiement - Ajout de fichiers|Ajoutez ce fichier bibliothèque au Gestionnaire de déploiement]] pour chacune des plates-formes cible prises en charge par votre application. Ainsi, lorsque vous [[Déploiement des applications - Index|déploierez votre application]] pour une plate-forme de bureau, le fichier de bibliothèque dynamique Box2D de {{Product}} sera inclus dans les fichiers déployés de votre application.

==Voir aussi==

* [[Utilisation de Box2D dans les applications C++Builder|Utilisation de Box2D dans les applications {{CBuilder}}]]
* [http://box2d.org/manual.pdf Manuel C++ (EN)]
* [http://www.learn-cocos2d.com/api-ref/1.0/Box2D/html/index.html Documentation API C++ (EN)]

===Exemples===

* [[Samp:Box2D Hello World (Delphi)|Box2D Hello World ({{Delphi}})]]
* Exemple [[samp_en:Box2D.Box2DHello|Box2D Hello]]
* Exemple [[samp_en:Box2D.TestBed|Box2D TestBed]]
* Exemple [[samp_en:FMX.SimplePhysics Sample|FMX SimplePhysics]]

[[Category:Delphi]]
[[Category:AMMigrate]]

Utilisation de Box2D dans les applications Delphi

2020-07-30T06:32:46Z

Yukikoi : 1 révision importée : LOC-23340

Tutoriel mobile : Définition de votre environnement de développement sur un PC Windows (iOS)

2020-07-30T06:28:20Z

Yukikoi : LOC-23340

{{Parent|Tutoriels mobiles : Développement d'applications mobiles (iOS et Android)}}

Avant de commencer ce tutoriel, il est recommandé de lire et suivre le tutoriel suivant :

* '''[[Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)|Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)]]'''

__TOC__

Une application {{FM}} destinée à la plate-forme cible iOS peut être testée initialement sur le '''simulateur iOS''' disponible sur le Mac. La deuxième moitié du processus de test consiste à utiliser la plate-forme cible '''Périphérique iOS''' et requiert un périphérique iOS test connecté au Mac.

: '''Remarque :''' Sur les périphériques iOS, vous pouvez exécuter à la fois des applications Delphi et C++. Toutefois, le '''simulateur iOS''' n'étant pas pris en charge par '''[[BCCIOSARM.EXE, le compilateur C++ pour le périphérique iOS 32 bits|BCCIOSARM]]''', seuls les périphériques iOS sont supportés pour C++.

Pour déployer une application iOS sur votre périphérique iOS ou sur un simulateur iOS à des fins de débogage et de test, {{Product}} utilise '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' ; vous devez [[Installation de Platform Assistant sur un Mac|l'installer]] et [[Exécution de Platform Assistant sur un Mac|l'exécuter]] sur le Mac. Votre environnement de développement matériel et logiciel doit présenter la configuration illustrée à la figure suivante. {{Product}} s'exécute sur un PC sous Windows. Votre PC doit être connecté à un Mac exécutant '''[[PAServer, l'application serveur Platform Assistant|Platform Assistant]]''' et équipé des versions appropriées de '''[[Installation de Xcode sur un Mac|Xcode]]''' et du SDK iOS (pour le développement iOS). Pour exécuter les apps iOS sur un périphérique iOS, ce dernier doit être connecté au Mac via un câble USB.

[[File:Win2Mac2iOSDevice.png|650px]]

Cette section décrit les étapes de configuration de votre environnement de développement '''après''' la configuration de votre environnement sur votre Mac.

==Configuration de votre environnement {{Product}}==

Vous devez exécuter les étapes de configuration suivantes pour préparer le développement iOS avec {{Product}}.

===[[Créer un profil de connexion|Créer un profil de connexion]] pour le Mac===

# Dans l'EDI {{Product}}, ouvrez '''Outils > Options > Déploiement > [[Gestionnaire de profils de connexion|Gestionnaire de profils de connexion]]''':

# Cliquez sur '''Ajouter''' :
#: [[File:RemoteProfilesPage.png|500px]] 
# Vous voyez maintenant l'expert [[Créer un profil de connexion|Créer un profil de connexion]]. Définissez le nom du profil de connexion, par exemple "Mon Mac". Assurez-vous de sélectionner '''macOS''' comme plate-forme, puis cliquez sur '''Next''':

#: [[File:AssignSimulatorProfile.png|500px]] 
# Dans la page '''Informations sur la machine distante''', définissez le nom ou l'adresse IP du Mac hôte, le numéro de port à utiliser (le port par défaut 64211 fonctionne en général) et un mot de passe facultatif (si vous souhaitez utiliser un mot de passe).
#: [[File:Specify name of your mac.png|500px]] 
# Cliquez sur '''Tester connexion''' et assurez-vous que le profil de connexion fonctionne sans erreur (vous devez recevoir le message '''"La connexion à <nom d'hôte> sur le port <numéro de port> a réussi"''').
# Si l'opération '''Tester connexion''' réussit, cliquez sur le bouton '''Terminer''', sinon vérifiez les paramètres et essayez à nouveau. 

===[[Ajout d'un SDK OS X ou iOS|Ajouter un SDK]] au système de développement pour le périphérique iOS connecté au Mac===

# Ouvrez {{Menu|Options > Options > Options d'environnement > [[Gestionnaire de SDK|Gestionnaire de SDK]]}}.
#: [[File:SDKManagerConfigs.png|500px]] 
# Cliquez sur '''Ajouter'''.
# Sur la boîte de dialogue '''Ajouter un nouveau SDK''', sélectionnez '''Périphérique iOS 32 bits''' ou '''Périphérique iOS 64 bits''' comme plate-forme.
#: [[File:SelectSDKProfile.png]] 
# Une fois la plate-forme sélectionnée, l'EDI remplit un profil (comme "Mon Mac") et la zone de liste déroulante relative à la version SDK par la liste des versions SDK disponibles sur la machine exécutant le serveur Platform Assistant :
#: [[File:SelectSDKProfileAndVersion.png]] 
# Cliquez sur '''OK''' pour ajouter le nouveau SDK sélectionné.
# Une fois l'opération terminée, cliquez sur '''Fermer''' pour fermer la boîte de dialogue.

==Voir aussi==

* [[Tutoriel mobile : Création d'une application pour les plates-formes mobiles (iOS et Android)|Tutoriel mobile : Création d'une application pour les plates-formes mobiles (iOS et Android)]]
* [[Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)|Tutoriel mobile : Définition de votre environnement de développement sur le Mac (iOS)]]
* [[Travailler avec un Mac et un PC|Travailler avec un Mac et un PC]]
* [[Exécution de votre application iOS sur un périphérique iOS|Exécution de votre application iOS sur un périphérique iOS]]
* [[Exécution de votre application iOS sur le simulateur iOS|Exécution de votre application iOS sur le simulateur iOS]]
* [[Prérequis de plate-forme FireMonkey|Prérequis de plate-forme FireMonkey]]
* [[Création d'une app iOS|Création d'une app iOS]]
* [[Développement d'applications OS X|Développement d'applications macOS]]
* [[Création d'une application FireMonkey|Création d'une application FireMonkey]]
* Pages Apple developer.apple.com
** [http://developer.apple.com/library/ios/navigation/ iOS Developer Library (EN)]
** [http://developer.apple.com/library/ios/navigation/index.html?section=Resource+Types&topic=Getting+Started iOS Developer Library: Getting Started (EN)]
** [http://developer.apple.com/devcenter/ios/index.action iOS Dev Center (EN)]
** [https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/LaunchingYourApponDevices/LaunchingYourApponDevices.html Lancement de votre app sur des périphériques (EN)]
** [https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/Introduction/Introduction.html Preparing Your iOS App for Distribution in the App Store (EN)]
** [http://developer.apple.com/iad/ iAd Network (EN)]

[[Category:Delphi]]
[[Category:FMX]]
[[Category:IOS]]
[[Category:XE4]]
[[Category:AMMigrate]]

Tutoriel mobile : Définition de votre environnement de développement sur un PC Windows (iOS)

2020-07-30T06:28:06Z

Yukikoi : 1 révision importée : LOC-23340

Importation ou migration de projets existants dans RAD Studio

2020-07-30T06:10:32Z

Yukikoi : LOC-23340

{{Parent|Considérations pour les applications multi-périphériques}}

==Mise à niveau des projets requise dans certaines instances==

La boîte de dialogue '''Mise à niveau des projets requise''' peut s'afficher si l'EDI détermine que l'ouverture de votre projet existant dans {{Variables|Product}} nécessite des modifications cruciales (par exemple, si le projet existant n'a pas de fichier .dproj ou .cbproj).

Sur la boîte de dialogue '''Mise à niveau des projets requise''', vous pouvez choisir exactement ce qui doit se produire à propos du renommage et de la sauvegarde de votre projet existant. Les mêmes choix sont aussi disponibles sur la boîte de dialogue '''Outils > Options > EDI > [[Mise à niveau des projets|Mise à niveau des projets]]'''.

La case à cocher suivante contrôle l'occurrence de la boîte de dialogue '''Mise à niveau des projets requise''' :

<code>Supprimer cette notification et appliquer mon choix à tous les projets convertis</code>

Si vous sélectionnez cette case à cocher :

* Vos choix actuels sur la boîte de dialogue '''Mise à niveau des projets requise''' seront automatiquement implémentés pour les projets existants que vous ouvrez.
* La boîte de dialogue '''Mise à niveau des projets requise''' n'apparaîtra pas quand vous ouvrez des projets existants qui nécessitent des modifications cruciales.
* Vous pouvez toutefois changer vos choix quant au renommage et à la sauvegarde des projets existants en accédant à la boîte de dialogue '''Outils > Options > EDI > [[Mise à niveau des projets|Mise à niveau des projets]]'''. Par exemple, après l'activation de la case à cocher '''Appliquer les paramètres sans invite''', la boîte de dialogue '''Mise à niveau des projets requise''' s'affichera de nouveau pour les projets qui nécessitent une mise à niveau.

==Plate-forme cible : macOS, iOS ou Android==

Un projet VCL ne peut pas être assigné à la plate-forme cible '''macOS''', '''iOS''' ou '''Android'''.

Pour créer une application multi-périphérique qui s'exécute sur macOS, iOS ou Android, commencez par créer un type d'application compatible, tel que :

* [[Application HD multi-périphérique|Application HD multi-périphérique]]
* [[Application 3D multi-périphérique|Application 3D multi-périphérique]]
* [[Application multi-périphérique|Application multi-périphérique]]
* [[Applications console|Application console]]

Pour de plus amples informations, voir :

* '''[[Développement d'applications OS X|Développement d'applications macOS]]'''
* '''[[Développement d'applications mobiles iOS|Développement d'applications mobiles iOS]]'''
* '''[[Développement d'applications mobiles Android|Développement d'applications mobiles Android]]'''

==Plate-forme cible : Windows 64 bits==

# Ouvrez un projet '''Win32''' existant ({{Delphi}} ou {{CBuilder}}) dans {{variables|Product}}.
# Activez le projet importé pour la plate-forme cible '''Win64''' dans le '''[[Fenêtre Projets|Fenêtre Projets]]'''. Pour des détails, voir [[Etapes de la création d'applications multi-périphériques|Etapes de la création d'applications multi-périphériques]].

# Compilez et construisez votre projet.

Si vous utilisez seulement les bibliothèques, les experts, les compilateurs et les composants de {{Variables|Product}}, attendez-vous à quelques problèmes lors de la migration de votre application vers Win64. Toutefois, si votre projet utilise, par exemple, des opérations pointeur ou contient du code assembleur inline, vous devez résoudre quelques problèmes, comme décrit dans [[Conversion des applications Delphi 32 bits en Windows 64 bits|Conversion des applications Delphi 32 bits en Windows 64 bits]].

Pour de plus amples informations, voir :

* '''[[Développement d'applications Windows 64 bits|Développement d'applications Windows 64 bits]]'''
* '''[[Développement d'applications C++ Builder Windows 64 bits|Développement d'applications C++ Builder Windows 64 bits]]'''

==Voir aussi==

* [[Conversion des applications Delphi 32 bits en Windows 64 bits|Conversion des applications Delphi 32 bits en Windows 64 bits]] {{f|vcl|
* [[Migration des applications VCL vers FireMonkey|Migration des applications VCL vers {{FM}}]] }}
* [[Mise à niveau des projets|Mise à niveau des projets]]
* [[Considérations Delphi pour les applications multi-périphériques|Considérations Delphi pour les applications multi-périphériques]]
* [[Considérations C++ pour les applications multi-périphériques|Considérations C++ pour les applications multi-périphériques]]

[[Category:XE2]]
[[Category:Multi-périphérique]]
[[Category:AMMigrate]]

Importation ou migration de projets existants dans RAD Studio

2020-07-30T06:10:17Z

Yukikoi : 1 révision importée : LOC-23340

Gestion des erreurs de mémoire insuffisante

2020-07-30T02:26:28Z

Yukikoi : LOC-23340

{{Parent|Utilisation de ILINK32 et ILINK64 en ligne de commande}}

Lorsque vous utilisez le lieur [[Détails techniques concernant ILINK32 et ILINK64|ILINK32]] ou [[Détails techniques concernant ILINK32 et ILINK64|ILINK64]] de {{Product}}, vous obtenez le message '''Fatal: Out of memory'''. Pour remédier au problème, vous devez identifier le tas du lieur qui est en manque de mémoire et augmenter sa taille.

Pour augmenter la taille de la mémoire du tas concerné, procédez comme suit :

1. Accédez à {{Menu|Outils > Options > EDI > Compilation et exécution}}. 
2. Pour voir quel tas du lieur est à l'origine du problème, sélectionnez '''Diagnostic''' dans le menu '''Verbosité'''. 
3. Tentez à nouveau d'utiliser le lieur, et Lorsque vous obtenez le message '''Fatal: Out of memory''', cliquez sur l'onglet '''Sortie'''. Il contient des informations supplémentaires qui identifient le tas du lieur en dépassement de mémoire. 
4. Dans l'onglet '''Sortie''', trouvez la ligne suivante :

: <code>Overrun on linker heap: </code>
:Le tas que vous voyez après l'affichage du message <code>Overrun on linker heap: </code> est le tas concerné par le dépassement de mémoire.
:Les valeurs relatives à l'ensemble des tas sont listées sous cette ligne. Reportez-vous à l'exemple [[#Indicateurs de la ligne de commande]] ci-dessous.
:* Examinez les deux valeurs hexadécimales suivant le nom du tas en dépassement.
::
::* La première valeur indique la taille requise par le lieur au moment où il réalise que le tas va être dépassé.
::* La seconde valeur indique la taille allouée.
:* Comparez la première et la deuxième valeurs et choisissez une valeur dépassant la première valeur.

[[File:Handling errors.png|450px]] 
5. Maintenant, vous pouvez augmenter la taille du tas concerné par le dépassement. Pour cela, accédez à {{Menu|Projet > Options > Lieur C++}}, puis dans la section '''Paramètres du tas du lieur''', indiquez la nouvelle taille du tas.

:
:* Sur la plate-forme Windows 32 bits, cinq tas sont disponibles. Dans la plupart des cas, il vous suffit d'augmenter trois d'entre eux. '''Taille du tas du code''', '''Taille du tas des données''' ou '''Taille du tas Info'''. Reportez-vous aux valeurs exemple utilisées dans un cas de test signalé :
::
::* '''Taille du tas du code''' : 0x14000000
::* '''Taille du tas des données''' : 0x0d000000
::* '''Taille du tas Info''' : 0x0B000000
::* '''Taille du tas des données RO''' : 0
::* '''Taille du tas TDS''' : 0
:* Sur la plate-forme Windows 64 bits, quatorze tas sont disponibles. Dans la plupart des cas, il vous suffit d'augmenter deux d'entre eux. '''Taille du tas Pubtypes Dwarf''' ou '''Taille du tas Aranges Dwarf'''. Reportez-vous aux valeurs exemple utilisées danss un cas de test signalé :
::
::* '''Taille du tas du code''' : 0
::* '''Taille du tas des données''' : 0
::* '''Taille du tas Abbrev Dwarf''' : 0
::* '''Taille du tas Aranges Dwarf''' : 0
::* '''Taille du tas Info Dwarf''' : 0
::* '''Taille du tas Line Dwarf''' : 0
::* '''Taille du tas Loc Dwarf''' : 0
::* '''Taille du tas Macinfo Dwarf''' : 0
::* '''Taille du tas Pubtypes Dwarf''' : 0x02400000
::* '''Taille du tas Ranges Dwarf''' : 0
::* '''Taille du tas Str Dwarf''' : 0x08000000
::* '''Taille du tas Info''' : 0
::* '''Taille du tas des données RO''' : 0
::* '''Taille du tas TDS''' : 0
:[[File:C++Linker.png|1100px]] 

6. Effectuez une nouvelle tentative de liaison. Si vous obtenez à nouveau le message '''Fatal: Out of memory''', répétez la procédure car vous devrez peut-être augmenter la mémoire d'autres tas.

:'''''Remarque''' : Chaque application requiert d'augmenter différents tas et différentes valeurs.''

==Indicateurs de la ligne de commande==

En cas de construction en ligne de commande, le lieur émettra un tableau similaire à celui obtenu dans l'exemple suivant :
<source lang="C">
Turbo Incremental Link64 6.80 Copyright (c) 1997-2017 Embarcadero Technologies,
Inc.
Overrun on linker heap: info
Linker Heaps
------------
info 0x12271000 0x12000000
code 0x0487d000 0x08000000
rodata 0x00159000 0x06000000
data 0x029bb000 0x08000000
bss 0x08000000 0x08000000
dwarf_aranges 0x00010000 0x00200000
dwarf_macinfo 0x00010000 0x00200000
dwarf_pubtypes 0x00275000 0x02000000
dwarf_info 0x04e57000 0x06000000
dwarf_abbrev 0x00040000 0x00200000
dwarf_line 0x0124d000 0x02000000
dwarf_str 0x036e0000 0x06000000
dwarf_loc 0x00070000 0x02000000
dwarf_ranges 0x00275000 0x02000000
Fatal: Out of memory
</source>

Vous pouvez modifier les tailles de tas utilisées par le lieur via l'indicateur -GH pour les lieurs [[Détails techniques concernant ILINK32 et ILINK64|ilink32]] ou [[Détails techniques concernant ILINK32 et ILINK64|ilink64]]. Utilisez <code>-GH<heapname>=size</code> pour allouer plusieurs tas ou un tas plus grand. Par exemple, pour lier la version de release de la bibliothèque OWLNext ([http://sourceforge.net/projects/owlnext/ DLL OWLNext library (EN)]), nos développeurs {{CBuilder}} internes utilisent <code>-GHinfo=0x13000000</code>.

===Voir aussi===

* [[Utilisation de ILINK32 et ILINK64 en ligne de commande|Utilisation de ILINK32 et ILINK64 en ligne de commande]]
* [[Détails techniques concernant ILINK32 et ILINK64|Détails techniques concernant ILINK32 et ILINK64]]
* [[Lieur C++|Lieur C++]]

[[Category:C++]]

Gestion des erreurs de mémoire insuffisante

2020-07-30T02:26:15Z

Yukikoi : 1 révision importée : LOC-23340

Fenêtre Paramètres du périphérique

2020-07-29T12:04:26Z

Yukikoi : LOC-23340

{{Parent|Gestionnaire de périphériques}}

[[Image:MobileDeviceDesigner.png|thumb|300px]]

{{Menu|Outils > Options > Interface utilisateur > Concepteur de fiches > Gestionnaire de périphériques}} | Cliquez sur '''Ajouter''' ou '''Modifier'''.

Cette boîte de dialogue vous permet de définir ou de modifier un périphérique prédéfini pouvant être ensuite utilisé dans la fenêtre [[Aperçu multi-périphérique|Aperçu multi-périphérique]]. Par ailleurs, si vous installez le [[Ajout d'une vue personnalisée au sélecteur de vue#Créer un nouveau package|package approprié pour ce périphérique]], vous pouvez également le voir dans le [[Concepteur de fiches#Sélecteur de vue|sélecteur de vue]] et l'utiliser en tant que [[Utilisation des vues FireMonkey|vue {{FM}}]].

La fenêtre '''Paramètres du périphérique''' fournit les éléments suivants.

{| border="1" frame="hsides" rules="rows"
|-
! '''Elément'''
! '''Description'''
|- valign="top"
| Nom du périphérique
| Le nom d'affichage du périphérique prédéfini.

'''{{Product}}''' affiche ce nom sur le [[Gestionnaire de périphériques|Gestionnaire de périphériques]], [[Aperçu multi-périphérique|l'Aperçu multi-périphérique]] et le [[Concepteur de fiches#Sélecteur de vue|sélecteur de vue]] (si le [[Ajout d'une vue personnalisée au sélecteur de vue#Créer un nouveau package|package approprié]] est installé).
|- valign="top"
|Plate-forme
|La plate-forme sur laquelle le périphérique prédéfini est censé s'exécuter. Vous pouvez choisir l'une des valeurs suivantes :
* '''Windows'''
* '''macOS'''
* '''iOS'''
* '''Android'''
|- valign="top"
| Facteur de forme
| Le format du périphérique prédéfini. Vous pouvez choisir l'une des valeurs suivantes :
* '''Bureau'''. Lors de la sélection du facteur de forme '''Bureau''', les informations d'orientation sont désactivées car il est inutile de configurer l'orientation pour ce format particulier.
* '''Téléphone'''
* '''Tablette'''
* '''Lecteur multimédia'''
* '''Automobile'''
* '''Industriel'''
* '''Incorporé'''
* '''Montre'''
* '''Lunettes'''
|- valign="top"
| Portrait 

180 degrés 
Paysage aligné à gauche 
Paysage aligné à droite
| Vous pouvez utiliser les onglets de la fenêtre '''Paramètres du périphérique''' pour définir les orientations prises en charge par le périphérique prédéfini, ainsi que l'aspect du périphérique prédéfini dans chacune de ces orientations.
{| border="1" frame="hsides" rules="rows"
|-
! '''Elément'''
! '''Description'''
|- valign="top"
| Activer l'orientation
| Cochez cette option pour activer, dans le périphérique prédéfini en cours, l'orientation de l'onglet sélectionné (Portrait, 180 degrés, Paysage aligné à gauche, Paysage aligné à droite).

Quand vous activez une orientation, '''{{Product}}''' ajoute cette orientation à la liste des orientations supportées du périphérique prédéfini en cours. Lorsque vous sélectionnez le périphérique en cours dans le [[Concepteur de fiches#Sélecteur de vue|sélecteur de vue]] (si le [[Ajout d'une vue personnalisée au sélecteur de vue#Créer un nouveau package|package approprié]] est installé), vous pouvez cliquer sur le bouton [[File:RotateCurrentView.png]] [[Concepteur de fiches#Sélecteur de vue|Rotation]] pour accéder aux orientations prises en charge.
|- valign="top"
| Arrière-plan du périphérique
|Le chemin de l'image à utiliser comme arrière-plan dans le '''[[Concepteur de fiches|Concepteur de fiches]]''' et dans '''[[Aperçu multi-périphérique|l'Aperçu multi-périphérique]]''' quand le périphérique prédéfini en cours est sélectionné.
|- valign="top"
! colspan="2" | '''Coin supérieur gauche de l'écran'''
|- valign="top"
| Gauche
| Le nombre de pixels à partir de la gauche de l'image d'arrière-plan avant que l'écran réel ne démarre.

Pour modifier cette valeur visuellement, faites glisser la poignée supérieure gauche ou la poignée inférieure gauche se trouvant sur l'aperçu de l'image d'arrière-plan.
|- valign="top"
| Haut
| Le nombre de pixels à partir du haut de l'image d'arrière-plan avant que l'écran réel ne démarre.

Pour modifier cette valeur visuellement, faites glisser la poignée supérieure gauche ou la poignée supérieure droite se trouvant sur l'aperçu de l'image d'arrière-plan.
|- valign="top"
! colspan="2" | '''Taille de l'écran'''
|- valign="top"
| Largeur
| La largeur, en pixels, de l'écran du périphérique prédéfini.

Pour modifier cette valeur visuellement, faites glisser la poignée supérieure droite ou la poignée inférieure droite se trouvant sur l'aperçu de l'image d'arrière-plan.
|- valign="top"
| Hauteur
| La hauteur, en pixels, de l'écran du périphérique prédéfini.

Pour modifier cette valeur visuellement, faites glisser la poignée inférieure gauche ou la poignée inférieure droite se trouvant sur l'aperçu de l'image d'arrière-plan.
|- valign="top"
! colspan="2" | '''Barre d'état'''
|- valign="top"
| Taille
| La taille (largeur ou hauteur) de la barre d'état, située dans l'écran du périphérique prédéfini.

Si la '''position''' est définie sur Haut ou Bas, '''Taille''' correspond à la hauteur de la barre d'état.

Si la '''position''' est définie sur Gauche ou Droite, '''Taille''' correspond à la largeur de la barre d'état.
|- valign="top"
| Position
|La position sur l'écran où est située la barre d'état.

Ce paramètre peut avoir l'une des valeurs suivantes :
* '''Haut'''
* '''Bas'''
* '''Gauche'''
* '''Droite'''
|}
|- valign="top"
| Image d'aperçu
|Utiliser l'image d'aperçu du périphérique prédéfini pour modifier visuellement les mesures '''Gauche''' et '''Haut''' de l'écran, ainsi que la taille de la barre d'état.
|- valign="top"
|Zoom
|Permet de changer le zoom de l'image d'aperçu.
|- valign="top"
|Zoom automatique
| Lorsque l'option '''Zoom automatique''' est activée, l'image est automatiquement agrandie lorsque vous faites glisser les poignées pour définir visuellement les mesures de l'écran et de la barre d'état.
|}

==Voir aussi==

* [[Ajout d'un périphérique prédéfini|Ajout d'un périphérique prédéfini]]
* [[Modification d'un périphérique prédéfini|Modification d'un périphérique prédéfini]]
* [[Suppression d'un périphérique prédéfini|Suppression d'un périphérique prédéfini]]
* [[Gestionnaire de périphériques#DevicePresets.xml|DevicePresets.xml]]
* [[Concepteur de fiches|Concepteur de fiches]]

[[Category:Multi-périphérique]]
[[Category:XE8]]
[[Category:AMMigrate]]

Fenêtre Paramètres du périphérique

2020-07-29T12:04:12Z

Yukikoi : 1 révision importée : LOC-23340

Extraits de code mobile

2020-07-29T11:07:50Z

Yukikoi : LOC-23340

{{Parent|Développement d'applications mobiles iOS}}
{{Parent|Développement d'applications mobiles Android}}
__TOC__
[[Image:CodeSnippetsKH.png|thumbnail|300px|right|Extraits de code mobile sur la page d'accueil]]
Les '''extraits de code mobile''' sont des exemples de code courts ; ils vous aident à comprendre comment implémenter les fonctionnalités mobiles de base en utilisant {{Product}}. Tous les extraits de code mobile sont listés [[#Liste des extraits de code mobile|ici]], et certains figurent sur la page d'accueil et la page d'introduction de {{Product}}, comme suit :

* La [[Page d'accueil|page d'accueil]] de '''{{Variables|Product}}''' est disponible dans le produit. Elle fournit :
** Des liens vers certains '''extraits de code mobile''' et de courtes vidéos illustrant les extraits
** Des liens pour démarrer les projets associés avec les '''extraits de code mobile'''
*** Les exemples installés contiennent un répertoire spécifique pour les extraits, typiquement dans {{SamplesPath}}
* La '''[http://www.embarcadero.com/starthere/xe7/index.html page d'introduction pour {{Product}}]''' est disponible depuis la page d'accueil. Elle fournit :
** L'URL du référentiel de code SourceForge pour certains extraits de code
** De courtes vidéos et des liens vers les tutoriels mobiles et les exemples associés (démos).

==Emplacement installé des projets Extraits de code mobile==

Les '''extraits de code mobile''' sont livrés dans les dossiers suivants de l'installation de votre produit (par langage) : 

* {{Path|{{DelphiSamplesPath}}\Mobile Snippets}}
* {{Path|{{CppSamplesPath}}\Mobile Snippets}}

Chaque dossier d'extraits contient les fichiers pour un ou plusieurs projets {{Variables|Product}} : c'est-à-dire les fichiers projet, le code source, les fichiers fiche et un fichier '''Information.txt''' (un fichier readme) pour chaque projet d'extrait de code (par exemple, le projet Accelerometer).

===Pour naviguer rapidement jusqu'aux extraits de code mobile===

#Sélectionnez ‎{{SamplesMenu}}.
#Ouvrez le dossier du langage que vous utilisez (c'est-à-dire, {{Delphi}} ou {{CBuilder}}).
# Ouvrez le dossier '''Mobile Snippets''' :
#* '''{{DelphiSamplesPath}}\Mobile Snippets'''
#* '''{{CppSamplesPath}}\Mobile Snippets'''

==Téléchargement du dernier code source==

Vous pouvez trouver des exemples de code Delphi et C ++ dans {{CodeSamplesRepositories}}. Recherchez par nom dans les référentiels d'exemples en fonction de votre version de RAD Studio.

==Liste des extraits de code mobile==

{| border="1" frame="hsides" rules="rows"
|-
! '''Extrait de code'''
! '''Vous montre comment ...'''
|- valign="top"
| '''Accelerometer'''
| Utiliser le détecteur [[lib_fr:System.Sensors.Components.TMotionSensor|Accelerometer]] pour obtenir des informations sur l'accélération de périphérique, l'accélération angulaire, le mouvement et la vitesse.
|- valign="top"
| '''AccessCameraApp'''
| Utiliser les [[Actions FireMonkey|actions standard]] pour ouvrir l'application Appareil photo sur votre périphérique mobile, prendre une photo et récupérer la photo prise pour l'afficher sur votre fiche multi-périphérique.
* Pour de plus amples informations, voir [[Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)|Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)]].
|- valign="top"
| '''AudioRecPlay'''
| Enregistrer des [[Audio-vidéo dans FireMonkey|données audio (son)]] en utilisant le microphone du périphérique, puis lire ces données audio en utilisant le haut-parleur ou les écouteurs du périphérique.
|-
| '''CameraComponent''' 
| Manipuler la [[Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)|caméra (appareil photo) sur votre périphérique mobile]], puis sélectionner la caméra avant ou arrière. Vous pouvez également sélectionner le mode d'utilisation du flash (toujours activé, automatique ou désactivé).
* Pour de plus amples informations, voir [[Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)|Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)]].
|- valign="top"
| '''CameraRoll'''
| Utiliser les [[Actions FireMonkey|actions standard]] pour ouvrir la bibliothèque de photos de votre périphérique mobile et y récupérer une image pour l'afficher sur votre fiche multi-périphérique.
* Pour de plus amples informations, voir [[Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)|Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)]].
|- valign="top"
| '''CustomPicker'''
| Utiliser le composant [[lib_fr:FMX.ListBox.TComboBox|TComboBox]] pour sélectionner un composant dans la zone de liste déroulante et afficher le texte de l'élément sur un libellé.
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation de composants Zone de liste déroulante pour sélectionner des éléments dans une liste (iOS et Android)|Tutoriel mobile : Utilisation de composants Zone de liste déroulante pour sélectionner des éléments dans une liste (iOS et Android)]].
|- valign="top"
| '''DatePicker'''
| Utiliser le composant [[lib_fr:FMX.DateTimeCtrls.TDateEdit|TDateEdit]] pour sélectionner des dates et les traiter afin de les utiliser dans vos applications {{FM}}.
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation d'un composant Calendrier pour sélectionner une date (iOS et Android)|Tutoriel mobile : Utilisation d'un composant Calendrier pour sélectionner une date (iOS et Android)]].
|- valign="top"
| '''DeviceInfo'''
| Obtenir des informations sur le périphérique, notamment la version du système d'exploitation, le nom du système d'exploitation et le type de périphérique.
|- valign="top"
| '''FireDAC_IBLite'''
|Remplir une vue liste depuis une base de données [[InterBase ToGo|IBLite]] en utilisant [[FireDAC|FireDAC]] et [[LiveBindings dans RAD Studio|LiveBindings]].
|- valign="top"
| '''FireDACSQLite'''
| Remplir une zone de liste depuis une base de données [[Utilisation de SQLite avec FireDAC|SQLite]] en utilisant [[FireDAC|FireDAC]] et [[LiveBindings dans RAD Studio|LiveBindings]].
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation de FireDAC et SQLite (iOS et Android)|Tutoriel mobile : Utilisation de FireDAC et SQLite (iOS et Android)]].
|- valign="top"
| '''Gyroscope'''
| Utiliser le composant [[lib_fr:System.Sensors.TCustomOrientationSensor|Gyroscope]] pour faire pivoter un cube 3D lorsque le périphérique mobile est incliné.
|- valign="top"
| '''HorizontalScroll'''
| Utiliser le composant [[lib_fr:FMX.Layouts.THorzScrollBox|THorzScrollBox]] pour faire défiler deux images identiques.
|- valign="top"
| '''IBLite'''
| Remplir une vue liste depuis une [[InterBase ToGo|base de données IBLite]] en utilisant LiveBindings.
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation de InterBase ToGo avec dbExpress (iOS et Android)|Tutoriel mobile : Utilisation de InterBase ToGo avec dbExpress (iOS et Android)]].
|- valign="top"
|'''InteractiveGestures'''
* '''ImageRotation'''
* '''ImageZoom'''
* '''TapAndHold'''
| Trois extraits de code distincts qui illustrent comment :
* Activer la rotation d'une image sur un périphérique mobile.
* Activer le zoom avant/arrière d'une image sur un périphérique mobile.
* Activer le mouvement Appuyer de façon prolongée (Appuyer et maintenir) sur un périphérique mobile.
|- valign="top"
| '''Location'''
| Utiliser le composant [[lib_fr:System.Sensors.Components.TLocationSensor|TLocationSensor]] pour lire la localisation GPS du périphérique et l'afficher en temps réel sur la fiche. L'extrait de code vous montre également comment utiliser Google Maps pour localiser précisément l'emplacement du périphérique sur une carte réelle.
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation de détecteurs d'emplacement (iOS et Android)|Tutoriel mobile : Utilisation de détecteurs d'emplacement (iOS et Android)]].
|- valign="top"
| '''MessageAlerts'''
| Faire apparaître différents messages d'alerte, utilisant un style de zone d'information standard à un bouton ou des styles de zone de texte à plusieurs boutons permettant différentes confirmations.
|- valign="top"
|'''Notifications'''
* '''SendCancelNotification'''
* '''SetResetBadgeNumber (iOS seulement)'''
| Deux extraits de code distincts qui illustrent comment :
* Utiliser [[lib_fr:System.Notification|l'API de notification]] pour envoyer une notification avec ou sans délai, et aussi pour annuler toutes les notifications envoyées.
* Utiliser [[lib_fr:System.Notification|l'API de notification]] pour définir le numéro de badge sur l'icône de l'application ou réinitialiser le numéro de badge à 0 (iOS seulement).
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation des notifications (iOS et Android)|Tutoriel mobile : Utilisation des notifications (iOS et Android)]].
|- valign="top"
| '''OrientationSensor'''
| Utiliser le composant [[lib_fr:System.Sensors.Components.TOrientationSensor|TOrientationSensor]] pour obtenir des informations en rapport avec la boussole, comme l'inclinaison à 3 axes, la distance et la direction, la direction par rapport au nord magnétique compensée et non compensée et la direction par rapport au nord géographique compensée et non compensée.
|- valign="top"
| '''PhoneDialer'''
| Utiliser [[lib_fr:FMX.PhoneDialer|l'API PhoneDialer]] pour passer un appel téléphonique et obtenir les informations sur l'opérateur.
|- valign="top"
| '''PlayAudioFile'''
| Utiliser [[lib_fr:FMX.Media.TMediaPlayer|TMediaPlayer]] et inclure un fichier audio à des fins de lecture sur le périphérique mobile.
|- valign="top"
| '''ShareSheet'''
| Utiliser les [[Actions FireMonkey|actions standard]] pour ouvrir l'application Appareil photo sur votre périphérique mobile, prendre une photo et récupérer la photo prise pour l'afficher sur votre fiche multi-périphérique. Puis, avec une autre action standard, ouvrir la feuille de partage pour partager cette image avec d'autres services.
* Pour de plus amples informations, voir [[Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)|Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)]].
|- valign="top"
| '''TabSliding'''
| Utiliser un composant [[lib_fr:FMX.TabControl|TabControl]] avec '''TabPosition''' défini sur '''Dots''' pour activer le défilement des éléments Onglet sur les périphériques mobiles. L'application comporte deux éléments Onglet, chacun contenant une image différente.
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation des composants Onglet pour afficher des pages (iOS et Android)|Tutoriel mobile : Utilisation des composants Onglet pour afficher des pages (iOS et Android)]].
|- valign="top"
| '''TimePicker'''
| Utiliser le composant [[lib_fr:FMX.DateTimeCtrls.TTimeEdit|TTimeEdit]] pour sélectionner des dates et les traiter afin de les utiliser dans vos applications {{FM}}.
* Pour de plus amples informations, voir [[samp_en:FMX.TimePicker Sample|Exemple FMX.TimePicker]].
|- valign="top"
| '''VideoPlayback'''
| Lire un clip vidéo existant sur votre périphérique mobile iOS ou Android.
|- valign="top"
| '''WebBrowser'''
| Utiliser un composant [[lib_fr:FMX.WebBrowser.TWebBrowser|TWebBrowser]] sur un périphérique mobile. L'application est constituée d'une zone d'édition, d'un bouton et du composant Navigateur Web. Tapez une adresse dans la zone d'édition et appuyez sur le bouton "Aller à" pour rediriger le navigateur vers votre adresse.
* Pour de plus amples informations, voir [[Tutoriel mobile : Utilisation du composant Navigateur Web (iOS et Android)|Tutoriel mobile : Utilisation du composant Navigateur Web (iOS et Android)]].
|}

==Voir aussi==

* [[Tutoriels mobiles : Développement d'applications mobiles (iOS et Android)|Tutoriels mobiles : Développement d'applications mobiles (iOS et Android)]]
* [[Développement d'applications mobiles iOS|Développement d'applications mobiles iOS]]
* [[Développement d'applications mobiles Android|Développement d'applications mobiles Android]]
* [[Création d'une app Android|Création d'une app Android]]
*[[Intégration de Subversion dans l'EDI|Intégration de Subversion dans l'EDI]]
** [[Valider (SVN)|Valider (SVN)]]
** [[Mettre à jour (SVN)|Mettre à jour (SVN)]]
** [[Navigateur de référentiel|Navigateur de référentiel]]

[[Category:Delphi]]
[[Category:IOS]]
[[Category:Android]]
[[Category:FMX]]
[[Category:Multi-périphérique]]
[[Category:XE4]]
[[Category:AMMigrate]]

Liaison d'une propriété d'un composant à un champ

2020-07-29T11:07:50Z

Yukikoi : LOC-23340

{{Parent|Expert LiveBindings}}

Cette procédure montre comment '''lier une propriété d'un composant à un champ''' d'un ensemble de données, par le biais de '''[[Expert LiveBindings|l'expert LiveBindings]]'''.
__TOC__
Commencez par créer une [[Application HD multi-périphérique|application HD multi-périphérique]], puis placez un contrôle '''TLabel''' et un ensemble de données client sur la fiche. Vous apprendrez comment lier la propriété '''Text''' du libellé à un champ textuel du fichier de données qui est transmis à l'ensemble de données.

<blockquote>'''Remarque :''' Pour que cette procédure fonctionne, la base de données '''biolife.cds''' doit typiquement :
* être installée dans le répertoire /Data accessible via {{SamplesMenu}} ;
* se trouver dans le référentiel Subversion pour les exemples sur {{CodeSamplesRepositories}}.

Notez que la base de données '''biolife.fds''' est une base de données [[FireDAC|FireDAC]] qui peut nécessiter différentes étapes. <f s="radstudio" t="span" />

Un exemple de code qui utilise une base de données similaire (DBDEMOS) est situé dans [[samp_en:FishFacts (Delphi)|l'exemple FishFact ({{Delphi}})]].<f e="radstudio" t="span" />
{{f|datasnap|
Un tutoriel LiveBindings similaire est aussi disponible : [[Tutoriel : Utilisation de LiveBindings pour créer une application sans code|Tutoriel : Utilisation de LiveBindings pour créer une application sans code]].
}}</blockquote>

<blockquote>'''Conseil :''' Afin que '''l'expert LiveBindings''' soit disponible dans le menu contextuel accessible par clic droit, vous devez l'activer dans {{Menu|Outils > Options > LiveBindings}} en sélectionnant "Afficher l'expert LiveBindings dans le menu contextuel". (Si vous démarrez l'expert depuis le [[Concepteur LiveBindings|Concepteur LiveBindings]], vous n'avez alors pas besoin d'activer la commande Expert dans la boîte de dialogue Options.)</blockquote>

==Etape 1 : Tâche de liaison==

Dès que vous avez placé le contrôle libellé sur la fiche, vous devez le lier au champ '''Category''' de l'ensemble de données.

Cliquez d'abord sur le composant ensemble de données client, puis dans '''[[Inspecteur d'objets|l'inspecteur d'objets]]''', localisez la propriété '''FileName'''. Spécifiez l'emplacement de la base de données '''biolife.cds'''.

Localisez la propriété '''Active''' dans [[Inspecteur d'objets|l'inspecteur d'objets]] et définissez-la sur '''True'''.

Cliquez avec le bouton droit sur le contrôle image et sélectionnez la commande '''Expert LiveBindings'''.

Sélectionnez ensuite '''Lier une propriété de Label1 à un champ''' dans la page '''Tâche de liaison''' de l'expert.

[[Image:LBTLinkPropertyWithField1.png]]

Validez votre sélection en cliquant sur le bouton '''Suivant'''.

==Etape 2 : Propriété de composant==

Vous êtes maintenant invité à sélectionner le composant et la propriété auxquels vous voulez lier votre libellé.

Dans la zone de liste déroulante '''Composant''', sélectionnez '''Label1'''.

Dans la zone de liste déroulante '''Propriété''', sélectionnez '''Text''', puisque vous voulez lier le libellé au champ texte '''Category'''.

[[Image:LBTLinkPropertyWithField2.png]]

Cliquez sur '''Suivant'''.

==Etape 3 : Source de données==

Vous devez sélectionner ici l'ensemble de données depuis l'onglet '''Source existante'''. Choisissez '''ClientDataSet1'''.

[[Image:LBTLinkPropertyWithField3.png]]

Cliquez sur '''Suivant'''.

==Etape 4 : Champ==

La liste des champs disponibles de la base de données '''biolife.cds''' est maintenant présentée.

Sélectionnez le champ '''Category'''.

[[Image:LBTLinkPropertyWithField4.png]]

Cliquez sur '''Suivant'''.

==Etape 5 : Options==

Vous êtes invité à préciser si vous voulez créer un navigateur de source de données avec votre expression de liaison.

Pour cet exemple, choisissez d'ajouter un navigateur.

[[Image:LBTLinkPropertyWithField5.png]]

Cliquez sur '''Terminer''' car c'est la dernière page de l'expert.

Dès que l'expert est fermé, une nouvelle expression de liaison est créée. Elle lie la propriété '''Text''' du contrôle image et le champ '''Category''' de l'ensemble de données spécifié.

==Les résultats==

Dès que l'expert est fermé et que vous revenez dans le concepteur de l'EDI, vous constatez que deux nouveaux composants associés au moteur LiveBindings ont été ajoutés ('''TBindingsList''' et '''TBindScopeDB''') ainsi qu'un composant '''TBindNavigator'''. Pour afficher la boîte de dialogue [[Editeur d'expressions de liaison|Editeur d'expressions de liaison]], double-cliquez sur le composant '''BindingsList1'''.

[[Image:LBTLinkPropertyWithFieldBindingsList.png]]

Exécutez maintenant l'application (appuyez sur '''F9''') et testez votre expression de liaison en parcourant les enregistrements de l'ensemble de données. Vous devriez constater que le texte du libellé est mis à jour correctement.

Un écran représentant l'exécution de l'application est affiché ci-dessous.

[[Image:LBTLinkPropertyWithFieldResults.png]]

==Voir aussi==

* [[Tutoriel : Utilisation de LiveBindings pour créer une application sans code|Tutoriel : Utilisation de LiveBindings pour créer une application sans code]]
* [[LiveBindings dans RAD Studio|LiveBindings dans RAD Studio]]
* [[Expert LiveBindings|Expert LiveBindings]]
* [[Liaison d'un contrôle à un champ|Liaison d'un contrôle à un champ]]
* [[Liaison d'un contrôle à une propriété de composant|Liaison d'un contrôle à une propriété de composant]]
* [[Liaison d'une propriété d'un composant à un contrôle|Liaison d'une propriété d'un composant à un contrôle]]
* [[Création d'une source de données (Expert LiveBindings)|Création d'une source de données]]

[[Category:Delphi]]
[[Category:XE3]]
[[Category:LiveBindings]]
[[Category:Référence RAD Studio]]
[[Category:AMMigrate]]

Extraits de code mobile

2020-07-29T11:07:38Z

Yukikoi : 1 révision importée : LOC-23340

Liaison d'une propriété d'un composant à un champ

2020-07-29T11:07:37Z

Yukikoi : 1 révision importée : LOC-23340

Liaison d'un contrôle à un champ

2020-07-29T10:30:47Z

Yukikoi : LOC-23340

{{Parent|Expert LiveBindings}}

Cette procédure montre comment '''lier un contrôle à un champ''' d'un ensemble de données, par le biais de '''[[Expert LiveBindings|l'expert LiveBindings]]'''.
__TOC__
Commencez par créer une [[Application HD multi-périphérique|application HD multi-périphérique]]. Placez ensuite un libellé et un ensemble de données client sur la fiche. Vous allez lier le contrôle libellé à un champ texte du fichier de données qui est transmis à l'ensemble de données.

Pour que cette procédure fonctionne, vous devez disposer de la base de données '''biolife.cds''' qui est typiquement installée dans \Data du répertoire Samples sur {{SamplesMenu}}. {{f|radstudio|Biolife.cds et est aussi disponible avec les autres exemples sur {{CodeSamplesRepositories}}. Un exemple de code utilisant une base de données similaire (DBDEMOS) est décrit dans [[samp_en:FishFacts (Delphi)|FishFacts ({{Delphi}})]]. }} Notez que la base de données '''biolife.fds''' est une base de données [[FireDAC|FireDAC]] pouvant nécessiter différentes étapes. {{f|datasnap|Un autre tutoriel LiveBindings est aussi disponible ici : [[Tutoriel : Utilisation de LiveBindings pour créer une application sans code|Tutoriel : Utilisation de LiveBindings pour créer une application sans code]].}}

<blockquote>'''Conseil :''' Afin que '''l'expert LiveBindings''' soit disponible dans le menu contextuel par clic droit, vous devez l'activer dans {{Menu|Outils > Options > [[Options LiveBindings|LiveBindings]]}} en sélectionnant "'''Afficher l'expert LiveBindings dans le menu contextuel'''". (Si vous démarrez l'expert depuis le [[Concepteur LiveBindings|Concepteur LiveBindings]], vous n'avez alors pas besoin d'activer la commande Expert dans la boîte de dialogue Options.)</blockquote>

==Etape 1 : Tâche de liaison==

Dès que vous avez placé le contrôle libellé sur la fiche, vous devez le lier au champ '''Name''' de l'ensemble de données.

Cliquez d'abord sur le composant ensemble de données client, puis dans '''[[Inspecteur d'objets|l'inspecteur d'objets]]''', localisez la propriété '''FileName'''. Spécifiez l'emplacement de la base de données '''biolife.cds'''.

Localisez la propriété '''Active''' dans [[Inspecteur d'objets|l'inspecteur d'objets]] et définissez-la sur '''True'''.

Cliquez avec le bouton droit sur le contrôle libellé et sélectionnez la commande '''Expert LiveBindings'''.

Sélectionnez ensuite '''Lier "Label1" à un champ''' dans la page '''Tâche de liaison''' de l'expert.

[[Image:LBTLinkControlWithField1.png]]

Validez votre sélection en cliquant sur le bouton '''Suivant'''.

==Etape 2 : Source de données==

Vous devez sélectionner ici l'ensemble de données sur l'onglet '''Source existante'''.

[[Image:LBTLinkControlWithField2.png]]

Validez votre sélection en passant à l'étape suivante.

==Etape 3 : Champ==

La liste des champs disponibles de la base de données '''biolife.cds''' est maintenant présentée. Sélectionnez le champ '''Category'''.

[[Image:LBTLinkControlWithField3.png]]

Cliquez sur '''Suivant'''.

==Etape 4 : Options==

Vous êtes invité à préciser si un navigateur de source de données doit être créé avec votre expression de liaison.

Choisissez d'ajouter un navigateur de source de données pour cet exemple.

[[Image:LBTLinkControlWithField4.png]]

Cliquez sur '''Terminer''' car c'est la dernière page de l'expert.

Dès que l'expert est fermé, une nouvelle expression de liaison est créée. Elle lie le contrôle libellé et le champ '''Category''' de l'ensemble de données spécifié.

==Les résultats==

Dès que l'expert est fermé et que vous êtes revenu dans le concepteur de l'EDI, vous constatez que deux nouveaux composants associés au moteur LiveBindings ont été ajoutés ('''TBindingsList''' et '''TBindScopeDB''') ainsi qu'un composant '''TBindNavigator'''. Pour afficher la boîte de dialogue [[Editeur d'expressions de liaison|Editeur d'expressions de liaison]], double-cliquez sur le composant '''BindingsList1'''.

[[Image:LBTLinkControlWithFieldBindingsList.png]]

Exécutez maintenant l'application (appuyez sur '''F9''') et testez votre expression de liaison en parcourant les enregistrements de l'ensemble de données. Vous devriez constater que le libellé est mis à jour correctement.

Un écran de l'exécution de l'application est présenté ci-dessous.

[[Image:LBTLinkControlWithFieldResults.png]]

==Voir aussi==

* [[LiveBindings dans RAD Studio|LiveBindings dans RAD Studio]]
* [[Expert LiveBindings|Expert LiveBindings]]
* [[Liaison d'un contrôle à une propriété de composant|Liaison d'un contrôle à une propriété de composant]]
* [[Liaison d'une propriété d'un composant à un contrôle|Liaison d'une propriété d'un composant à un contrôle]]
* [[Liaison d'une propriété d'un composant à un champ|Liaison d'une propriété d'un composant à un champ]]
* [[Création d'une source de données (Expert LiveBindings)|Création d'une source de données]]

[[Category:Delphi]]
[[Category:XE3]]
[[Category:LiveBindings]]
[[Category:Référence RAD Studio]]
[[Category:AMMigrate]]

Liaison d'un contrôle à un champ

2020-07-29T10:30:33Z

Yukikoi : 1 révision importée : LOC-23340

Développement d'applications DataSnap

2020-07-29T10:17:40Z

Yukikoi : LOC-23340

{{Parent|Types d'applications principaux}}

__TOC__
{{f|radstudio|
La technologie '''DataSnap''' continue à évoluer au fur et à mesure que les demandes d'une informatique distribuée augmentent. La technologie sous-jacente à DataSnap a été déplacée au-delà de l'approche des données distantes à travers Microsoft COM/DCOM vers une approche de communication plus ouverte, basée sur TCP/IP. Cette évolution a permis à la technologie DataSnap d'étendre ses capacités afin d'inclure une technologie middleware complète. L'une des fonctionnalités clés de la technologie est sa '''rapidité''' : rapide à construire, rapide à déployer et rapide à exécuter en production.

DataSnap a maintenant des capacités étendues, permettant à la technologie de fonctionner au sein de la plupart des infrastructures basées sur les standards. Tandis que le dernier DataSnap a toujours une compatibilité descendante avec l'approche COM/DCOM, il a maintenant la capacité de communiquer nativement à travers TCP/IP et alternativement à travers HTTP ou HTTPS. En même temps, la logique métier trouvée dans les serveurs DataSnap peut être diffusée en tant que services RESTful.
}}{{f|appmethod|
La technologie '''DataSnap''' continue à évoluer au fur et à mesure que les demandes d'une informatique distribuée augmentent. La technologie sous-jacente à DataSnap a évolué et est passée d'une approche d'accès aux données distantes via Microsoft COM/DCOM à une approche de communication plus ouverte, basée sur les services RESTful. Cette évolution a permis à la technologie DataSnap d'étendre ses capacités afin d'inclure une technologie middleware complète. L'une des fonctionnalités clés de la technologie est sa '''rapidité''' : rapide à construire, rapide à déployer et rapide à exécuter en production.

DataSnap a maintenant des capacités étendues, permettant à la technologie de fonctionner au sein de la plupart des infrastructures basées sur les standards. Tandis que le dernier DataSnap a toujours une compatibilité descendante avec l'approche COM/DCOM, il a maintenant la capacité de communiquer nativement à travers HTTP ou HTTPS.
}}

L'utilisation ou le déploiement de la technologie DataSnap ne requiert aucun frais supplémentaire.

==Présentation détaillée de DataSnap==

[[Image:DataSnapArch.png]]

{{f|radstudio|

===Connecteurs DataSnap pour les périphériques mobiles===

Vous pouvez maintenant créer des applications pour les périphériques mobiles tels que l'iPhone (iOS) et les périphériques Android (Java), Blackberry (Java) et Windows Phone 7 (C# Silverlight).

Pour de plus amples informations, voir :

*[[Introduction aux connecteurs mobiles DataSnap|Introduction aux connecteurs mobiles DataSnap]]
** [[Introduction au connecteur mobile iOS Objective-C DataSnap|Introduction au connecteur mobile iOS Objective-C DataSnap]]
** [[Introduction au connecteur mobile CSharp Silverlight DataSnap|Introduction au connecteur mobile CSharp Silverlight DataSnap]]
** [[Introduction au connecteur mobile Java Android DataSnap|Introduction au connecteur mobile Java Android DataSnap]]
** [[Introduction au connecteur mobile Java BlackBerry DataSnap|Introduction au connecteur mobile Java BlackBerry DataSnap]]

}}

===Exemple de code DataSnap Proxy===

L'exemple de code {{Delphi}} '''[[samp_en:DSProxyGenerator (Delphi)|DSProxyGenerator_({{Delphi}})]]''' illustre comment générer un proxy client DataSnap à l'exécution.
<f s="radstudio" />

===Applications exemple DataSnap disponibles dans l'installation de votre produit===

Vous pouvez trouver des applications exemple '''DataSnap''' (installées avec {{Product}}) en choisissant {{SamplesMenu}}. Les dossiers présentant un intérêt sont {{Path|\Object Pascal\DataSnap\}}, contenant les démos multiplates-formes '''DataSnap'''. Ces exemples DataSnap sont appelés, par leur nom de dossier :

* ''[[samp_en:DataSnap.Basic DataSnap Client and Server Sample|DataSnap\Basic -- Exemple Basic DataSnap Client and Server]]''
* ''[[samp_en:DataSnap.EchoToChannel Sample|DataSnap\EchoToChannel -- Exemple EchoToChannel]]''

Vous trouverez aussi des fichiers '''Readme.htm''' (dans les sous-dossiers '''DataSnap''') qui fournissent des informations utiles sur les démos multiplates-formes DataSnap.

Le source des exemples DataSnap de l'installation de votre produit est archivé dans un référentiel Subversion public résidant sur {{CodeSamplesRepositories}}:
Pour extraire une copie du référentiel Subversion contenant les applications exemple DataSnap, suivez le [{{demosurl}} lien d'extraction Subversion]. En outre, vous pouvez valider les modifications apportées aux exemples, et mettre aussi à jour vos copies locales pour acquérir les dernières modifications effectuées aux exemples sur {{CodeSamplesRepositories}}.

Les vidéos suivantes fournissent plus d'informations à propos de la technologie DataSnap :

* [http://cc.embarcadero.com/javascript/play.html?u=y&w=1024&h=768&s=11.4MB&f=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27275%26file%3dAdrianAndrei_developing_multitier_datasnap.swf&d=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27275 Developing Multi-Tier Solutions Using DataSnap (EN)]
* [http://cc.embarcadero.com/javascript/play.html?u=y&w=1024&h=768&s=85.6MB&f=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27287%26file%3dJimTierney_DataSnapTooling.swf&d=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27287 DataSnap Tooling (EN)]
* [http://www.embarcadero.com/rad-in-action/datasnap-xe Building DataSnap Clients and Servers (EN)]

<f e="radstudio" />

==Rubriques==

* [[Présentation et architecture de DataSnap|Présentation et architecture de DataSnap]]{{f|radstudio|
* [[Prise en charge de l'explorateur de données pour DataSnap|Prise en charge de l'explorateur de données pour DataSnap]]}}
* {{f|radstudio|[[Tutoriel : Utilisation d'un serveur DataSnap avec une application|Utilisation d'un serveur DataSnap avec une application (Tutoriel)]]}}{{f|appmethod|[[Tutoriel : Utilisation d'un serveur DataSnap REST avec une application|Utilisation d'un serveur DataSnap avec une application (Tutoriel)]]}}{{f|radstudio|
*[[Application Serveur DataSnap|Application Serveur DataSnap]]
** [[Création d'un serveur DataSnap|Création d'un serveur DataSnap]]
** [[Expert Serveur DataSnap|Expert Serveur DataSnap]]}}
** [[Expert Application DataSnap REST|Expert Application DataSnap REST]]{{f|radstudio|
** [[Expert Application DataSnap WebBroker|Expert Application DataSnap WebBroker]]
** [[Génération de proxies de méthodes serveur DataSnap|Génération de proxies de méthodes serveur DataSnap]]}}
** [[Exposition des méthodes serveur DataSnap|Exposition des méthodes serveur DataSnap]]{{f|radstudio|
** [[Utilisation des rappels|Utilisation des rappels]]
** [[Cycle de vie de la classe serveur|Cycle de vie de la classe serveur]]
** [[Surveillance et contrôle des connexions DataSnap TCP/IP|Surveillance et contrôle des connexions DataSnap TCP/IP]]}}
*[[Application Client DataSnap|Application Client DataSnap]]
** [[Connexion du client au serveur DataSnap|Connexion du client au serveur DataSnap]]{{f|radstudio|
** [[Filtrage du flux d'octets DataSnap|Filtrage du flux d'octets DataSnap]]}}
** [[Vérification du certificat HTTPS|Vérification du certificat HTTPS]]
* [[Sérialisation des objets utilisateur|Sérialisation des objets utilisateur à l'aide de JSON]]
*[[DataSnap REST|DataSnap REST]]
** [[Filtres de requêtes|Filtres de requêtes]]
** [[JavaScript REST Proxy|JavaScript REST Proxy]]{{f|radstudio|
** [[Mise en cache des paramètres DBX|Mise en cache des paramètres DBX]]}}
** [[Rappels avancés REST|Rappels avancés REST]]
** [[Authentification avec un client JavaScript|Authentification avec un client JavaScript]]
** [[Sessions client JavaScript|Sessions client JavaScript]]
** [[Protocole de messagerie DataSnap REST|Protocole de messagerie DataSnap REST]]
** [[Bibliothèque client REST|Bibliothèque client REST]]
* [[Authentification et autorisation|Authentification et autorisation]]
* [[Gestion des sessions côté serveur|Gestion des sessions côté serveur]]
*[[Environnement Cloud avec DataSnap|Environnement Cloud avec DataSnap]]
** [[Création d'une app iOS#Support OpenSSL|Support OpenSSL]]
** [[Environnement Azure et Cloud avec DataSnap|Environnement Azure et Cloud avec DataSnap]]
** [[Environnement Amazon et Cloud avec DataSnap|Environnement Amazon et Cloud avec DataSnap]]
* [[Gestionnaire de déploiement|Gestionnaire de déploiement]]{{f|radstudio|
* [[Connecteurs DataSnap pour les périphériques mobiles|Connecteurs DataSnap pour les périphériques mobiles]]}}

{{f|appmethod|

===Autres produits de base de données supportés par {{Product}}===

* [[InterBase XE3|InterBase XE3]]
* [[InterBase ToGo|InterBase ToGo]]
* [[SQLite support in Appmethod|Support SQLite dans Appmethod]]

===[[LiveBindings in Appmethod|LiveBindings dans Appmethod]]===

*[[Concepteur LiveBindings|Concepteur LiveBindings]]
** [[Synchronisation des données via LiveBindings|Synchronisation des données via LiveBindings]]
** [[Afficher et masquer des éléments dans le Concepteur LiveBindings|Afficher et masquer des éléments dans le Concepteur LiveBindings]]
** [[Zoom (mise à l'échelle) du Concepteur LiveBindings|Zoom (mise à l'échelle) du Concepteur LiveBindings]]
** [[Enregistrement du diagramme LiveBindings en tant qu'image|Enregistrement du diagramme LiveBindings en tant qu'image]]
** [[Utilisation des couches dans le Concepteur LiveBindings|Utilisation des couches dans le Concepteur LiveBindings]]
* [[Expert LiveBindings|Expert LiveBindings]]
* [[Création de LiveBindings|Création de LiveBindings]]

}}

==Voir aussi==

* {{f|radstudio|[[Tutoriel : Utilisation d'un serveur DataSnap avec une application|Tutoriel : Utilisation d'un serveur DataSnap avec une application]]}}{{f|appmethod|[[Tutoriel : Utilisation d'un serveur DataSnap REST avec une application|Tutorial: Utilisation d'un serveur DataSnap REST avec une application]]}}{{f|radstudio|
* [[Tutoriel : Application DataSnap utilisant un serveur ISAPI DLL|Tutoriel : Application DataSnap utilisant un serveur ISAPI DLL]]}}{{f|appmethod|
* [[Tutoriel : Utilisation de LiveBindings pour créer une application sans code|Tutoriel : Utilisation de LiveBindings pour créer une application sans code]]}}{{f|radstudio|
* [http://www.embarcadero.com/rad-in-action/datasnap-xe Vidéos : Building DataSnap Clients and Servers, par Bob Swart (EN)]
* [http://cc.embarcadero.com/javascript/play.html?u=y&w=1024&h=768&s=11.4MB&f=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27275%26file%3dAdrianAndrei_developing_multitier_datasnap.swf&d=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27275 Vidéo : Developing Multi-Tier Solutions Using DataSnap, par Adrian Andrei (EN)]
* [http://cc.embarcadero.com/javascript/play.html?u=y&w=1024&h=768&s=85.6MB&f=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27287%26file%3dJimTierney_DataSnapTooling.swf&d=http%3a%2f%2fcc.embarcadero.com%2fdownload.aspx%3fid%3d27287 Vidéo : DataSnap Tooling, par Jim Tierney (EN)]
*[http://www.embarcadero.com/rad-in-action/delphi-labs Vidéos : {{Delphi}} Labs, par Paweł Głowacki (EN)]
* [[Creating multi-tiered applications Index|Création d'applications multiniveaux]]
* [[Présentation des applications de bases de données multiniveaux|Présentation des applications de bases de données multiniveaux]]
* [[Connexion au serveur d'applications à l'aide de composants DataSnap|Connexion au serveur d'applications à l'aide de composants DataSnap]]
* [[Contrôles Serveur DataSnap|Contrôles Serveur DataSnap]]
* [[Contrôles Client DataSnap|Contrôles Client DataSnap]]}}
* [[lib_fr:Datasnap.DSConnect.TDSProviderConnection|Datasnap.DSConnect.TDSProviderConnection]]
* [[lib_fr:Datasnap.DSServer|Datasnap.DSServer]]
* [[lib_fr:Datasnap.DSNames|Datasnap.DSNames]]
* [[lib_fr:Datasnap.DSCommonServer|Datasnap.DSCommonServer]]

===Exemples de code et applications exemple DataSnap===

* [[samp_en:DSProxyGenerator (Delphi)|Exemple de code : DSProxyGenerator ({{Delphi}})]]{{f|radstudio|
* [[samp_en:DataSnap.Basic DataSnap Client and Server Sample|Exemple DataSnap.Basic DataSnap Client and Server]]

}}

[[Category:Delphi]]
[[Category:C++]]
[[Category:XE5]]
[[Category:Référence DataSnap]]

Développement d'applications DataSnap

2020-07-29T10:17:26Z

Yukikoi : 1 révision importée : LOC-23340