RAD Studio - Contributions [fr]

Codage des réponses aux actions des utilisateurs dans l'éditeur de code (tutoriel de l'EDI)

2021-10-08T21:17:57Z

Alejandra.Barrientos : RS-108915 Updated Screenshots

{{Parent|Démarrage de votre première application {{Variables|Product}} - Index (tutoriel de l'EDI)}}

En suivant les instructions de cette section, vous rendrez votre application interactive et lui fournirez les fonctionnalités de votre choix. Vous coderez les gestionnaires d'événement, c'est-à-dire les réponses aux clics sur les divers éléments du menu principal et à d'autres types d'interaction de l'utilisateur.

==Commencement du code==

Commencez l'écriture du code en définissant une variable <code>String</code> que vous utiliserez pendant l'exécution de l'application pour stocker le nom du fichier texte ouvert.
<l s="delphi" />

Dans {{Delphi}}, sélectionnez l'onglet '''Code''' dans la barre d'état pour ouvrir '''[[Editeur de code|l'éditeur de code]]'''. Utilisez '''l'éditeur de code''' pour définir une variable <code>String</code> appelée <code>CurrentFile</code> dans la section private de la classe '''TTextEditorForm''' dans la partie <source lang="delphi" enclose="none">interface</source> :

: [[Image:Code_Editor-CurrentFile_Delphi.jpg|Link=|Code Editor for Delphi]]
: ''Définition de la variable private <code>CurrentFile</code> (vue {{Delphi}})''

<l e="delphi" />
<l s="cpp" />

Dans {{CBuilder}}, sélectionnez l'onglet '''TextEditorUnit.h''' dans la barre d'état pour ouvrir le fichier en-tête de l'unité dans '''[[Editeur de code|l'éditeur de code]]'''. Utilisez '''l'éditeur de code''' pour déclarer une variable <code>String</code> appelée <code>CurrentFile</code> dans la section <source lang="cpp" enclose="none">private</source> de '''TTextEditorForm''' :

: [[Image:Code_Editor-CurrentFile_C++.jpg|Link=|Code Editor for C++]]
: ''Définition de la variable private <code>CurrentFile</code> (vue {{CBuilder}})''

<l e="cpp" />

Pour permuter entre les modes '''[[Concepteur de fiches|Concepteur de fiches]]''' et '''[[Editeur de code|Editeur de code]]''', appuyez sur <code>F12</code>.

==Mise à jour de la barre d'état en réponse aux actions sur l'éditeur de texte==

Lorsque les utilisateurs déplacent le ''signe d'insertion'' (curseur de texte) ou modifient le contenu de votre composant '''[[lib_fr:FMX.Memo.TMemo|TMemo]]''', vous devez mettre à jour la barre d'état. Comme vous devez mettre à jour la barre d'état en réponse à de nombreux événements différents, vous avez la possibilité de définir une procédure unique dans votre code et de l'appeler ultérieurement à partir d'un gestionnaire d'événement pour procéder à la mise à jour.
<l s="delphi" />

Dans {{Delphi}}, pour définir cette nouvelle procédure dans votre application, ajoutez la signature de procédure suivante à la section private de la classe '''TTextEditorForm''' dans la partie <source lang="delphi" enclose="none">interface</source> , juste en dessous de la variable <code>CurrentFile</code> que vous avez précédemment définie :

<source lang="delphi">
procedure UpdateStatusBar;
</source>

Cliquez avec le bouton droit sur <code>UpdateStatusBar</code> dans votre code, puis sélectionnez '''Compléter la classe au niveau du curseur''' de manière à ce que {{Product}} ajoute une définition squelette pour votre procédure à la partie <source lang="delphi" enclose="none">implementation</source> de votre code :

<source lang="delphi">
procedure TTextEditorForm.UpdateStatusBar;
begin

end;
</source>

Définissez la logique de la procédure <code>UpdateStatusBar</code> entre ces mots-clés <source lang="delphi" enclose="none">begin</source> et <source lang="delphi" enclose="none">end</source> comme suit :

<source lang="delphi">
LineNumber.Text := 'L: ' + (Editor.CaretPosition.Line+1).ToString;
ColumnNumber.Text := 'C: ' + (Editor.CaretPosition.Pos+1).ToString;
LineCount.Text := 'Lines: ' + Editor.Lines.Count.ToString;
</source><l e="delphi" /><l s="cpp" />

Dans C++, pour définir cette nouvelle fonction dans votre application, ajoutez la signature de fonction suivante à la section <source lang="cpp" enclose="none">private</source> de la classe '''TTextEditorForm''' dans le fichier ''TextEditorUnit.h'', juste en dessous de la variable <code>CurrentFile</code> que vous avez précédemment définie :

<source lang="cpp">
void UpdateStatusBar();
</source>

Sélectionnez le fichier d'implémentation, ''TextEditorUnit.cpp'', et implémentez cette fonction comme suit :

<source lang="cpp">
void TTextEditorForm::UpdateStatusBar()
{
TextEditorForm->LineNumber->Text = L"L: " + String(TextEditorForm->Editor->CaretPosition.Line+1);
TextEditorForm->ColumnNumber->Text = L"C: " + String(TextEditorForm->Editor->CaretPosition.Pos+1);
TextEditorForm->LineCount->Text = L"Lines: " + String(TextEditorForm->Editor->Lines->Count);
}
</source><l e="cpp" />

Vous pouvez à présent appeler <code>UpdateStatusBar</code> à partir de n'importe quel gestionnaire d'événement pour mettre à jour votre barre d'état.

Votre application doit mettre à jour pour la première fois les informations affichées sur la barre d'état lorsque votre application démarre. Pour cela, vous pouvez utiliser l'événement '''OnCreate''' de votre fiche :

# Sélectionnez l'onglet '''Conception''' pour revenir au [[Concepteur de fiches|Concepteur de fiches]].
# Sur la vue [[Vue Structure|Structure]], sélectionnez votre composant fiche, que vous avez nommé <code>TextEditorForm</code>.
# Sur [[Inspecteur d'objets|l'inspecteur d'objets]], ouvrez l'onglet '''Evénements'''.
# Sur l'onglet '''Evénements''', double-cliquez sur le champ de valeur de l'événement '''OnCreate'''. {{Product}} bascule vers [[Editeur de code|l'éditeur de code]] et ajoute une définition squelette pour votre nouveau gestionnaire d'événement. Utilisez ce gestionnaire d'événement pour appeler votre procédure <code>UpdateStatusBar</code> :

<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
procedure TTextEditorForm.FormCreate(Sender: TObject);
begin
Editor.Lines.Add('');
UpdateStatusBar;
end;
</source><l e="delphi" /><l s="cpp" />'''C++ :'''
<source lang="cpp">
void __fastcall TTextEditorForm::FormCreate(TObject *Sender)
{
TextEditorForm->Editor->Lines->Add(L"");
UpdateStatusBar();
}
</source><l e="cpp" />

Notez qu'avant d'appeler <code>UpdateStatusBar</code>, ce code ajoute une ligne vide à votre composant TMemo. Cette action initialise le nombre de lignes du mémo, de sorte que le libellé du nombre de lignes dans la barre d'état affiche "1" ligne à partir du début au lieu de "0" ligne.

Répétez les étapes ci-dessus avec les événements '''OnKeyUp''' et '''OnMouseUp''' de votre composant TMemo, que vous avez nommé <code>Editor</code><l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
procedure TTextEditorForm.EditorKeyUp(Sender: TObject; var Key: Word;
var KeyChar: Char; Shift: TShiftState);
begin
UpdateStatusBar;
end;

procedure TTextEditorForm.EditorMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Single);
begin
UpdateStatusBar;
end;
</source><l e="delphi" /><l s="cpp" />

'''C++ :'''
<source lang="cpp">
void __fastcall TTextEditorForm::EditorKeyUp(TObject *Sender, WORD &Key, System::WideChar &KeyChar,
TShiftState Shift)
{
UpdateStatusBar();
}

void __fastcall TTextEditorForm::EditorMouseUp(TObject *Sender, TMouseButton Button,
TShiftState Shift, float X, float Y)
{
UpdateStatusBar();
}
</source><l e="cpp" />

==Création de gestionnaires d'événement pour les entrées du menu Fichier==

Vous êtes maintenant prêt à définir les réponses aux clics sur les éléments de menu. Dans le [[Concepteur de fiches|Concepteur de fiches]] ouvert, sélectionnez <code>NewAction</code> dans la vue [[Vue Structure|Structure]] :

:[[Image:Code_Editor-IDETutorialSelectingNewAction.jpg|Link=|Selecting New Action]]

Sélectionnez ensuite l'onglet '''Evénements''' dans '''l'inspecteur d'objets''', et double-cliquez sur la zone d'édition correspondant à l'événement <code>OnExecute</code>. '''L'éditeur de code''' s'ouvre et affiche un squelette pour votre nouveau gestionnaire d'événement. Ecrivez dans ce gestionnaire d'événement le code qui s'exécute lorsque les utilisateurs choisissent {{Menu|Fichier > Nouveau}}.
<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
procedure TTextEditorForm.NewActionExecute(Sender: TObject);
var
UserResponse: Integer;
begin
// Ask for confirmation if the memo is not empty.
if not Editor.Text.IsEmpty then
begin
UserResponse := TDialogServiceSync.MessageDialog(
'This will clear the current document. Do you want to continue?',
TMsgDlgType.mtInformation, mbYesNo, TMsgDlgBtn.mbYes, 0);
if UserResponse = mrYes then
begin
Editor.Text := '';
Editor.Lines.Add(''); // Initialize the memo line count to "1".
UpdateStatusBar;
CurrentFile := ''; // New files have no file name until saved.
end;
end;
end;
</source><l e="delphi" /><l s="cpp" />'''C++ :'''
<source lang="cpp">
void __fastcall TTextEditorForm::NewActionExecute(TObject *Sender)
{
if (!TextEditorForm->Editor->Text.IsEmpty()) {
int UserResponse = TDialogServiceSync::MessageDialog(
L"This will clear the current document. Do you want to continue?",
TMsgDlgType::mtInformation, mbYesNo, TMsgDlgBtn::mbYes, 0);
if (UserResponse == mrYes) {
TextEditorForm->Editor->Text = L"";
TextEditorForm->Editor->Lines->Add(L""); // Initialize the memo line count to "1".
UpdateStatusBar();
CurrentFile = L""; // New files have no file name until saved.
}
}
}
</source><l e="cpp" />

Cliquez sur l'onglet '''Conception''' pour revenir au '''Concepteur de fiches''', et répétez le processus pour les actions restantes utilisées par les entrées du menu Fichier : <code>OpenAction</code>, <code>SaveAction</code>, <code>SaveAsAction</code>, <code>ExitAction</code>. Il s'agit des implémentations des gestionnaires d'événement de l'événement '''OnExecute''' de chacune de ces actions :<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
// File > Open
procedure TTextEditorForm.OpenActionExecute(Sender: TObject);
var
FileName: String;
begin
if OpenFileDialog.Execute = True then
begin
FileName := OpenFileDialog.FileName;
if FileExists(FileName) then
begin
Editor.Lines.LoadFromFile(FileName);
CurrentFile := FileName;
Caption := 'Text Editor - ' + ExtractFileName(FileName);
end;
end;
end;

// File > Save
procedure TTextEditorForm.SaveActionExecute(Sender: TObject);
begin
if CurrentFile = '' then
SaveAsAction.Execute()
else
Editor.Lines.SaveToFile(CurrentFile);
end;

// File > Save As
procedure TTextEditorForm.SaveAsActionExecute(Sender: TObject);
var
FileName: String;
UserResponse: TModalResult;
begin
if SaveFileDialog.Execute = True then
begin
FileName := SaveFileDialog.FileName;
if FileExists(FileName) then
begin
UserResponse := TDialogServiceSync.MessageDialog(
'File already exists. Do you want to overwrite?',
TMsgDlgType.mtInformation, mbYesNo, TMsgDlgBtn.mbYes, 0);
if UserResponse = mrNo then
Exit;
end;
Editor.Lines.SaveToFile(FileName);
CurrentFile := FileName;
Caption := 'Text Editor - ' + ExtractFileName(FileName);
end;
end;

// File > Exit
procedure TTextEditorForm.ExitActionExecute(Sender: TObject);
begin
Application.Terminate;
end;
</source><l e="delphi" /><l s="cpp" />'''C++ :'''
<source lang="cpp">
// File > Open
void __fastcall TTextEditorForm::OpenActionExecute(TObject *Sender)
{
if (TextEditorForm->OpenFileDialog->Execute()) {
String FileName = TextEditorForm->OpenFileDialog->FileName;
if (FileExists(FileName)) {
TextEditorForm->Editor->Lines->LoadFromFile(FileName);
CurrentFile = FileName;
Caption = L"Text Editor - " + ExtractFileName(FileName);
}
}
}

// File > Save
void __fastcall TTextEditorForm::SaveActionExecute(TObject *Sender)
{
if (CurrentFile == L"") {
TextEditorForm->SaveAsAction->Execute();
} else {
TextEditorForm->Editor->Lines->SaveToFile(CurrentFile);
}
}

// File > Save As
void __fastcall TTextEditorForm::SaveAsActionExecute(TObject *Sender)
{
if (TextEditorForm->SaveFileDialog->Execute()) {
String FileName = TextEditorForm->SaveFileDialog->FileName;
if (FileExists(FileName)) {
String UserResponse = TDialogServiceSync::MessageDialog(
L"File already exists. Do you want to overwrite?",
TMsgDlgType::mtInformation, mbYesNo, TMsgDlgBtn::mbYes, 0);
if (UserResponse == System::Uitypes::TMsgDlgBtn::mbNo) {
return;
}
}
TextEditorForm->Editor->Lines->SaveToFile(FileName);
CurrentFile = FileName;
Caption = L"Text Editor - " + ExtractFileName(FileName);
}
}

// File > Exit
void __fastcall TTextEditorForm::ExitActionExecute(TObject *Sender)
{
Application->Terminate();
}
</source><l e="cpp" />

==Création de gestionnaires d'événement pour les entrées du menu Edition et Format==

Pour implémenter les actions des entrées du menu dans les menus Edition et Format, vous devez suivre la même procédure que pour les actions du menu Fichier. Ces gestionnaires d'événement sont très simples : ils transmettent simplement l'action à votre mémo, car toutes les fonctionnalités requises sont déjà implémentées dans la classe [[lib_fr:FMX.Memo.TMemo|TMemo]], et ils appellent <code>UpdateStatusBar</code> si l'action peut avoir un effet sur la position du signe d'insertion ou sur le nombre de lignes.<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
// Edit > Cut
procedure TTextEditorForm.CutActionExecute(Sender: TObject);
begin
Editor.CutToClipboard;
UpdateStatusBar;
end;

// Edit > Copy
procedure TTextEditorForm.CopyActionExecute(Sender: TObject);
begin
Editor.CopyToClipboard;
end;

// Edit > Paste
procedure TTextEditorForm.PasteActionExecute(Sender: TObject);
begin
Editor.PasteFromClipboard;
UpdateStatusBar;
end;

// Edit > Select All
procedure TTextEditorForm.SelectAllActionExecute(Sender: TObject);
begin
Editor.SelectAll;
UpdateStatusBar;
end;

// Edit > Undo
procedure TTextEditorForm.UndoActionExecute(Sender: TObject);
begin
Editor.UnDo;
UpdateStatusBar;
end;

// Edit > Delete
procedure TTextEditorForm.DeleteActionExecute(Sender: TObject);
begin
if Editor.SelLength > 0 then
Editor.DeleteSelection
else
Editor.DeleteFrom(Editor.CaretPosition, 1, [TDeleteOption.MoveCaret]);
UpdateStatusBar;
end;

// Format > Word Wrap
procedure TTextEditorForm.WordWrapActionExecute(Sender: TObject);
begin
Editor.WordWrap := not Editor.WordWrap;
WordWrapAction.Checked := Editor.WordWrap;
UpdateStatusBar;
end;
</source><l e="delphi" /><l s="cpp" />'''C++ :'''
<source lang="cpp">
// Edit > Cut
void __fastcall TTextEditorForm::CutActionExecute(TObject *Sender)
{
TextEditorForm->Editor->CutToClipboard();
UpdateStatusBar();
}

// Edit > Copy
void __fastcall TTextEditorForm::CopyActionExecute(TObject *Sender)
{
TextEditorForm->Editor->CopyToClipboard();
}

// Edit > Paste
void __fastcall TTextEditorForm::PasteActionExecute(TObject *Sender)
{
TextEditorForm->Editor->PasteFromClipboard();
UpdateStatusBar();
}

// Edit > Select All
void __fastcall TTextEditorForm::SelectAllActionExecute(TObject *Sender)
{
TextEditorForm->Editor->SelectAll();
UpdateStatusBar();
}

// Edit > Undo
void __fastcall TTextEditorForm::UndoActionExecute(TObject *Sender)
{
TextEditorForm->Editor->UnDo();
UpdateStatusBar();
}

// Edit > Delete
void __fastcall TTextEditorForm::DeleteActionExecute(TObject *Sender)
{
if (TextEditorForm->Editor->SelLength > 0) {
TextEditorForm->Editor->DeleteSelection();
} else {
TextEditorForm->Editor->DeleteFrom(
TextEditorForm->Editor->CaretPosition, 1,
Fmx::Memo::TDeleteOptions() << Fmx::Memo::TDeleteOption::MoveCaret);
}
UpdateStatusBar();
}

// Format > Word Wrap
void __fastcall TTextEditorForm::WordWrapActionExecute(TObject *Sender)
{
TextEditorForm->Editor->WordWrap = !TextEditorForm->Editor->WordWrap;
TextEditorForm->WordWrapAction->Checked = TextEditorForm->Editor->WordWrap;
UpdateStatusBar();
}
</source><l e="cpp" />

==Suivant==

[[Compilation et exécution de l'application (tutoriel de l'EDI)|Compilation et exécution de l'application]]

{{DEFAULTSORT:Codage des reponses aux actions des utilisateurs dans l'editeur de code (tutoriel de l'EDI)}}
[[Category:Delphi]]
[[Category:C++]]
[[Category:XE6]]
[[Category:AMMigrate]]

[[en:Coding responses to user actions in the Code Editor (IDE Tutorial)]]
[[de:Programmieren von Reaktionen auf Benutzeraktionen im Quelltext-Editor (IDE-Tutorial)]]
[[ja:ユーザーアクションに対する応答をコードエディタでコーディングする（IDE チュートリアル）]]

Fichier:Code Editor-IDETutorialSelectingNewAction.jpg

2021-10-08T21:17:06Z

Alejandra.Barrientos : MsUpload

MsUpload

Fichier:Code Editor-CurrentFile Delphi.jpg

2021-10-08T21:16:53Z

Alejandra.Barrientos : MsUpload

MsUpload

Fichier:Code Editor-CurrentFile C++.jpg

2021-10-08T21:16:51Z

Alejandra.Barrientos : MsUpload

MsUpload

Déclaration des génériques

2021-07-30T16:45:45Z

Alejandra.Barrientos : RS-107222

{{Parent|Génériques - Index}}
La déclaration d'un générique est similaire à la déclaration d'un type de classe, d'enregistrement ou d'interface normal. La différence réside dans le fait qu'un ou plusieurs paramètres de type placés entre les crochets angulaires (< et >) suivent l'identificateur de type dans la déclaration d'un générique.

Un paramètre de type peut être utilisé comme un identificateur de type typique dans un corps de méthode et une déclaration de type de conteneur.

Par exemple :
<source lang="delphi">
type
TPair<TKey,TValue> = class // TKey and TValue are type parameters
FKey: TKey;
FValue: TValue;
function GetValue: TValue;
end;

function TPair<TKey,TValue>.GetValue: TValue;
begin
Result := FValue;
end;
</source>

{{Note| Vous devez appeler le constructeur par défaut et initialiser les champs de classe avant d'appeler la méthode '''GetValue'''.}}

==Argument de type==

Les types génériques sont instanciés en fournissant des arguments de type. Dans {{Delphi}}, vous pouvez utiliser n'importe quel type comme argument de type, à l'exception des types suivants : un tableau statique, une chaîne courte ou un type d'enregistrement qui contient (de façon récursive) un champ d'un ou de plusieurs de ces deux types.
<source lang="delphi">
type
TFoo<T> = class
FData: T;
end;
var
F: TFoo<Integer>; // 'Integer' is the type argument of TFoo<T>
begin
...
end.
</source>

==Types imbriqués==

Un type imbriqué dans un générique est lui-même un générique.
<source lang="delphi">
type
TFoo<T> = class // A generic class
type
TBar = class
X: Integer;
end;
end;
</source>

Pour accéder au type imbriqué TBar, vous devez spécifier une construction du premier type TFoo :

<source lang="delphi">
var
N: TFoo<Double>.TBar;
</source>
Un générique peut également être déclaré dans une classe normale en tant que type imbriqué :
<source lang="delphi">
type
TBaz = class // A regular class
type
TQux<T> = class
X: Integer;
end;
end;

type
TOuter = class
type
TData<T> = class
FFoo1: TFoo<Integer>; // declared with closed constructed type
FFoo2: TFoo<T>; // declared with open constructed type
FFooBar1: TFoo<Integer>.TBar; // declared with closed constructed type
FFooBar2: TFoo<T>.TBar; // declared with open constructed type
FBazQux1: TBaz.TQux<Integer>; // declared with closed constructed type
FBazQux2: TBaz.TQux<T>; // declared with open constructed type
...
end;
var
FIntegerData: TData<Integer>;
FStringData: TData<String>;
end;
</source>

==Types de base==

Le type de base d'un type de classe ou d'interface paramétré peut être un type réel ou un type construit. Le type de base ne peut pas être un paramètre de type seul.

<source lang="delphi">
type
TFoo1<T> = class(TBar) // Actual type
end;

TFoo2<T> = class(TBar2<T>) // Open constructed type
end;

TFoo3<T> = class(TBar3<Integer>) // Closed constructed type
end;
</source>
Si TFoo2<String> est instancié, une classe ancêtre devient TBar2<String> et TBar2<String> est automatiquement instancié.

==Types de classe, d'interface et d'enregistrement==

Les types de classe, d'interface, d'enregistrement et de tableau peuvent être déclarés avec des paramètres de type.

Par exemple :
<source lang="delphi">
type
TRecord<T> = record
FData: T;
end;

type
IAncestor<T> = interface
function GetRecord: TRecord<T>;
end;

IFoo<T> = interface(IAncestor<T>)
procedure AMethod(Param: T);
end;

type
TFoo<T> = class(TObject, IFoo<T>)
FField: TRecord<T>;
procedure AMethod(Param: T);
function GetRecord: TRecord<T>;
end;

type
anArray<T>= array of T;
IntArray= anArray<integer>;

</source>

==Types procéduraux==

Le type de procédure et le pointeur de méthode peuvent être déclarés avec des paramètres de type. Les types de paramètre et les types de résultat peuvent également utiliser des paramètres de type.

Par exemple :
<source lang="delphi">
type
TMyProc<T> = procedure(Param: T);
TMyProc2<Y> = procedure(Param1, Param2: Y) of object;
type
TFoo = class
procedure Test;
procedure MyProc(X, Y: Integer);
end;

procedure Sample(Param: Integer);
begin
Writeln(Param);
end;

procedure TFoo.MyProc(X, Y: Integer);
begin
Writeln('X:', X, ', Y:', Y);
end;

procedure TFoo.Test;
var
X: TMyProc<Integer>;
Y: TMyProc2<Integer>;
begin
X := Sample;
X(10);
Y := MyProc;
Y(20, 30);
end;

var
F: TFoo;
begin
F := TFoo.Create;
F.Test;
F.Free;
end.
</source>

==Méthodes paramétrées==

Les méthodes peuvent être déclarées avec des paramètres de type. Les types de paramètre et les types de résultat peuvent utiliser des paramètres de type. Cependant, les constructeurs et les destructeurs ne possèdent pas de paramètres de types, et ni les uns ni les autres ne peuvent avoir de méthodes virtuelles, dynamiques ou de message. Les méthodes paramétrées sont semblables à des méthodes surchargées.

Il existe deux façons d'instancier une méthode :

* Spécifier explicitement l'argument de type
* Déduire automatiquement de l'argument de type

Par exemple :
<source lang="delphi">
type
TFoo = class
procedure Test;
procedure CompareAndPrintResult<T>(X, Y: T);
end;

procedure TFoo.CompareAndPrintResult<T>(X, Y: T);
var
Comparer : IComparer<T>;
begin
Comparer := TComparer<T>.Default;
if Comparer.Compare(X, Y) = 0 then
WriteLn('Both members compare as equal')
else
WriteLn('Members do not compare as equal');
end;

procedure TFoo.Test;
begin
CompareAndPrintResult<String>('Hello', 'World');
CompareAndPrintResult('Hello', 'Hello');
CompareAndPrintResult<Integer>(20, 20);
CompareAndPrintResult(10, 20);
end;

var
F: TFoo;
begin
F := TFoo.Create;
F.Test;
ReadLn;
F.Free;
end.
</source>

==Portée des paramètres de type==

La portée d'un paramètre de type couvre la déclaration de type et les corps de tous ses membres, mais n'inclut pas les types descendants.

Par exemple :
<source lang="delphi">
type
TFoo<T> = class
X: T;
end;

TBar<S> = class(TFoo<S>)
Y: T; // error! unknown identifier "T"
end;

var
F: TFoo<Integer>;
begin
F.T // error! unknown identifier "T"
end.
</source>

==Voir aussi==

*[[Présentation des génériques|Présentation des génériques]]
*[[Terminologie des génériques|Terminologie des génériques]]
*[[Contraintes dans les génériques|Contraintes dans les génériques]]
*[[Compatibilité des types et surcharges dans les génériques|Compatibilité des types et surcharges dans les génériques]]
*[[Variable classe dans les génériques|Variable classe dans les génériques]]

{{DEFAULTSORT:Declaration des generiques}}
[[Category:Delphi]]
[[Category:Guide du langage Delphi]]
[[Category:AMMigrate]]

[[en:Declaring Generics]]
[[de:Deklaration von Generics]]
[[ja:ジェネリックスの宣言]]

Propriétés (Delphi)

2021-06-29T20:06:19Z

Alejandra.Barrientos : /* Spécificateurs de stockage */ RS-107569

{{Parent|Classes et objets - Index}}
__TOC__
<ideTag id="property"></ideTag><ideTag id="type"></ideTag><ideTag id="integerConstant"></ideTag><ideTag id="read"></ideTag><ideTag id="write"></ideTag><ideTag id="stored"></ideTag><ideTag id="default"></ideTag><ideTag id="nodedefault"></ideTag><ideTag id="implements"></ideTag><ideTag id="var"></ideTag><ideTag id="virtual"></ideTag><ideTag id="register"></ideTag><ideTag id="dynamic"></ideTag><ideTag id="const"></ideTag><ideTag id="index"></ideTag><ideTag id="True"></ideTag><ideTag id="False"></ideTag><ideTag id="Boolean"></ideTag><ideTag id="nil"></ideTag><ideTag id="''"></ideTag><ideTag id="class property"></ideTag><ideTag id="published"></ideTag><ideTag id="class var"></ideTag><ideTag id="public"></ideTag><ideTag id="private"></ideTag><ideTag id="protected"></ideTag><ideTag id="strict private"></ideTag><ideTag id="strict protected"></ideTag>Cette rubrique traite les sujets suivants :

* Accès aux propriétés
* Propriétés tableau
* Spécificateurs d'indice
* Spécificateurs de stockage
* Redéclarations et redéfinitions de propriétés
* Propriétés de classes

==A propos des propriétés==

Comme un champ, une propriété définit un attribut d'un objet. Mais alors qu'un champ n'est rien de plus qu'un emplacement de stockage dont le contenu peut être consulté et modifié, une propriété associe des actions spécifiques à la lecture et la modification de ses données. Les propriétés proposent un moyen de contrôler l'accès aux attributs d'un objet et permettent le calcul des attributs.

La déclaration d'une propriété spécifie son nom et son type, et contient au moins un spécificateur d'accès. Une déclaration de propriété a la syntaxe suivante :

'''property '''''propertyName[indexes]: type ''index'' integerConstant specifiers;''

where

* ''propertyName'' est un identificateur correct.
* ''[indexes]'' est facultatif, c'est une suite de déclarations de paramètre séparées par des point-virgules. Chaque déclaration de paramètre est de la forme ''identificateur1'', ..., ''identificateurn'': type. Pour plus d'informations, voir la section Propriétés tableau plus loin.
* type doit être un identificateur de type prédéfini ou déclaré précédemment. C'est-à-dire que les déclarations de propriétés comme property Num: 0..9 ... sont incorrectes.
* la clause index ''integerConstant'' est facultative. Pour plus d'informations, voir la section Spécificateurs d'indice plus loin.
* specifiers est une suite de spécificateurs '''read''', '''write''', '''stored''', '''default''' (ou '''nodefault''') et '''implements'''. Chaque déclaration de propriété doit comporter au moins un spécificateur '''read''' ou '''write'''.

Les propriétés sont définies par leurs spécificateurs d'accès. A la différence des champs, les propriétés ne peuvent être transmises comme paramètre '''var'''. De même, il n'est pas possible d'appliquer l'opérateur '''@''' à une propriété. En effet, une propriété n'existe pas nécessairement en mémoire. Elle peut, par exemple, avoir une méthode '''read''' qui obtient une valeur d'une base de données ou génère une valeur aléatoire.

==Accès aux propriétés==

Chaque propriété a un spécificateur '''read''', un spécificateur '''write''' ou les deux. Ce sont les spécificateurs d'accès. Ils ont la forme suivante :

'''read '''''fieldOrMethod''

'''write '''''fieldOrMethod''

où ''fieldOrMethod'' est le nom du champ ou de la méthode déclaré dans la même classe ou dans une classe ancêtre.

* Si ''fieldOrMethod'' est déclaré dans la même classe, il doit apparaître avant la déclaration de la propriété. S'il est déclaré dans une classe ancêtre, il doit être visible dans le descendant ; ce ne peut donc pas être un champ ou une méthode privé d'une classe ancêtre déclarée dans une autre unité.
* Si ''fieldOrMethod'' est un champ, il doit être de même type que la propriété.
* Si ''fieldOrMethod'' est une méthode, elle ne peut être '''dynamique''' et, si elle est '''virtuelle''', elle ne peut être surchargée. En outre, les méthodes d'accès pour une propriété publiée doivent utiliser la convention d'appel par défaut '''register'''.
* Dans un spécificateur '''read''', si ''fieldOrMethod'' est une méthode, ce doit être une fonction sans paramètre renvoyant une valeur de même type que celui de la propriété. Une exception est une méthode d'accès pour une propriété indicée ou une propriété tableau.
* Dans un spécificateur '''write''', si ''fieldOrMethod'' est une méthode, ce doit être une procédure prenant un seul paramètre valeur ou '''const''' du même type que la propriété (ou plus, s'il s'agit d'une propriété tableau ou d'une propriété indicée).

Par exemple, soit ces déclarations :

property Color: TColor read GetColor write SetColor;

la méthode GetColor doit être déclarée comme suit :

function GetColor: TColor;

et la méthode SetColor doit utiliser l'une des déclarations suivantes :

procedure SetColor(Value: TColor);
procedure SetColor(const Value: TColor);

Le nom du paramètre de SetColor n'a pas besoin d'être Value.

Quand une propriété est référencée dans une expression, sa valeur est lue en utilisant le champ ou la méthode indiqué par le spécificateur '''read'''. Quand une propriété est référencée dans une instruction d'affectation, sa valeur est modifiée en utilisant le champ ou la méthode indiqué par le spécificateur '''write'''.

L'exemple suivant déclare une classe appelée TCompass ayant une propriété publiée Heading. La valeur de Heading est lue via le champ FHeading et écrite via la procédure SetHeading.

type
THeading = 0..359;
TCompass = class(TControl)
private
FHeading: THeading;
procedure SetHeading(Value: THeading);
published
property Heading: THeading read FHeading write SetHeading;
...
end;

Etant donné cette déclaration, les instructions :

if Compass.Heading = 180 then GoingSouth;
Compass.Heading := 135;

correspondent à :

if Compass.FHeading = 180 then GoingSouth;
Compass.SetHeading(135);

Dans la classe TCompass, aucune action n'est associée à la lecture de la propriété Heading ; l'opération '''read''' consiste simplement à récupérer la valeur stockée dans le champ FHeading. Par contre, l'affectation d'une valeur à la propriété Heading se transforme en un appel de la méthode SetHeading qui, probablement, stocke la nouvelle valeur dans le champ FHeading mais effectue également d'autres actions. La méthode SetHeading peut, par exemple, être implémentée de la manière suivante :

procedure TCompass.SetHeading(Value: THeading);
begin
if FHeading <> Value then
begin
FHeading := Value;
Repaint; // actualise l'interface utilisateur afin de refléter la nouvelle valeur
end;
end;

Une propriété dont la déclaration ne contient qu'un spécificateur '''read''' est une propriété en lecture seule, et la propriété dont la déclaration ne comporte que le spécificateur '''write''' est une propriété en écriture seule. Affecter une valeur à une propriété en lecture seule ou utiliser une propriété en écriture seulement dans une expression sont des erreurs.

==Propriétés tableau==

Les propriétés tableau sont des propriétés indicées. Elles peuvent représenter les éléments d'une liste, les contrôles enfant d'un contrôle ou les pixels d'un bitmap.

La déclaration d'une propriété tableau inclut une liste de paramètres spécifiant le nom et le type des indices. Par exemple,

property Objects[Index: Integer] : TObject read GetObject write SetObject;
property Pixels[X, Y: Integer] : TColor read GetPixel write SetPixel;
property Values[const Name: string]: string read GetValue write SetValue;

Le format d'une liste de paramètres indice est le même que celui de la liste de paramètres d'une procédure ou d'une fonction, à cette différence que la déclaration des paramètres est placée entre crochets au lieu de parenthèses. A la différence des tableaux qui ne peuvent utiliser que des indices de type scalaire, les propriétés tableau peuvent avoir des indices de type quelconque.

Pour les propriétés tableau, les spécificateurs d'accès doivent indiquer des méthodes et pas des champs. La méthode d'un spécificateur '''read''' doit être une fonction ayant les mêmes paramètres, en nombre, en ordre et en type, que ceux indiqués dans la liste de paramètres indice de la propriété et dont le type de résultat est identique au type de la propriété. La méthode indiquée par le spécificateur '''write''' doit être une procédure ayant les mêmes paramètres, en nombre, en ordre et en type, que ceux indiqués dans la liste de paramètres indice de la propriété plus un paramètre valeur ou '''const''' supplémentaire du même type que la propriété.

Par exemple, les méthodes d'accès des propriétés tableau déclarées dans l'exemple précédent peuvent se déclarer de la manière suivante :

function GetObject(Index: Integer): TObject;
function GetPixel(X, Y: Integer): TColor;
function GetValue(const Name: string): string;
procedure SetObject(Index: Integer; Value: TObject);
procedure SetPixel(X, Y: Integer; Value: TColor);
procedure SetValue(const Name, Value: string);

Vous accédez à une propriété tableau en indiçant l'identificateur de la propriété. Par exemple, les instructions :

if Collection.Objects[0] = nil then Exit;
Canvas.Pixels[10, 20] := clRed;
Params.Values['PATH'] := 'C:\BIN';

correspondent à :

if Collection.GetObject(0) = nil then Exit;
Canvas.SetPixel(10, 20, clRed);
Params.SetValue('PATH', 'C:\BIN');

La définition d'une propriété tableau peut être suivie de la directive '''default''', auquel cas, la propriété tableau devient la propriété par défaut de la classe. Par exemple,

type
TStringArray = class
public
property Strings[Index: Integer] : string ...; default;
...
end;

Si une classe a une propriété par défaut, vous pouvez accéder à cette propriété en utilisant la forme abrégée object[index] équivalente à object.property[index]. Par exemple, étant donné les déclarations précédentes, StringArray.Strings[7] peut s'abréger en StringArray[7]. Une classe peut n'avoir qu'une seule propriété par défaut avec une signature donnée (liste de paramètres en tableau), mais il est possible de surcharger la propriété par défaut. Changer ou masquer la propriété par défaut dans les classes dérivées peut entraîner un comportement inattendu, car le compilateur effectue toujours les liaisons aux propriétés de manière statique.

==Spécificateurs d'indice==

Les spécificateurs d'indice permettent à plusieurs propriétés de partager la même méthode d'accès alors qu'elles représentent des valeurs différentes. Un spécificateur d'indice est constitué de la directive '''index''' suivie d'une constante entière comprise entre -2147483647 et 2147483647. Si une propriété a un spécificateur d'indice, ses spécificateurs '''read''' et '''write''' doivent indiquer des méthodes et pas des champs. Par exemple,

type
TRectangle = class
private
FCoordinates: array[0..3] of Longint;
function GetCoordinate(Index: Integer): Longint;
procedure SetCoordinate(Index: Integer; Value: Longint);
public
property Left: Longint index 0 read GetCoordinate write SetCoordinate;
property Top: Longint index 1 read GetCoordinate write SetCoordinate;
property Right: Longint index 2 read GetCoordinate write SetCoordinate;
property Bottom: Longint index 3 read GetCoordinate write SetCoordinate;
property Coordinates[Index: Integer] : Longint read GetCoordinate write SetCoordinate;
...
end;

La méthode d'accès d'une propriété ayant un spécificateur d'accès doit prendre un paramètre supplémentaire de type Integer. Pour une fonction '''read''', ce doit être le dernier paramètre ; pour une procédure '''write''', ce doit être l'avant-dernier paramètre (avant le paramètre spécifiant la valeur de la propriété). Quand un programme accède à la propriété, la constante entière est automatiquement transmise à la méthode d'accès.

Etant donné les déclarations précédentes, si Rectangle est de type TRectangle, alors :

Rectangle.Right := Rectangle.Left + 100;

correspond à

Rectangle.SetCoordinate(2, Rectangle.GetCoordinate(0) + 100);

==Spécificateurs de stockage==

Les directives facultatives '''stored''', '''default''' et '''nodefault''' sont appelées des spécificateurs de stockage. Sans effet sur le comportement du programme, les spécificateurs de stockage indiquent si on enregistre ou non la valeur des propriétés publiées dans les fichiers fiche.

La directive '''stored''' doit être suivie par '''True''', '''False''', le nom d'un champ '''Boolean''' ou par le nom d'une méthode sans paramètre qui renvoie une valeur '''Boolean'''. Par exemple,

property Name : TComponentName read FName write SetName stored False;

Si la propriété n'a pas de directive '''stored''', elle est traitée comme si stored '''True''' était spécifié.

La directive '''default''' doit être suivie par une constante du même type que la propriété. Par exemple,

property Tag: Longint read FTag write FTag default 0;

Pour redéfinir une valeur '''default''' héritée sans en spécifier de nouvelle valeur, utilisez la directive '''nodefault'''. Les directives '''default''' et '''nodefault''' ne sont gérées que pour les types scalaires et pour les types ensemble dont les bornes inférieure et supérieure du type de base de l'ensemble sont des valeurs scalaires comprises entre 0 et 31 ; si une telle propriété est déclarée sans '''default''' ni '''nodefault''', elle est traitée comme si '''nodefault''' était spécifié. Pour les réels, les pointeurs et les chaînes, il y a une valeur '''par défaut''' implicite de 0, '''nil''' et <nowiki>''</nowiki> (la chaîne vide), respectivement.

{{Note| Vous ne pouvez pas utiliser la valeur scalaire -2147483648 comme valeur par défaut. Cette valeur est utilisée de manière interne pour représenter '''nodefault'''. }}

Quand on enregistre l'état d'un composant, les spécificateurs de stockage des propriétés publiées du composant sont vérifiés. Si la valeur en cours de la propriété est différente de sa valeur '''par défaut''' (ou s'il n'y a pas de valeur par défaut) et si le spécificateur '''stored''' a la valeur '''True''', alors la valeur de la propriété est enregistrée. Sinon, la valeur de la propriété n'est pas enregistrée.

{{Note| Les valeurs des propriétés ne sont pas automatiquement initialisées à la valeur par défaut. C'est-à-dire que la directive default agit uniquement lorsque les valeurs des propriétés sont enregistrées dans le fichier fiche, mais pas sur la valeur initiale de l'instance nouvellement créée d'une propriété.}}

Les spécificateurs de stockage ne sont pas gérés pour les propriétés tableau. La directive '''default''' a une signification différente quand elle est utilisée dans une déclaration de propriété tableau. Voir Propriétés tableau, ci-avant.

==Redéclarations et redéfinitions de propriétés==

Une déclaration de propriété qui ne spécifie pas de type est appelée une redéfinition de propriété. La redéfinition de propriété permet de modifier la visibilité ou les spécificateurs hérités d'une propriété. La redéfinition la plus simple est constituée uniquement du mot réservé '''property''' suivi de l'identificateur de la propriété héritée ; cette forme est utilisée pour changer la visibilité d'une propriété. Si, par exemple, une classe ancêtre déclare une propriété comme protégée, une classe dérivée peut la redéclarer dans la section publique ou publiée de la classe. La redéfinition de propriété peut comporter les directives '''read''', '''write''','''stored''', '''default''' et '''nodefault''' ; ces directives redéfinissent la directive correspondante héritée. Une directive redéfinie peut remplacer un spécificateur d'accès hérité, ajouter un spécificateur manquant ou augmenter la visibilité d'une propriété. Elle ne peut pas supprimer un spécificateur d'accès ou réduire la visibilité d'une propriété. Une redéfinition peut comporter la directive '''implements''' qui s'ajoute à la liste des interfaces implémentées sans en supprimer d'interfaces héritées.

Les déclarations suivantes illustrent la redéfinition de propriété :

type
TAncestor = class
...
protected
property Size: Integer read FSize;
property Text: string read GetText write SetText;
property Color: TColor read FColor write SetColor stored False;
...
end;

type

TDerived = class(TAncestor)
...
protected
property Size write SetSize;
published
property Text;
property Color stored True default clBlue;
...
end;

La redéfinition de Size ajoute un spécificateur '''write''' afin de permettre la modification de la propriété. La redéfinition des propriétés Text et Color fait passer la visibilité des propriétés de protégée à publiée. La redéfinition de la propriété Color spécifie également que sa valeur doit être enregistrée quand elle n'est pas clBlue.

Une redéclaration de propriété qui inclut un identificateur de type masque la propriété héritée au lieu de la redéfinir. Cela signifie qu'une nouvelle propriété est créée portant le même nom que celle héritée. Toute déclaration de propriété spécifiant un type doit être une déclaration complète et doit donc comporter au moins un spécificateur d'accès.

Si une propriété est masquée ou redéfinie dans une classe dérivée, le substitut de la propriété est toujours statique. C'est-à-dire que c'est le type déclaré (à la compilation) de la variable utilisée pour identifier un objet qui détermine l'interprétation de ses identificateurs de propriété. Ainsi, une fois le code suivant exécuté, la lecture ou l'affectation d'une valeur à MyObject.Value appelle Method1 ou Method2 même si MyObject contient une instance de TDescendant. Mais vous pouvez transtyper MyObject en TDescendant pour accéder aux propriétés de la classe dérivée et à leurs spécificateurs d'accès.

type
TAncestor = class
...
property Value : Integer read Method1 write Method2;
end;

TDescendant = class(TAncestor)
...
property Value : Integer read Method3 write Method4;
end;

var MyObject: TAncestor;
...
MyObject := TDescendant.Create;

==Propriétés de classes==

Les propriétés de classes sont accessibles sans référence d'objet. Les accesseurs de propriétés de classes doivent être déclarés comme méthodes '''statiques de classe''' ou '''champs classe'''. Une propriété de classe se déclare à l'aide des mots-clés '''class property'''. Les propriétés de classes ne peuvent pas être publiées ('''published''') et ne peut pas avoir de définition de valeur '''stored''' ou '''default'''.

La déclaration de bloc '''class var''' vous permet d'introduire un bloc de champs de classe statique dans une déclaration de classe. Tous les champs déclarés après '''class var''' ont des attributs de stockage statique. Un bloc '''class var''' se termine par :

# Une autre déclaration '''class var'''
# Une [[Méthodes (Delphi)|déclaration de procédure ou fonction (c'est-à-dire méthode)]] (y compris des procédures de classe et des fonctions de classe)
# Une déclaration de propriété (y compris des propriétés de classes)
# Une [[Méthodes (Delphi)|déclaration de constructeur ou de destructeur]]
# Un [[Classes et objets (Delphi)|spécificateur de portée de visibilité]] ('''public''', '''private''', '''protected''', '''published''', '''strict private''' et '''strict protected''')

Par exemple :

type
TMyClass = class
strict private
class var // Remarquez que les champs doivent être déclarés comme champs de classe
FRed: Integer;
FGreen: Integer;
FBlue: Integer;
public // termine le bloc class var.
class property Red: Integer read FRed write FRed;
class property Green: Integer read FGreen write FGreen;
class property Blue: Integer read FBlue write FBlue;
end;

Vous pouvez accéder aux propriétés de classes ci-dessus avec le code :

TMyClass.Red := 0;
TMyClass.Blue := 0;
TMyClass.Green := 0;

==Voir aussi==

*[[Classes et objets (Delphi)]]
*[[Champs (Delphi)]]
*[[Méthodes (Delphi)]]
*[[Evénements]]
*[[Déclarations de types imbriqués]]
*[[Références de classes]]
*[[Exceptions (Delphi)]]
*[[Surcharge d'opérateurs (Delphi)]]
*[[Assistances de classes et d'enregistrements (Delphi)]]

{{DEFAULTSORT:Proprietes (Delphi)}}
[[Category:{{Delphi}}]]
[[Category:Guide du langage {{Delphi}}]]
[[Category:AMMigrate]]

[[en:Properties (Delphi)]]
[[de:Eigenschaften (Delphi)]]
[[ja:プロパティ]]

Comptage automatique des références dans les compilateurs mobiles Delphi

2021-03-04T14:20:24Z

Alejandra.Barrientos : Addded Templates

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

Les utilisateurs de {{Delphi}} sont depuis longtemps familiers à la notion de comptage automatique de références (Automatic Reference Counting, ARC). Dans le passé, les compilateurs de bureau {{Delphi}} (DCC32, DCC64, DCCOSX) supportaient ARC pour les interfaces (introduit dans '''{{Delphi}} 3'''), les tableaux dynamiques et les chaînes ('''AnsiString''' a été introduit dans '''{{Delphi}} 2'''). A présent, les compilateurs mobiles {{Delphi}} introduisent le comptage automatique des références pour les classes. En conséquence, la notion de '''référence faible''' a également été introduite afin de gérer les "cycles", avec une autre fonctionnalité : la '''Surcharge des opérateurs pour les classes'''.

Pour obtenir une description détaillée du comptage automatique de références, voir '''[https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]''' (EN).

==Comptage automatique des références==

Le '''comptage automatique de références''' est une façon de gérer la durée de vie d'un objet sans libérer l'objet quand il n'est plus nécessaire. Un bon exemple est une variable locale qui référence un objet qui sort de la portée. Ensuite, l'objet est automatiquement détruit. Comme vu ci-dessus, Delphi prend déjà en charge le comptage de références pour les chaînes et les objets référencés par le biais de variables de type interface. Toutefois, ARC dans les compilateurs mobiles Delphi a une certaine souplesse permettant de résoudre des problèmes tels que les références circulaires qui sont difficiles à gérer avec les variables de type interface.

Une autre notion introduite dans les nouveaux compilateurs mobiles {{Delphi}} est la '''référence faible'''. Celle-ci permet de résoudre des problèmes de références circulaires.

Le schéma de gestion de la mémoire est le même pour les apps compilées pour le périphérique iOS et le simulateur iOS :

* DCCIOSARM (le compilateur {{Delphi}} pour le périphérique iOS 32 bits) dispose par défaut du comptage de références automatique.
* DCCIOSARM (le compilateur {{Delphi}} pour le périphérique iOS 64 bits) dispose par défaut du comptage de références automatique.
* DCCIOS32.EXE (le compilateur {{Delphi}} pour le simulateur iOS) active également ARC, bien que DCCIOS32 soit basé sur l'architecture du compilateur traditionnel.

{{Note| La seule zone dans laquelle ces nouvelles fonctionnalités apparaissent dans le code source de {{Variables|Product}} est à l'intérieur des blocs conditionnels <code>{$AUTOREFCOUNT}</code> au sein de la RTL (par exemple, dans ''System.pas''). }}

==Changements du style de codage==

Puisque les nouveaux compilateurs mobiles supportent le comptage automatique de références, le code peut être simplifié considérablement quand vous avez besoin de faire référence à des objets temporaires au sein d'une méthode. La gestion de la mémoire est complètement ignorée :

<source lang="delphi">
class procedure TMySimpleClass.CreateOnly;
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
MyObj.DoSomething;
end;
</source>

Dans l'exemple ci-dessus, le destructeur de l'objet est appelé quand le programme atteint l'instruction '''end''', c'est-à-dire quand la variable <code>MyObj</code> sort de la portée.

Il est également possible d'arrêter l'utilisation de l'objet avant la fin de la méthode. Pour ce faire, définissez la variable sur '''nil''' :

<source lang="delphi">
class procedure TMySimpleClass.SetNil;
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
MyObj.DoSomething (False); // True => raise
MyObj := nil;
// do something else
end;

</source>

Dans ce cas, l'objet est détruit avant la fin de la méthode, exactement comme nous définissons la variable sur '''nil'''. Dans le cas où la procédure <code>DoSomething</code> déclenche une exception, l'instruction d'affectation '''nil''' sera ignorée. En fin de compte, quand la méthode est terminée, l'objet est toujours détruit.

Au fur et à mesure que le cycle de vie de l'objet suit le flux du programme, vous pouvez interroger le compteur de références d'un objet (seulement sur les plates-formes disposant du comptage de références) en utilisant la nouvelle propriété RefCount :
<source lang="delphi">
public
property RefCount: Integer read FRefCount;
</source>

{{Note| L'interrogation du compteur de références d'un objet n'est pas recommandée et en général, ne doit pas être utilisée. }}

===La vitesse des opérations à blocage===

Les opérations d'incrémentation et de décrémentation du compteur de références d'un objet sont accomplies en utilisant des opérations thread-safe afin que le membre d'instance du compteur de références soit thread-safe. Cela signifie que la variable d'instance du compteur de références est correctement '''délimitée en mémoire''' afin de garantir que tous les threads observent immédiatement le changement et ne peuvent pas modifier une valeur '''obsolète'''.

{{Note| Le mécanisme de comptage de références automatique ne protège pas des conditions de concurrence et des blocages. }}

===ARC et la directive {$AUTOREFCOUNT}===

Vous devez envisager l'usage de la directive <code>{$IFDEF AUTOREFCOUNT}</code> afin d'obtenir le meilleur code pour les deux scénarios : ARC et le scénario traditionnel. <code>AUTOREFCOUNT</code> définit le code qui utilise le comptage de références automatique, tel que le code pour les compilateurs mobiles {{Delphi}}. C'est une directive importante, différente de <code>{$IFDEF NEXTGEN}</code> (la directive qui définit les nouvelles fonctionnalités de langage des compilateurs mobiles). <code>AUTOREFCOUNT</code> pourrait être utile à l'avenir, dans le cas où ARC est implémenté au-dessus des compilateurs de bureau {{Delphi}}.

==Les méthodes [[lib_fr:System.TObject.Free|Free]] et [[lib_fr:System.TObject.DisposeOf|DisposeOf]] sous ARC==

Pour les classes, les développeurs {{Delphi}} sont habitués à un modèle de codage différent, basé sur l'appel de la méthode <code>Free</code>, protégé par un bloc <code>try-finally</code>.

Par exemple :
<source lang="delphi">
class procedure TMySimpleClass.TryFinally;
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.Free;
end;
end;
</source>

Avec les compilateurs de bureau {{Delphi}}, <code>Free</code> est une méthode de <code>TObject</code> qui vérifie si la référence en cours n'est pas nil, et dans ce cas, appelle le destructeur <code>Destroy</code> qui retire l'objet de la mémoire après l'exécution du code de destructeur adéquat.

Dans le nouveau compilateur mobile {{Delphi}}, l'appel de <code>Free</code> est remplacé par l'affectation de la variable à '''nil'''. Dans le cas où il s'agissait de la dernière référence à l'objet, il est toujours retiré de la mémoire après l'appel de son destructeur. Pour les autres références, rien ne se passe (sauf une décrémentation du compteur de références).

<source lang="delphi">
FreeAndNil (MyObj);
</source>

De la même façon, un appel comme celui ci-dessus définit l'objet sur '''nil''' et déclenche de nouveau la destruction de l'objet seulement si aucune autre variable n'y fait référence. Dans la plupart des cas, c'est correct, étant donné que vous ne voulez pas détruire les objets utilisés dans une autre partie d'un programme. D'autre part, il existe des scénarios où vous devez exécuter immédiatement le code du destructeur, indépendamment de la présence d'autres références en suspens à l'objet. Pour permettre aux développeurs de forcer l'exécution du destructeur (sans libérer l'objet réel de la mémoire), le nouveau compilateur introduit un modèle dispose :

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

Cet appel exécute avec vigueur le code du destructeur, même avec des références en suspens existantes. A ce stade, l'objet est placé dans un état spécial, de telle sorte que le destructeur n'est pas appelé de nouveau dans le cas d'autres opérations de destruction ou quand le compteur de références atteint la valeur zéro et que la mémoire est réellement libérée. Cet état '''disposed''' (ou l'état '''zombie''') est assez significatif, et vous pouvez interroger un objet pour celui-ci en utilisant la propriété <code>[[lib_fr:System.TObject.Disposed|Disposed]]</code>.

Comme mentionné plus tôt, les blocs '''try-finally''' classiques utilisés avec les compilateurs de bureau {{Delphi}} fonctionnent toujours correctement sous le nouveau compilateur, même s'ils ne sont pas requis.
Toutefois, dans la plupart des cas, vous souhaiterez utiliser à la place le modèle '''dispose''' (à moins que vous ne vouliez recompiler le code pour les versions antérieures de {{Delphi}}).

Dans l'exemple ci-dessous, l'effet reste le même avec le compilateur classique, puisque <code>DisposeOf</code> appelle Free. A la place, sur ARC, le code exécute le destructeur quand c'est attendu (au même moment que le compilateur classique, mais la mémoire est gérée par le mécanisme ARC).
<source lang="delphi">
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.DisposeOf;
end;
end;
</source>

{{Note| Le stockage de l'indicateur Disposed est un bit dans le champ <code>FRefCount</code>, prenant en compte qu'un objet a une limite de 230 références.}}

==Méthodes de construction et de destruction de TObject sous ARC==

C'est un résumé des méthodes de la classe <code>TObject</code> relatives à la création et à la destruction.

Une des façons de voir la différence entre <code>Free</code> et <code>DisposeOf</code> consiste à considérer l'intention. Lors de l'utilisation de <code>Free</code>, l'intention est que l'utilisateur nécessite que cette référence particulière soit détachée de l'instance. Elle n'implique aucune sorte de destruction ou de désallocation. En revanche, <code>DisposeOf</code> est la manière pour le développeur de préciser explicitement l'instance nécessaire pour "se libérer lui-même". Elle n'implique jamais nécessairement des désallocations, <code>DisposeOf</code> effectue un "pré-nettoyage" explicite de l'instance, qui dépend alors de la sémantique du compteur de références normal pour désallouer éventuellement l'instance.

==Références faibles==

Un autre concept important pour ARC est le rôle des '''références faibles''' que vous pouvez créer en les identifiant avec l'attribut <code>[weak]</code>. Supposons que deux objets s'auto-référencent en utilisant un champ, et qu'une variable externe fait référence au premier. Le compteur de références du premier objet sera 2 (la variable externe, et le deuxième objet), tandis que le compteur de références du deuxième objet est 1. A présent, comme la variable externe sort de la portée, le compteur de références des deux objets reste à 1, et ils restent en mémoire indéfiniment.

Pour résoudre ce type de situation, et de nombreux scénarios similaires, utilisez une référence faible pour rompre les références circulaires quand la dernière référence externe sort de la portée.

Une '''référence faible''' est une référence à un objet qui n'incrémente pas son compteur de références. Pour déclarer une référence faible, utilisez l'attribut <code>[weak]</code>, supporté par les compilateurs mobiles {{Delphi}}.

Etant donné le scénario précédent, si la référence depuis le deuxième objet de retour vers le premier est faible, les deux objets sont détruits quand la variable externe sort de la portée. Voici un exemple de cette situation :

<source lang="delphi">
type
TMyComplexClass = class;

TMySimpleClass = class
private
[Weak] FOwnedBy: TMyComplexClass;
public
constructor Create();
destructor Destroy (); override;
procedure DoSomething(bRaise: Boolean = False);
end;

TMyComplexClass = class
private
fSimple: TMySimpleClass;
public
constructor Create();
destructor Destroy (); override;
class procedure CreateOnly;
end;
</source>

Dans l'extrait de code suivant, le constructeur de la classe complexe crée un objet de l'autre classe :
<source lang="delphi">
constructor TMyComplexClass.Create;
begin
inherited Create;
FSimple := TMySimpleClass.Create;
FSimple.FOwnedBy := self;
end;
</source>

N'oubliez pas que le champ <code>FOwnedBy</code> est une référence faible ; il n'augmente donc pas le compteur de références de l'objet auquel il se réfère, dans ce cas l'objet en cours ('''self''').

Etant donné cette structure de classe, nous pouvons écrire :
<source lang="delphi">
class procedure TMyComplexClass.CreateOnly;
var
MyComplex: TMyComplexClass;
begin
MyComplex := TMyComplexClass.Create;
MyComplex.fSimple.DoSomething;
end;
</source>

Cela ne provoque aucune perte de mémoire, tant que la référence faible est utilisée correctement.

Un autre exemple de l'utilisation des références faibles est cet extrait de code de la RTL {{Delphi}} ; il fait partie de la déclaration de la classe [[lib_fr:System.Classes.TComponent|TComponent]] :
<source lang="delphi">
type
TComponent = class(TPersistent, IInterface,
IInterfaceComponentReference)
private
[Weak] FOwner: TComponent;
</source>

Si vous utilisez l'attribut '''weak''' dans du code compilé par l'un des compilateurs de bureau {{Delphi}}, l'attribut est ignoré. Avec DCC32, vous devez vous assurer que vous ajoutez le code approprié dans le destructeur d'un objet "propriétaire" pour libérer également l'objet "possédé". L'appel de <code>Free</code> est autorisé, bien que l'effet soit différent dans les compilateurs mobiles {{Delphi}}. Le comportement est correct dans la plupart des circonstances.

{{Note| Quand une instance a sa mémoire libérée, toutes les références '''[weak]''' actives sont définies sur '''nil'''. Comme une référence '''strong''' (normal), une variable '''[weak]''' peut seulement être '''nil''' ou référencer une instance valide. C'est la raison principale pour laquelle une référence '''weak''' doit être assignée à une référence '''strong''' avant d'être testée à '''nil''' et déréférencée. L'affectation à une référence strong ne permet pas la libération prématurée de l'instance.}}
<source lang="delphi">
var
O: TComponent;// a strong reference
begin
O := FOwner; // assigning a weak reference to a strong reference
if O <> nil then
O.<method>;// safe to dereference
end;
</source></blockquote>

{{Note| Vous pouvez seulement passer une variable '''[Weak]''' à un paramètre '''var''' ou '''out''' qui est également marqué comme '''[Weak]'''. Vous ne pouvez pas passer une référence '''strong''' régulière à un paramètre '''[Weak]''' '''var''' ou '''out'''. }}

==L'attribut Unsafe==

Pour définir l'attribut '''unsafe''' sur une fonction, utilisez cette syntaxe :

<source lang="delphi">
[Result: Unsafe] function ReturnUnsafe: TObject;
</source>

{{Warning| '''[Unsafe]''' peut également être appliqué aux variables (membres) et aux paramètres. Il doit être seulement utilisé en dehors de l'unité [[lib_fr:System|System]] dans de très rares situations. Il est considéré comme dangereux et son utilisation n'est pas recommandée car aucun code associé au comptage de références n'est généré.}}

{{Note| Vous pouvez seulement passer une variable '''[Unsafe]''' à un paramètre '''var''' ou '''out''' qui est également marqué en tant que '''[Unsafe]'''. Vous ne pouvez pas passer une référence '''strong''' régulière à un paramètre '''[Unsafe]''' '''var''' ou '''out'''. }}
==Surcharge des opérateurs pour les classes==

Un très intéressant effet de bord de l'utilisation du gestionnaire de mémoire ARC est que le compilateur peut gérer la durée de vie des objets temporaires renvoyés par les fonctions. Un cas spécifique est celui des objets temporaires renvoyés par les opérateurs. En fait, une nouvelle fonctionnalité du nouveau compilateur {{Delphi}} est la capacité à définir des opérateurs pour les classes, en utilisant une syntaxe et un modèle identiques à ceux ayant été disponibles pour les enregistrements depuis {{Delphi}} 2006.

{{Note| L'exemple de code suivant fonctionne avec les compilateurs mobiles {{Delphi}} (iOS), mais ne peut pas être compilé par les compilateurs de bureau {{Delphi}}. }}

En tant qu'exemple, considérez la simple classe suivante :
<source lang="delphi">
type
TNumber = class
private
FValue: Integer;
procedure SetValue(const Value: Integer);
public
property Value: Integer read FValue write SetValue;
constructor Create(Value: Integer);
function ToString: string; override;
class operator Add (a, b: TNumber): TNumber;
class operator Implicit (n: TNumber): Integer;
class operator Implicit(n: Integer): TNumber;
end;

constructor TNumber.Create(Value: Integer); begin
inherited Create;
Self.Value := Value;
end;

class operator TNumber.Add(a, b: TNumber): TNumber; begin
Result := TNumber.Create(a.Value + b.Value); end;

class operator TNumber.Implicit (n: TNumber): Integer; begin
Result := n.Value;
end;

class operator TNumber.Implicit (n: Integer): TNumber; begin
Result := TNumber.Create(n);
end;

procedure TNumber.SetValue(const Value: Integer); begin
FValue := Value;
end;

function TNumber.ToString: string;
begin
Result := IntToStr(Value);
end;

procedure Test;
var
a, b, c: TNumber;
begin
a := 10;
b := 20;
c := a + b;
Writeln(c.ToString);
end;

</source>

==Voir aussi==

* [[Comptage automatique des références dans C++|Comptage automatique des références dans C++]]
* [[Développement d'applications mobiles iOS|Développement d'applications mobiles iOS]]
* [[DCCIOS32.EXE, le compilateur Delphi pour le simulateur iOS|DCCIOS32, le compilateur Delphi pour le simulateur iOS]]
* [[DCCIOSARM.EXE, le compilateur Delphi pour le périphérique iOS 32 bits|DCCIOSARM, le compilateur Delphi pour le périphérique iOS 32 bits]]
* [[DCCIOSARM64.EXE, le compilateur Delphi pour le périphérique iOS 64 bits|DCCIOSARM64, le compilateur Delphi pour le périphérique iOS 64 bits]]
* [https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)] (EN)
* [[Utilisation du comptage de références|Utilisation du comptage de références]] (à propos des interfaces avec les compilateurs de bureau {{Delphi}})

===Exemple de code===

* [[samp_en:AutomaticReferenceCounting (Delphi)|AutomaticReferenceCounting ({{Delphi}})]]

{{DEFAULTSORT:Comptage automatique des references dans les compilateurs mobiles Delphi}}
[[Category:Delphi]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Automatic Reference Counting in Delphi Mobile Compilers]]
[[de:Automatische Referenzzählung in mobilen Delphi-Compilern]]
[[ja:Delphi モバイルコンパイラでの自動参照カウント]]

Modèle:PackageVersion

2021-01-06T16:03:25Z

Alejandra.Barrientos : RS-98408

{{ #switch: {{RadstudioVersion|{{{1|{{RadstudioVersion}}}}}}}
| {{Version|XE7}} = 210
| {{Version|XE8}} = 220
| {{Version|Seattle}} = 230
| {{Version|Berlin}} = 240
| {{Version|Godzilla}} = 250
| {{Version|Rio}} = 260
}}<noinclude>

See [[rad_fr:Versions du compilateur]].

[[Category:Modèles de données]]
[[Category:Modèles affectés par les changements de version majeure]]

Installation d'un débogueur sur une machine distante

2021-01-05T23:26:46Z

Alejandra.Barrientos : /* Fichiers du débogueur distant installés sur la machine distante */ RS-98408

{{Parent|Débogage distant - Procédures d'ancien style|Débogage distant - Procédures d'ancien style}}

<blockquote>'''Remarque :''' Cette rubrique décrit comment installer le débogueur distant d'ancien style. 
'''Remarque :''' Bien que la solution de débogage distant d'ancien style soit toujours prise en charge, nous vous recommandons d'utiliser la nouvelle [[Débogage des applications multi-périphériques|solution de débogage distant et multi-périphérique]], qui vous permet d'utiliser :
* Le débogueur intégré pour déboguer les applications distantes et multi-périphériques.
* Le [[Gestionnaire de déploiement|Gestionnaire de déploiement]] pour configurer et déployer vos applications.
</blockquote>

==Fichiers du débogueur distant installés sur la machine distante==

Sur un PC Windows, les fichiers du débogueur distant sont installés par défaut dans {{Path|{{InstallPath}}\PAServer}} quand vous [[Installation de Platform Assistant sur Windows|installez '''Platform Assistant''']], même si vous pouvez sélectionner un autre répertoire d'installation. Toutefois, si vous n'installez pas Platform Assistant, vous devez copier vous-même les fichiers suivants du débogueur distant sur la machine distante :

* {{Path|rmtdbg{{PackageVersion}}.exe}}
* {{Path|bccide.dll}}
* {{Path|bordbk{{PackageVersion}}.dll}}
* {{Path|bordbk{{PackageVersion}}N.dll}}
* {{Path|comp32x.dll}}
* {{Path|dcc32{{PackageVersion}}.dll}} pour un système Win32
* {{Path|dcc64{{PackageVersion}}.dll}} pour un système Win64
* {{Path|dccosx{{PackageVersion}}.dll}} pour un système OS X

:
::'''Remarque :''' Sur le PC de développement, les fichiers du débogueur distant sont livrés dans {{Path|{{InstallPath}}\bin}}.

==Pour recenser le débogueur distant==

Sur l'ordinateur distant, recensez {{Path|bordbk{{PackageVersion}}.dll}} et {{Path|bordbk{{PackageVersion}}.dll}} en exécutant l'utilitaire de recensement {{Path|regsvr32.exe}}. 

Par exemple, sur Windows 7, entrez {{Code|C:\Windows\System32\regsvr32.exe bordbk{{PackageVersion}}.dll}} à l'invite de commande, puis entrez :

C:\Windows\System32\regsvr32.exe bordbk{{PackageVersion}}.dll

==Voir aussi==

*[[Présentation du débogage distant|Présentation du débogage distant]]
*[[Etablissement d'une connexion pour le débogage distant|Etablissement d'une connexion pour le débogage distant]]
*[[Préparation des fichiers pour le débogage distant|Préparation des fichiers pour le débogage distant]]
* [[Débogage des applications multi-périphériques|Débogage des applications multi-périphériques (nouvelle solution de débogage distant)]]

{{DEFAULTSORT:Installation d'un debogueur sur une machine distante}}
[[Category:Utilisation de RAD Studio]]
[[Category:Delphi]]
[[Category:C++]]

[[en:Installing a Debugger on a Remote Machine]]
[[de:Debugger auf einem externen Computer installieren]]
[[ja:リモートマシンへデバッガをインストールする]]

Utilisation d'un client HTTP

2020-12-10T18:42:59Z

Alejandra.Barrientos : /* Gestion de l'authentification d'accès de base HTTP */ RS-102658

{{Parent|Utilisation de la RTL dans les applications multi-périphériques}}

La RTL fournit deux composants que vous pouvez utiliser pour envoyer des requêtes HTTP aux serveurs et gérer leurs réponses :

* [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient|TNetHTTPClient]]
* [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest|TNetHTTPRequest]]

: {{Note| Vous pouvez également utiliser une instance de [[lib_fr:System.Net.HttpClient.THTTPClient|THTTPClient]] pour gérer vos requêtes HTTP.}}

==Configuration de votre application à la conception==

===Création d'un client HTTP===

Pour créer un client HTTP permettant d'envoyer une requête HTTP, déplacez un composant [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient|TNetHTTPClient]] de la '''[[Palette d'outils|palette d'outils]]''' sur une fiche ou un module de données de votre application. Le [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient|TNetHTTPClient]] ne nécessite aucune configuration initiale.

===Création et configuration de requêtes HTTP===

Vous avez également besoin de déposer un ou plusieurs composants [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest|TNetHTTPRequest]] sur votre fiche ou module de données.

Dès que vous avez déposé votre nouveau composant requête HTTP, double-cliquez sur sa propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Client|Client]] dans '''[[Inspecteur d'objets|l'inspecteur d'objets]]''' afin que sa valeur soit le composant client HTTP que vous avez déposé auparavant.

Vous pouvez utiliser n'importe quel nombre de composants requête. Néanmoins, si vous devez envoyer plusieurs requêtes HTTP différentes, une meilleure approche consiste à utiliser un seul composant requête HTTP et à le reconfigurer à l'exécution pour envoyer chaque requête.

==Envoi d'une requête et gestion de sa réponse==

===Envoi d'une requête HTTP===

Pour envoyer une requête HTTP, vous devez spécifier au moins les éléments suivants :

* Une [[Wikipedia:Hypertext Transfer Protocol#Request methods|méthode de requête HTTP (EN)]]
* Une URL de ressource

La méthode de requête HTTP détermine l'action que le serveur doit effectuer sur la ressource située à l'URL spécifiée. Cette action peut concerner l'envoi des données de la ressource ou la mise à jour de la ressource avec les données incluses dans votre requête.

La façon dont vous envoyez une requête HTTP au moyen d'un composant [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest|TNetHTTPRequest]] dépend de la méthode de requête HTTP que vous souhaitez utiliser.

: {{Note| Les fonctions qui envoient une requête, [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Execute|Execute]] ou les fonctions spécifiques à une méthode, sont toutes bloquantes. Ainsi, ces fonctions ne se terminent pas tant qu'une réponse n'a pas été fournie par le serveur. Voir [[#Suivi de la progression du téléchargement des données de la réponse|Suivi de la progression du téléchargement des données de la réponse]] ci-dessous.}}

====Envoi d'une requête HTTP en utilisant les méthodes de requête HTTP DELETE, GET, HEAD, OPTIONS et TRACE====

Les méthodes de requête HTTP suivantes ne nécessitent pas de données en entrée autres que l'URL de la ressource cible :

* [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.7 DELETE (EN)]
* [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.3 GET (EN)]
* [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.4 HEAD (EN)]
* [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.2 OPTIONS (EN)]
* [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.8 TRACE (EN)]

Pour envoyer une requête HTTP en utilisant l'une de ces méthodes de requête HTTP, configurez d'abord votre requête à la conception :

# Configurez la propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.URL|URL]] avec l'URL de la ressource cible.
# Configurez la propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.MethodString|MethodString]] avec le nom de la méthode de requête HTTP que vous souhaitez utiliser.
#: {{Note| Les noms des méthodes de requête HTTP [http://tools.ietf.org/html/rfc7230 sont sensibles à la casse (EN)].}}

Appelez ensuite '''[[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Execute|Execute]]''' pour envoyer votre requête.

====Envoi d'une requête HTTP en utilisant les méthodes de requête HTTP MERGE, PATCH et PUT====

En plus de l'URL de la ressource cible, les méthodes de requête HTTP suivantes nécessitent des données en entrée :

* [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.6 PUT (EN)]
* [http://tools.ietf.org/html/rfc5789 PATCH (EN)]
* [http://www.odata.org/documentation/odata-version-2-0/operations/#Operations MERGE (EN)]

Pour envoyer une requête HTTP en utilisant l'une de ces méthodes de requête HTTP, appelez sa fonction correspondante (voir le tableau ci-dessous). Dans votre appel, spécifiez l'URL de la ressource cible en premier argument et une instance de [[lib_fr:System.Classes.TStream|TStream]] en second argument.

{| class="wikitable"
|-
! Méthode de requête HTTP
! Fonction TNetHTTPRequest
|-
| PUT
| [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Put|Put]]
|-
| PATCH
| [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Patch|Patch]]
|-
| MERGE
| [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Merge|Merge]]
|-
| PATCH via PUT*
| [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.PatchAlternative|PatchAlternative]]
|-
| MERGE via PUT*
| [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.MergeAlternative|MergeAlternative]]
|}

: <nowiki>*</nowiki> Certains proxies HTTP ne prennent pas en charge les dernières méthodes de requête HTTP standard (telles que PATCH) ou les méthodes de requête HTTP non standard (telles que MERGE). Dans ces cas, vous pouvez établir un proxy entre les méthodes de requête HTTP et une autre méthode de requête HTTP. Pour cela, la requête inclut des en-têtes qui spécifient la méthode de requête HTTP prévue.

====Envoi d'une requête HTTP en utilisant la méthode de requête HTTP POST====

En plus de l'URL de la ressource cible, la méthode de requête HTTP [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.5 POST (EN)] nécessite des données en entrée.

Pour envoyer une requête HTTP en utilisant la méthode de requête HTTP POST, appelez [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Post|Post]]. Dans votre appel, vous devez spécifier l'URL de la ressource cible en premier argument. Les autres arguments dépendent de la façon dont vous souhaitez fournir les données d'entrée de votre requête :

* Pour envoyer le contenu d'un fichier local, spécifiez le chemin local d'accès à ce fichier en second argument de votre appel.
* Pour envoyer le contenu d'un flux, fournissez votre instance de [[lib_fr:System.Classes.TStream|TStream]] en second argument de votre appel.
* Pour envoyer les données d'une fiche encodées en tant que [[Wikipedia:MIME#Multipart messages|message multi-partie MIME (EN)]] suivant le [http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.2 standard HTML 4 (EN)], fournissez votre instance de [[lib_fr:System.Net.Mime.TMultipartFormData|TMultipartFormData]] en second argument de votre appel.
* Pour envoyer le contenu d'une liste de chaînes, fournissez votre instance de [[lib_fr:System.Classes.TStrings|TStrings]] en second argument de votre appel, et si vos chaînes ne sont pas encodées en UTF-8, fournissez une instance de [[lib_fr:System.SysUtils.TEncoding|TEncoding]] en quatrième argument. Par exemple :

<l s="delphi" />

'''{{Delphi}} :'''
<source lang="delphi">
NetHTTPRequest1.Post('http://www.example.com/rest/items', String1, nil, TEncoding.Default);
</source><l e="delphi" /><l s="cpp" />

'''C++ :'''
<source lang="cpp">
NetHTTPRequest1->Post("http://www.example.com/rest/items", String1, NULL, TEncoding::Default);
</source><l e="cpp" />

===Gestion d'une réponse HTTP===

Lorsque le serveur cible envoie une réponse à votre requête, l'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestCompleted|OnRequestCompleted]] de votre composant requête HTTP se produit. Définissez un [[Gestionnaires d'événement|gestionnaire d'événement]] pour cet événement afin de lire les données provenant de la réponse du serveur. En cas d'erreur pendant votre requête, l'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestError|OnRequestError]] de votre composant requête HTTP se produit à la place.

Le gestionnaire d'événement de [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestCompleted|OnRequestCompleted]] reçoit deux paramètres :

* {{Arg|Sender}} est votre composant requête HTTP.
* {{Arg|AResponse}} est un objet qui implémente l'interface [[lib_fr:System.Net.HttpClient.IHTTPResponse|IHTTPResponse]].

Vous pouvez obtenir toutes les données de la réponse à partir de {{Arg|AResponse}} :

* [[lib_fr:System.Net.HttpClient.IHTTPResponse.Version|Version]] indique la version du protocole HTTP que le serveur a utilisé.
* [[lib_fr:System.Net.HttpClient.IHTTPResponse.StatusCode|StatusCode]] contient le [[Wikipedia:List of HTTP status codes|code d'état]] de la réponse, et [[lib_fr:System.Net.HttpClient.IHTTPResponse.StatusText|StatusText]] contient un texte compréhensible qui décrit l'état, comme "OK" lorsque StatusCode est égal à 200.
* [[lib_fr:System.Net.URLClient.IURLResponse.ContentAsString|ContentAsString]] contient le corps de la réponse sous la forme d'une chaîne. Vous pouvez également lire les données brutes de la réponse (y compris les en-têtes et le corps) en tant que flux de [[lib_fr:System.Net.URLClient.IURLResponse.ContentStream|ContentStream]].
* Vous pouvez lire les en-têtes de la réponse en utilisant les propriétés [[lib_fr:System.Net.URLClient.IURLResponse.Headers|Headers]], [[lib_fr:System.Net.HttpClient.IHTTPResponse.HeaderValue|HeaderValue]], [[lib_fr:System.Net.HttpClient.IHTTPResponse.ContainsHeader|ContainsHeader]], ou l'une des propriétés d'assistance suivantes qui fournissent la valeur des champs d'en-tête de réponse HTTP communs : [[lib_fr:System.Net.HttpClient.IHTTPResponse.ContentCharSet|ContentCharSet]], [[lib_fr:System.Net.HttpClient.IHTTPResponse.ContentEncoding|ContentEncoding]], [[lib_fr:System.Net.HttpClient.IHTTPResponse.ContentLanguage|ContentLanguage]], [[lib_fr:System.Net.HttpClient.IHTTPResponse.ContentLength|ContentLength]], [[lib_fr:System.Net.HttpClient.IHTTPResponse.Date|Date]], [[lib_fr:System.Net.HttpClient.IHTTPResponse.LastModified|LastModified]], [[lib_fr:System.Net.URLClient.IURLResponse.MimeType|MimeType]].
* [[lib_fr:System.Net.HttpClient.IHTTPResponse.Cookies|Cookies]] contient les [[lib_fr:System.Net.HttpClient.TCookies|cookies]] de la réponse du serveur.

==Gestion des cookies==

La propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.AllowCookies|AllowCookies]] du composant client HTTP vous permet de spécifier si vous acceptez les cookies envoyés par le serveur dans la réponse.
Si [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.AllowCookies|AllowCookies]] vaut {{True}}, le client HTTP enregistre les cookies reçus dans son [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.CookieManager|CookieManager]].

:{{Note| Le client HTTP ajoute toujours ses [[lib_fr:System.Net.HttpClient.TCookieManager.Cookies|cookies existants]] à la requête, quelle que soit la valeur de [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.AllowCookies|AllowCookies]].}}

==Gestion des redirections==

Utilisez la propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.HandleRedirects|HandleRedirects]] pour contrôler la manière dont le composant client HTTP gère les redirections. La valeur par défaut vaut {{True}}, ce qui signifie que le composant client HTTP suit automatiquement les redirections.

Utilisez la propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.MaxRedirects|MaxRedirects]] du composant client HTTP pour spécifier le nombre maximal de redirections que le composant peut suivre. Si le composant client HTTP atteint le nombre maximal de redirections spécifié, il déclenche une exception de type [[lib_fr:System.Net.HttpClient.ENetHTTPRequestException|ENetHTTPRequestException]].

==Gestion du téléchargement des données de réponse==

Au fur et à mesure que votre client HTTP télécharge la réponse à votre requête, l'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]] de votre objet requête HTTP se produit. Fournissez un gestionnaire d'événement pour [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]] afin de suivre la progression du téléchargement des données de la réponse. Votre gestionnaire d'événement reçoit les paramètres suivants :

* {{Arg|Sender}}, qui est votre objet requête HTTP.
* {{Arg|AContentLength}}, qui est la longueur attendue des données de la réponse en nombre d'octets.
* {{Arg|AReadCount}}, qui est le nombre d'octets des données de la réponse que le client HTTP a téléchargé jusqu'ici.
* {{Arg|Abort}}, qui est le paramètre booléen qui vous permet d'annuler le téléchargement.

Lorsque le téléchargement est terminé, [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]] se produit pour la dernière fois, et les valeurs de {{Arg|AContentLength}} et {{Arg|AReadCount}} sont identiques. [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestCompleted|OnRequestCompleted]] se produit peu de temps après.

===Suivi de la progression du téléchargement des données de la réponse===

Pour suivre l'évolution du téléchargement des données, utilisez les valeurs de {{Arg|AContentLength}} et {{Arg|AReadCount}} dans le gestionnaire d'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]].
Voici un exemple qui calcule le pourcentage de données téléchargées :

<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
procedure TForm1.NetHTTPRequest1ReceiveData(const Sender: TObject;
AContentLength, AReadCount: Int64; var Abort: Boolean);
var
percentageDownloaded:Double;
begin
if AContentLength > 0 then
percentageDownloaded := (AReadCount / AContentLength) * 100;
else
// the server did not provide the Content-Length header
end;
</source><l e="delphi" />

<l s="cpp" />'''C++ :'''
<source lang="cpp">
void __fastcall TForm1::NetHTTPRequest1ReceiveData(TObject * const Sender, __int64 AContentLength,
__int64 AReadCount, bool &Abort)
{
float percentageDownloaded;
if (AContentLength > 0)
{
percentageDownloaded = ((float)AReadCount / (float)AContentLength) * 100.f;
}
else
{
// the server did not provide the Content-Length header
}
}
</source><l e="cpp" />

===Annulation du téléchargement des données de réponse===

Pour annuler le téléchargement des données de réponse, changez la valeur de {{Arg|Abort}} en {{True}} dans le gestionnaire d'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]].

==Envoi d'une requête avec des en-têtes personnalisés==

Le composant client HTTP et le composant requête HTTP vous permettent tous deux de définir des en-têtes personnalisés.
Les en-têtes personnalisés que vous pouvez spécifier sont les suivants :

* Dans le composant client HTTP :
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.Accept|Accept]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.AcceptCharSet|AcceptCharSet]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.AcceptEncoding|AcceptEncoding]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.AcceptLanguage|AcceptLanguage]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.ContentType|ContentType]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.UserAgent|UserAgent]]

* Dans le composant requête HTTP :
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Accept|Accept]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.AcceptCharSet|AcceptCharSet]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.AcceptEncoding|AcceptEncoding]]
** [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.AcceptLanguage|AcceptLanguage]]

Lorsque vous [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Execute|exécutez]] une requête, la méthode [[lib_fr:System.Net.HttpClient.THTTPClient.Execute|THTTPClient.Execute]] du framework HTTP combine les en-têtes personnalisés à partir du composant client HTTP et du composant requête HTTP correspondant, puis ajoute ces en-têtes à la requête finale.

==Gestion des connexions sécurisées==

Le composant client HTTP prend en charge les connexions (HTTPS) sécurisées. Le framework HTTP gère automatiquement les demandes de certificat émises et déclenche l'événement approprié si nécessaire :

* [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnNeedClientCertificate|OnNeedClientCertificate]] lorsqu'un serveur demande un certificat au client.
* [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnValidateServerCertificate|OnValidateServerCertificate]] si le serveur fournit un certificat non valide.

Pour plus d'informations sur la gestion des certificats, voir les sections [[Utilisation d'un client HTTP#Gestion des certificats côté serveur|Gestion des certificats côté serveur]] et [[Utilisation d'un client HTTP#Gestion des certificats côté client|Gestion des certificats côté client]].

==Gestion de l'authentification et des certificats==

===Gestion de l'authentification d'accès de base HTTP===

Lorsque vous envoyez une requête HTTP à un serveur qui requiert une [[Wikipedia:Basic access authentication|authentification d'accès de base HTTP]], l'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.OnAuthEvent|OnAuthEvent]] de votre objet client HTTP se produit. Pour soumettre vos informations d'authentification d'accès, fournissez un gestionnaire pour cet événement, et si la valeur du deuxième paramètre que le gestionnaire d'événement reçoit ({{Arg|AnAuthTarget}}) est [[lib_fr:System.Net.URLClient.TAuthTargetType|TAuthTargetType.Server]], remplissez les variables {{Arg|AUserName}} et {{Arg|APassword}} avec votre nom d'utilisateur et mot de passe pour l'accès HTTP. Par exemple :
<l s="delphi" />

'''{{Delphi}} :'''
<source lang="delphi">
procedure TForm1.NetHTTPClient1AuthEvent(const Sender: TObject;
AnAuthTarget: TAuthTargetType; const ARealm, AURL: string;
var AUserName, APassword: string; var AbortAuth: Boolean;
var Persistence: TAuthPersistenceType);
begin
if AnAuthTarget = TAuthTargetType.Server then
begin
AUserName := 'MyUsername';
APassword := '1234';
end;
end;
</source><l e="delphi" /><l s="cpp" />

'''C++ :'''
<source lang="cpp">
void __fastcall TForm1::NetHTTPClient1AuthEvent(TObject * const Sender,
TAuthTargetType AnAuthTarget, const UnicodeString ARealm,
const UnicodeString AURL, UnicodeString &AUserName, UnicodeString &APassword,
bool &AbortAuth, TAuthPersistenceType &Persistence)
{
if (AnAuthTarget == TAuthTargetType::Server) {
AUserName = "MyUsername";
APassword = "1234";
}
}
</source><l e="cpp" />

Votre gestionnaire d'événement reçoit également le domaine du serveur HTTP qui requiert une authentification ({{Arg|ARealm}}) et l'URL cible de votre requête ({{Arg|AURL}}).

Pour abandonner le processus d'authentification HTTP, définissez la valeur de {{Arg|AbortAuth}} sur {{True}}.

===Envoi d'une requête derrière un proxy===

Lorsque vous êtes derrière un [[Wikipedia:Proxy server|proxy]] qui requiert une authentification, vous pouvez définir les [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.ProxySettings|paramètres proxy]] qui sont utilisés pour l'authentification.
L'exemple suivant montre comment procéder :

<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
NetHTTPClient1.ProxySettings := TProxySettings.Create('192.168.1.1', 8080, 'MyUserName', 'MyPassword');
</source><l e="delphi" />

<l s="cpp" />'''C++ :'''
<source lang="cpp">
TProxySettings MyProxySettings("192.168.1.1", 8080, "MyUserName", "MyPassword", "");
NetHTTPClient1->ProxySettings = MyProxySettings;
</source><l e="cpp" />

Pour spécifier les paramètres de proxy, vous avez aussi la possibilité de fournir une chaîne URL qui inclut les informations associées au proxy :

<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
NetHTTPClient1.ProxySettings := TProxySettings.Create('http://MyUserName:MyPassword@192.168.1.1:8080');
</source><l e="delphi" />

<l s="cpp" />'''C++ :'''
<source lang="cpp">
TProxySettings MyProxySettings("http://MyUserName:MyPassword@192.168.1.1:8080");
NetHTTPClient1->ProxySettings = MyProxySettings;
</source><l e="cpp" />

Sinon, vous pouvez spécifier les informations d'identification pour l'authentification proxy dans le gestionnaire d'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.OnAuthEvent|OnAuthEvent]]. Consultez la section [[Utilisation d'un client HTTP#Gestion de l'authentification d'accès de base HTTP|Gestion de l'authentification d'accès de base HTTP]] et vérifiez que la valeur de {{Code|AnAuthTarget}} vaut {{Const|TAuthTargetType.Proxy}} plutôt que {{Const|TAuthTargetType.Server}}.

'''Gestion des paramètres proxy avec un client HTTP'''

Le tableau suivant explique la manière dont le client HTTP gère les paramètres proxy du système sur différentes plates-formes :

{|
|-
!Plate-forme
!Comportement
|-
|
Windows
|
Le client HTTP utilise les paramètres proxy du système. Vous pouvez ignorer les paramètres proxy du système et vous pouvez également fournir d'autres paramètres proxy pour le client HTTP.

Pour ignorer les paramètres proxy du système, créez des paramètres proxy pour le client HTTP et spécifiez {{Code|<nowiki>http://direct</nowiki>}} comme URL.
|-
|
OS X
|
Le client HTTP utilise toujours les paramètres proxy du système. Même si vous fournissez d'autres paramètres proxy pour le client HTTP, celui-ci utilise les paramètres proxy du système.
|-
|
iOS
|
Le client HTTP utilise toujours les paramètres proxy du système. Même si vous fournissez d'autres paramètres proxy pour le client HTTP, celui-ci utilise les paramètres proxy du système.
|-
|
Android
|
Le client HTTP utilise les paramètres proxy du système. Vous ne pouvez pas ignorer ces paramètres, mais vous pouvez fournir d'autres paramètres proxy pour le client HTTP.
|-
|
Linux
|
Le client HTTP utilise les paramètres proxy du système. Vous ne pouvez pas ignorer ces paramètres, mais vous pouvez fournir d'autres paramètres proxy pour le client HTTP.
|}

:{{Note| Si le système ne spécifie aucun paramètre proxy (la connexion est directe), cela est également considéré comme un "réglage". Par exemple, sur un système iOS ou OS X n'ayant aucun paramètre proxy défini, vous ne pouvez pas fournir de paramètres proxy pour le client HTTP. Les paramètres que vous fournissez sont ignorés car les paramètres du système (réglage "aucun proxy") sont utilisés.}}

===Gestion du stockage des informations d'identification utilisateur===

[[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient|TNetHTTPClient]] vous permet de stocker les informations d'identification pour l'authentification HTTP ou proxy. Chaque [[lib_fr:System.Net.URLClient.TCredentialsStorage.TCredential|information d'identification]] stockée peut contenir un nom d'utilisateur, un mot de passe, un [[lib_fr:System.Net.URLClient.TAuthTargetType|type cible d'authentification]], un domaine et une URL cible.

L'exemple suivant montre comment utiliser [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.CredentialsStorage|TNetHTTPClient.CredentialsStorage]] pour enregistrer des informations d'identification, puis les utiliser pour s'authentifier lors de la connexion à un serveur HTTP nécessitant une authentification de base :

<ol><li>Créez des informations d'identification et ajoutez-les à votre stockage dédié :
<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
NetHTTPClient1.CredentialsStorage.AddCredentials(TCredentialsStorage.TCredential.Create(TAuthTargetType.Server, '', '', 'MyUserName', 'MyPassword');
</source><l e="delphi" /><l s="cpp" />'''C++ :'''
<source lang="cpp">
TCredentialsStorage::TCredential *MyCredential = new TCredentialsStorage::TCredential(TAuthTargetType::Server, "", "", "MyUserName", "MyPassword");
NetHTTPClient1->CredentialsStorage->AddCredential(*MyCredential);
</source><l e="cpp" /></li>
<li>Utilisez les informations d'identification enregistrées.

Par exemple, vous pouvez écrire un gestionnaire d'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.OnAuthEvent|OnAuthEvent]] dans lequel vous pouvez :
* Utiliser [[lib_fr:System.Net.URLClient.TCredentialsStorage.FindAccurateCredential|TCredentialsStorage.FindAccurateCredential]] pour rechercher des informations d'identification correspondant au type d'authentification nécessaire ({{Code|TAuthTargetType.Server}}).
* Utiliser le nom d'utilisateur et le mot de passe correspondant aux informations d'identification appropriées pour l'authentification.
<l s="delphi" />'''{{Delphi}} :'''
<source lang="delphi">
procedure TForm1.NetHTTPClient1AuthEvent(const Sender: TObject;
AnAuthTarget: TAuthTargetType; const ARealm, AURL: string; var AUserName,
APassword: string; var AbortAuth: Boolean;
var Persistence: TAuthPersistenceType);
var
MyCredential: TCredentialsStorage.TCredential;
begin
MyCredential := NetHTTPClient1.CredentialsStorage.FindAccurateCredential(AnAuthTarget, '');
AUserName := MyCredential.UserName;
APassword := MyCredential.Password;
end;
</source><l e="delphi" /><l s="cpp" />'''C++ :'''
<source lang="cpp">
void __fastcall TForm2::NetHTTPClient1AuthEvent(TObject * const Sender, TAuthTargetType AnAuthTarget,
const UnicodeString ARealm, const UnicodeString AURL,
UnicodeString &AUserName, UnicodeString &APassword, bool &AbortAuth,
TAuthPersistenceType &Persistence)
{
TCredentialsStorage::TCredential MyCredential;

MyCredential = NetHTTPClient1->CredentialsStorage->FindAccurateCredential(AnAuthTarget, "");
AUserName = MyCredential.UserName;
APassword = MyCredential.Password;
}
</source><l e="cpp" /></li>
</ol>

===Gestion des certificats côté serveur===

Si le serveur fournit un certificat SSL non valide, l'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnValidateServerCertificate|OnValidateServerCertificate]] se produit. Fournissez un gestionnaire d'événement pour {{Code|OnValidateServerCertificate}} afin de vérifier le certificat serveur ({{Arg|Certificate}}) et déterminer si vous acceptez ou non ce dernier. Si vous acceptez le certificat serveur, définissez la valeur du paramètre {{Arg|Accept}} sur {{True}}.

===Gestion des certificats côté client===

Si le serveur requiert un certificat client, l'événement [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.OnNeedClientCertificate|OnNeedClientCertificate]] se produit. Fournissez un gestionnaire d'événement pour {{Code|OnNeedClientCertificate}} afin de vérifier votre liste de certificats client ({{Arg|ACertificateList}}) et déterminer le certificat que vous souhaitez envoyer au serveur. Pour envoyer un certificat de la liste, définissez la valeur de {{Arg|AnIndex}} sur l'index du certificat cible dans {{Arg|ACertificateList}}.

: {{Note| Si la méthode HTTP de la première requête à un serveur qui requiert un certificat côté client n'est ni HEAD ni GET (c'est donc POST), le code d'état de la réponse du serveur est 413. Envoyez toujours une requête HEAD ou GET en premier. L'utilisation d'une requête HEAD est généralement un meilleur choix, puisque moins de données sont transférées.}}

==Rendre les requêtes asynchrones==

Les requêtes sont synchrones par défaut. Pendant une requête, l'exécution de votre application s'arrête quand vous lancez votre requête, et reprend la main seulement quand vous obtenez une réponse du serveur ou quand la requête dépasse le délai d'attente.

Si vous voulez rendre vos requêtes asynchrones, afin que les requêtes n'arrêtent pas l'exécution de votre application, vous devez activer la propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPClient.Asynchronous|Asynchronous]] du composant client ou la propriété [[lib_fr:System.Net.HttpClientComponent.TNetHTTPRequest.Asynchronous|Asynchronous]] du composant requête, selon le composant utilisé pour effectuer votre requête.

==Voir aussi==

* [[lib_fr:System.Net.URLClient|System.Net.URLClient]]
* [[lib_fr:System.Net.HttpClient|System.Net.HttpClient]]
* [[lib_fr:System.Net.HttpClientComponent|System.Net.HttpClientComponent]]

* [[Utilisation du tethering d'app|Utilisation du tethering d'app]]
* [[Utilisation du Bluetooth|Utilisation du Bluetooth]]

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

[[en:Using an HTTP Client]]
[[de:Verwenden eines HTTP-Clients]]
[[ja:HTTP クライアントの使用]]