RAD Studio - Benutzerbeiträge [de]

Programmieren von Reaktionen auf Benutzeraktionen im Quelltext-Editor (IDE-Tutorial)

2021-10-08T21:15:50Z

Alejandra.Barrientos: RS-108915 Updated Screenshots

{{Parent|Ihre erste Anwendung mit {{Variables|Product}} - Index (IDE-Tutorial)}}

Mithilfe der Anleitungen in diesem Abschnitt gestalten Sie Ihre Anwendung interaktiv und fügen die gewünschte Funktionalität hinzu. In diesem Abschnitt werden die Ereignisbehandlungsroutinen programmiert, d. h. die Reaktionen auf die Auswahl der verschiedenen Einträge im Hauptmenü und auf andere Arten von Benutzerinteraktionen.

==Beginnen der Programmierung==

Fangen Sie mit der Definition einer <code>String</code>-Variable an, die während der Ausführung der Anwendung den Namen der aktuell geöffneten Textdatei aufnimmt.
<l s="delphi" />

Wählen Sie in {{Delphi}} in der Statusleiste das Register '''Code''', um den '''[[Quelltext-Editor|Quelltext-Editor]]''' zu öffnen. Verwenden Sie den '''Quelltext-Editor''', um im Abschnitt "private" der Klasse '''TTextEditorForm''' eine <code>String</code>-Variable namens <code>CurrentFile</code> und zwar im <source lang="delphi" enclose="none">interface</source>-Teil zu definieren:

: [[Image:Code_Editor-CurrentFile_Delphi.jpg|Link=|Code Editor for Delphi]]
: ''Definieren der "private" Variable <code>CurrentFile</code> ({{Delphi}}-Ansicht)''

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

Wählen Sie in {{CBuilder}} in der Statusleiste das Register '''TextEditorUnit.h''', um die Header-Datei der Unit im '''[[Quelltext-Editor|Quelltext-Editor]]''' zu öffnen. Verwenden Sie '''Quelltext-Editor''', um eine <code>String</code>-Variable namens <code>CurrentFile</code> im <source lang="cpp" enclose="none">private</source> Abschnitt von '''TTextEditorForm''' zu deklarieren:

: [[Image:Code_Editor-CurrentFile_C++.jpg|Link=|Code Editor for C++]]
: ''Definieren der "private" Variable CurrentFile ({{CBuilder}}-Ansicht)''

<l e="cpp" />

Um zwischen dem '''[[Formular-Designer|Formular-Designer]]''' und dem '''[[Quelltext-Editor|Quelltext-Editor]]''' zu wechseln, drücken Sie die Taste <code>F12</code>.

==Aktualisieren der Statusleiste als Reaktion auf Aktionen im Texteditor==

Wenn der Benutzer den ''Textcursor'' bewegt oder den Inhalt der '''[[lib_de:FMX.Memo.TMemo|TMemo]]'''-Komponente ändert, müssen Sie die Statusleiste aktualisieren. Da die Statusleiste als Reaktion auf viele verschiedene Ereignisse aktualisiert werden muss, können Sie eine einzige Prozedur im Code definieren und diese Prozedur dann später von jeder Ereignisbehandlungsroutine aus aufrufen, die die Statusleiste aktualisieren muss.
<l s="delphi" />

Fügen Sie in {{Delphi}} zum Definieren dieser neuen Prozedur in Ihrer Anwendung die folgende Prozedursignatur dem "private" Abschnitt der Klasse '''TTextEditorForm''' hinzu und zwar im <source lang="delphi" enclose="none">interface</source>-Teil direkt unterhalb der Variable <code>CurrentFile</code>, die Sie zuvor definiert haben:

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

Klicken Sie in Ihrem Code mit der rechten Maustaste auf <code>UpdateStatusBar</code>, und wählen Sie '''Klasse beim Cursor vervollständigen''', damit {{Product}} ein Grundgerüst für die Definition der Prozedur hinzufügt und zwar im <source lang="delphi" enclose="none">implementation</source>-Teil des Codes:

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

end;
</source>

Definieren Sie die Logik der Prozedur <code>UpdateStatusBar</code> zwischen den Schlüsselwörtern <source lang="delphi" enclose="none">begin</source> und <source lang="delphi" enclose="none">end</source> wie folgt:

<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" />

Fügen Sie in C++ zum Definieren dieser neuen Funktion in Ihrer Anwendung die folgende Funktionssignatur dem <source lang="cpp" enclose="none">private</source> Abschnitt der Klasse '''TTextEditorForm''' in der Datei ''TextEditorUnit.h'' direkt unterhalb der Variable <code>CurrentFile</code> hinzu, die Sie zuvor definiert haben:

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

Wählen Sie die Implementierungsdatei ''TextEditorUnit.cpp'' aus, und implementieren Sie diese Funktion wie folgt:

<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" />

Sie können jetzt <code>UpdateStatusBar</code> aus allen Ereignisbehandlungsroutinen aufrufen, um die Statusleiste zu aktualisieren.

Das erste Mal sollten Sie die in der Statusleiste angezeigten Informationen beim Start Ihrer Anwendung aktualisieren. Dafür können Sie das Ereignis '''OnCreate''' des Formulars verwenden:

# Klicken Sie auf die Registerkarte '''Design''', um zurück zum [[Formular-Designer|Formular-Designer]] zu wechseln.
# Wählen Sie in der [[Strukturansicht|Strukturansicht]] die Formular-Komponente mit dem Namen <code>TextEditorForm</code> aus.
# Klicken Sie im [[Objektinspektor|Objektinspektor]] auf die Registerkarte '''Ereignisse'''.
# Doppelklicken Sie auf der Registerkarte '''Ereignisse''' auf das Wertefeld des '''OnCreate'''-Ereignisses. {{Product}} wechselt zum [[Quelltext-Editor|Quelltext-Editor]] und fügt ein Grundgerüst für die Definition der neuen Ereignisbehandlungsroutine hinzu. Rufen Sie mit dieser Ereignisbehandlungsroutine Ihre <code>UpdateStatusBar</code>-Prozedur auf:

<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" />

Beachten Sie, dass vor dem Aufruf von <code>UpdateStatusBar</code> eine leere Zeile in der TMemo-Komponente eingefügt wird. Dadurch wird der Zeilenzähler des Memofeldes initialisiert, damit der Zeilenzähler in der Statusleiste am Anfang "1" Zeile anstatt "0" Zeilen anzeigt.

Wiederholen Sie die obigen Schritte für die Ereignisse '''OnKeyUp''' und '''OnMouseUp''' der TMemo-Komponente <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" />

==Erstellen von Ereignisbehandlungsroutinen für die Einträge im Menü "File"==

Wiederholen Sie die obigen Schritte für die Ereignisse '''OnKeyUp''' und '''OnMouseUp''' der TMemo-Komponente (<code>Editor</code>):
<l s="delphi" />

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

Wählen Sie dann im '''Objektinspektor''' die Registerkarte '''Ereignisse''' aus, und doppelklicken Sie auf das Eingabefeld neben dem Ereignis <code>OnExecute</code>. Der '''Quelltext-Editor''' wird geöffnet, und ein Grundgerüst für die neue Ereignisbehandlungsroutine wird angezeigt. Schreiben Sie in diese Ereignisbehandlungsroutine den Code, der ausgeführt werden soll, wenn der Benutzer {{Menu|Datei > Neu}}.
<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" />

'''C++:'''
<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" />

==Erstellen von Ereignisbehandlungsroutinen für die Einträge im Menü "Edit" und "Format"==

Gehen Sie für die Implementierung der Aktionen für die Einträge in den Menüs "Edit" und "Format" genauso vor wie bei den Aktionen für das Menü "File" vor. Diese Ereignisbehandlungsroutinen sind ziemlich einfach: sie leiten die Aktion nur an das Memofeld weiter, weil die gesamte benötigte Funktionalität bereits in der Klasse [[lib_de:FMX.Memo.TMemo|TMemo]] implementiert ist, und sie rufen <code>UpdateStatusBar</code> auf, falls die Aktion Auswirkungen auf die Position des Textcursors oder den Zeilenzähler hat.
<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" />

==Weiter==

[[Compilieren und Ausführen der Anwendung (IDE-Tutorial)|Compilieren und Ausführen der Anwendung]]

[[Category:Delphi]]
[[Category:C++]]
[[Category:XE6]]
[[Category:AMMigrate]]

[[en:Coding responses to user actions in the Code Editor (IDE Tutorial)]]
[[fr:Codage des réponses aux actions des utilisateurs dans l'éditeur de code (tutoriel de l'EDI)]]
[[ja:ユーザーアクションに対する応答をコードエディタでコーディングする（IDE チュートリアル）]]

Datei:Code Editor-IDETutorialSelectingNewAction.jpg

2021-10-08T21:15:15Z

Alejandra.Barrientos: Datei hochgeladen mit MsUpload

Datei hochgeladen mit MsUpload

Datei:Code Editor-CurrentFile Delphi.jpg

2021-10-08T21:15:02Z

Alejandra.Barrientos: Datei hochgeladen mit MsUpload

Datei hochgeladen mit MsUpload

Datei:Code Editor-CurrentFile C++.jpg

2021-10-08T21:14:50Z

Alejandra.Barrientos: Datei hochgeladen mit MsUpload

Datei hochgeladen mit MsUpload

Deklaration von Generics

2021-07-30T16:42:51Z

Alejandra.Barrientos: RS-107222

{{Parent|Generics - Index}}
Die Deklaration von Generics ist vergleichbar mit der Deklaration von regulären Klassen-, Record- oder Interface-Typen. Der Unterschied besteht darin, dass die Deklaration von Generics eine Liste mit einem oder mehreren Typparametern in spitzen Klammern (< und >) nach dem Typbezeichner enthält.

Ein Typparameter kann als typischer Typbezeichner innerhalb der Container-Typdeklaration und im Methodenrumpf verwendet werden.

Zum Beispiel:
<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| Vor dem Aufruf der Methode '''GetValue''' müssen Sie den Standardkonstruktor aufrufen und die Klassenfelder initialisieren.}}

==Typargument==

Generische Typen werden durch das Bereitstellen von Typargumenten instantiiert. In {{Delphi}} können Sie jeden beliebigen Typ außer den folgenden als Typargument verwenden: ein statisches Array, ein Short String oder ein Record-Typ, der ein Feld mit einem oder mehreren dieser beiden Typen (rekursiv) enthält.
<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>

==Verschachtelte Typen==

Ein in einem generischen Typ verschachtelter Typ ist selbst ein generischer Typ.
<source lang="delphi">
type
TFoo<T> = class // A generic class
type
TBar = class
X: Integer;
end;
end;
</source>

Um auf den verschachtelten Typ TBar zuzugreifen, müssen Sie zuerst eine Konstruktion des Typs TFoo angeben:

<source lang="delphi">
var
N: TFoo<Double>.TBar;
</source>
Ein generischer Typ kann auch in einer regulären Klasse als verschachtelter Typ deklariert werden:
<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>

==Basistypen==

Der Basistyp eines parametrisierten Klassen- oder Interface-Typs kann ein tatsächlicher Typ oder ein konstruierter Typ sein. Der Basistyp darf kein Typparameter sein.

<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>
Wenn TFoo2<String> instantiiert ist, wird eine Vorfahrklasse zu TBar2<String>, und TBar2<String> wird automatisch instantiiert.

==Klassen-, Interface- und Record-Typen==

Klassen-, Interface-, Record- und Array-Typen können mit Typparametern deklariert werden.

Zum Beispiel:
<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>

==Prozedurale Typen==

Prozedurale Typen und Methodenzeiger können mit Typparametern deklariert werden. Parametertypen und Ergebnistypen können auch Typparameter verwenden.

Zum Beispiel:
<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>

==Parametrisierte Methoden==

Methoden können mit Typparametern deklariert werden. Parametertypen und Ergebnistypen können Typparameter verwenden. Konstruktoren und Destruktoren sowie virtuelle, dynamische oder Botschaftsmethoden dürfen allerdings keine Typparameter haben. Parametrisierte Methoden sind mit überladenen Methoden vergleichbar.

Es gibt zwei Möglichkeiten, eine Methode zu instantiieren:

* Durch die explizite Angabe eines Typarguments
* Durch automatische Ableitung vom Typargument

Zum Beispiel:
<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>

==Gültigkeitsbereich von Typparametern==

Der Gültigkeitsbereich eines Typparameters umfasst die Typdeklaration und den Rumpf aller Member, aber keine abgeleiteten Typen.

Zum Beispiel:
<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>

==Siehe auch==

*[[Übersicht über Generics|Übersicht über Generics]]
*[[Terminologie für Generics|Terminologie für Generics]]
*[[Einschränkungen bei Generics (Parametrisierte Typen)|Einschränkungen bei Generics]]
*[[Overloads und Typkompatibilität in Generics|Overloads und Typkompatibilität in Generics]]
*[[Klassenvariablen in Generics|Klassenvariablen in Generics]]

[[Category:Delphi]]
[[Category:Delphi-Sprachreferenz]]
[[Category:AMMigrate]]

[[en:Declaring Generics]]
[[fr:Déclaration des génériques]]
[[ja:ジェネリックスの宣言]]

Eigenschaften (Delphi)

2021-06-29T20:05:19Z

Alejandra.Barrientos: /* Speicherbezeichner */ RS-107569

{{Parent|Klassen und Objekte - Index}}
{{DISPLAYTITLE:Eigenschaften ({{Delphi}})}}
<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>
Dieses Thema enthält Informationen zu folgenden Bereichen:

* Auf Eigenschaften zugreifen
* Array-Eigenschaften
* Indexbezeichner
* Speicherbezeichner
* Eigenschaften überschreiben und neu deklarieren
* Klasseneigenschaften

==Allgemeines zu Eigenschaften==

Eine Eigenschaft definiert wie ein Feld ein Objektattribut. Felder sind jedoch nur Speicherbereiche, die überprüft und geändert werden können, während Eigenschaften mithilfe bestimmter Aktionen gelesen und geschrieben werden können. Sie erlauben eine größere Kontrolle über den Zugriff auf die Attribute eines Objekts und ermöglichen das Berechnen von Attributen.

Die Deklaration einer Eigenschaft muss einen Namen, einen Typ und mindestens eine Zugriffsangabe enthalten. Die Syntax lautet folgendermaßen:

'''property '''''Eigenschaftsname[Indizes]: Typ ''index'' Integer-Konstante Bezeichner;''

wobei

* ''Eigenschaftsname'' ein beliebiger gültiger Bezeichner ist.
* ''[Indizes]'' ist optional und besteht aus einer Folge von durch Strichpunkte getrennten Parameterdeklarationen. Jede Deklaration hat die Form ''Bezeichner1'', ..., ''Bezeichnern'': Typ. Weitere Informationen finden Sie im Abschnitt "Array-Eigenschaften" weiter unten.
* ''Typ'' muss ein vordefinierter oder vorher deklarierter Typbezeichner sein. Eigenschaftsdeklarationen der Form property Num: 0..9 sind somit unzulässig.
* Die Indexklausel ''Integer-Konstante'' ist optional. Weitere Informationen hierzu finden Sie im Abschnitt "Indexbezeichner" weiter unten.
* ''Bezeichner'' besteht aus den Bezeichnern '''read''', '''write''', '''stored''', '''default''' (oder '''nodefault''') und '''implements'''. Jede Eigenschaftsdeklaration muss zumindest einen '''read'''- oder '''write'''-Bezeichner enthalten.

Eigenschaften werden durch ihre Zugriffsbezeichner definiert. Sie können im Gegensatz zu Feldern nicht als '''var'''-Parameter übergeben oder mit dem Adressoperator '''@''' versehen werden. Der Grund dafür liegt darin, dass eine Eigenschaft nicht notwendigerweise im Speicher vorhanden sein muss. Sie kann beispielsweise eine '''read'''-Methode haben, die einen Wert aus einer Datenbank abruft oder einen Zufallswert generiert.

==Auf Eigenschaften zugreifen==

Jede Eigenschaft verfügt über eine '''read'''- oder eine '''write'''-Angabe (oder über beide). Diese Zugriffsbezeichner werden in folgender Form angegeben:

'''read '''''FeldOderMethode''

'''write '''''FeldOderMethode''

''FeldOderMethode'' ist der Name eines Feldes oder einer Methode, das bzw. die in derselben Klasse oder in einer Vorfahrklasse der Eigenschaft deklariert ist.

* Wenn ''FeldOderMethode'' in derselben Klasse deklariert wird, muss dies vor der Eigenschaft geschehen. Ist das Element in einer Vorfahrklasse deklariert, muss es in der abgeleiteten Klasse sichtbar sein. Es kann also kein Element einer abgeleiteten Klasse angegeben werden, das in einer anderen Unit als '''private''' deklariert ist.
* Handelt es sich bei ''FeldOderMethode'' um ein Feld, muss dieses Feld denselben Typ wie die Eigenschaft haben.
* Wenn ''FeldOderMethode'' eine Methode ist, kann diese nicht '''dynamic''' sein. Falls es sich um eine '''virtual''' Methode handelt, kann diese nicht überladen werden. Zugriffsmethoden für eine als '''published''' deklarierte Eigenschaft müssen die Standard-Aufrufkonvention '''register''' verwenden.
* Wird in einem '''read'''-Bezeichner für ''FeldOderMethode'' eine Methode angegeben, muss eine Funktion ohne Parameter verwendet werden, die einen Wert mit dem Typ der Eigenschaft zurückgibt. Eine Ausnahme bildet die Zugriffsmethode für eine indizierte Eigenschaft oder eine Array-Eigenschaft.
* Wird in einem '''write'''-Bezeichner für ''FeldOderMethode'' eine Methode angegeben, muss eine Prozedur verwendet werden, die einen Wert- oder '''const'''-Parameter mit dem Datentyp der Eigenschaft entgegennimmt (oder wenn es sich um eine Array-Eigenschaft oder indizierte Eigenschaft handelt).

Betrachten Sie beispielsweise die folgende Deklaration:

property Color: TColor read GetColor write SetColor;

Die Methode GetColor muss hier folgendermaßen deklariert werden:

function GetColor: TColor;

Die Deklaration der Methode SetColor muss eine der folgenden Formen haben:

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

(Der Parameter von SetColor muss natürlich nicht unbedingt Value heißen.)

Wenn eine Eigenschaft in einem Ausdruck verwendet wird, erfolgt der Zugriff auf ihren Wert mithilfe des mit '''read''' angegebenen Elements (Feld oder Methode). Bei Zuweisungen wird das mit '''write''' angegebene Element für das Schreiben der Eigenschaft verwendet.

Im folgenden Beispiel wird die Klasse TCompass mit der '''published'''-Eigenschaft Heading deklariert. Zum Lesen der Eigenschaft wird das Feld FHeading, zum Schreiben die Prozedur SetHeading verwendet.

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

Ausgehend von dieser Deklaration ist die Anweisung

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

mit den folgenden Anweisungen identisch:

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

In der Klasse TCompass wird zum Lesen der Eigenschaft Heading keine bestimmte Aktion verwendet. Die '''read'''-Operation besteht lediglich aus dem Abrufen des im Feld FHeading gespeicherten Wertes. Wertzuweisungen an die Eigenschaft werden in Aufrufe der Methode SetHeading umgesetzt. Diese Methode speichert den neuen Wert im Feld FHeading und führt optional weitere Operationen durch. SetHeading könnte beispielsweise folgendermaßen implementiert werden:

procedure TCompass.SetHeading(Value: THeading);
begin
if FHeading <> Value then
begin
FHeading := Value;
Repaint; // Aktualisieren der Benutzeroberfläche, um den neuen Wert anzuzeigen
end;
end;

Eine Eigenschaft, die nur mit einer '''read'''-Angabe deklariert ist, nennt man Nur-Lesen-Eigenschaft (schreibgeschützt). Ist nur ein '''write'''-Bezeichner vorhanden, handelt es sich um eine Nur-Schreiben-Eigenschaft (lesegeschützt). Wenn Sie einer Nur-Lesen-Eigenschaft einen Wert zuweisen oder eine Nur-Schreiben-Eigenschaft in einem Ausdruck verwenden, tritt ein Fehler auf.

==Array-Eigenschaften==

Array-Eigenschaften sind indizierte Eigenschaften. Sie werden beispielsweise für die Einträge eines Listenfeldes, die untergeordneten Objekte eines Steuerelements oder die Pixel einer Bitmap-Grafik verwendet.

Die Deklaration einer Array-Eigenschaft enthält eine Parameterliste mit den Namen und Typen der Indizes. Beispiel:

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;

Das Format der Liste ist mit dem Format der Parameterliste einer Prozedur oder Funktion identisch. Der einzige Unterschied besteht darin, dass die Parameterdeklarationen nicht in runden, sondern in eckigen Klammern angegeben werden. Im Gegensatz zu Arrays, bei denen nur ordinale Indizes erlaubt sind, können die Indizes von Array-Eigenschaften einen beliebigen Typ haben.

Bei Array-Eigenschaften müssen die Zugriffsbezeichner keine Felder, sondern Methoden angeben. Die Methode in einem '''read'''-Bezeichner muss eine Funktion sein, bei der Anzahl, Reihenfolge und Typ der Parameter mit der Indexparameterliste der Eigenschaft identisch sind, und der Ergebnistyp mit dem Typ der Eigenschaft übereinstimmt. Die Methode in einem '''write'''-Bezeichner muss eine Prozedur sein, bei der Anzahl, Reihenfolge und Typ der Parameter mit der Indexparameterliste der Eigenschaft identisch sind. Außerdem muss ein zusätzlicher Wert- oder '''const'''-Parameter mit dem Typ der Eigenschaft vorhanden sein.

Die Zugriffsmethoden für die obigen Array-Eigenschaften können beispielsweise folgendermaßen deklariert werden:

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);

Auf eine Array-Eigenschaft kann durch Indizieren ihres Bezeichners zugegriffen werden. So sind beispielsweise die Anweisungen

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

mit den folgenden Anweisungen identisch:

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

Wenn Sie die Direktive '''default''' nach der Definition einer Array-Eigenschaft angeben, wird diese als Standardeigenschaft der betreffenden Klasse verwendet. Beispiel:

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

Auf die Array-Standardeigenschaft einer Klasse kann mit der Kurzform Objekt[Index] zugegriffen werden. Diese Anweisung ist mit Objekt.Eigenschaft[Index] identisch. Ausgehend von der vorhergehenden Deklaration kann z.B. StringArray.Strings[7] zu StringArray[7] verkürzt werden. Eine Klasse kann nur eine Standardeigenschaft mit der gegebenen Signatur (Array-Parameterliste) haben, aber es ist möglich, die Standardeigenschaft zu überladen. Das Ändern oder Verbergen der Standardeigenschaft in abgeleiteten Klassen kann zu unerwünschten Ergebnissen führen, da der Compiler Bindungen an Eigenschaften immer statisch vornimmt.

==Indexbezeichner==

Mithilfe von Indexbezeichnern können mehrere Eigenschaften dieselbe Zugriffsmethode verwenden, auch wenn sie unterschiedliche Werte repräsentieren. Indexbezeichner bestehen aus der Direktive '''index''' und einem Integer-Wert zwischen -2.147.483.647 und 2.147.483.647. Bei Eigenschaften mit Indexbezeichnern muss auf die Direktiven '''read''' und '''write''' eine Methode (kein Feld) folgen. Beispiel:

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;

Eine Zugriffsmethode für eine Eigenschaft mit einem Indexbezeichner benötigt einen zusätzlichen Wert-Parameter vom Typ Integer. Bei einer '''read'''-Funktion muss dies der letzte, bei einer '''write'''-Prozedur der vorletzte Parameter sein. Diese Konstante (der Index) wird beim Zugriff auf die Eigenschaft automatisch an die Zugriffsmethode übergeben.

Wenn Rectangle ein Objekt der zuvor deklarierten Klasse TRectangle ist, dann ist die Anweisung

Rectangle.Right := Rectangle.Left + 100;

mit der folgenden Anweisung identisch:

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

==Speicherbezeichner==

Die optionalen Direktiven '''stored''', '''default''' und '''nodefault''' sind Speicherbezeichner. Sie haben keinerlei Auswirkungen auf die Funktionsweise des Programms, sondern bestimmen, ob die Werte der '''published'''-Eigenschaften in Formulardateien gespeichert werden.

Nach der Angabe '''stored''' muss der Wert '''True''' oder '''False''', der Name eines booleschen Feldes oder der Name einer parameterlosen Methode folgen, die einen booleschen Wert zurückgibt. Beispiel:

property Name : TComponentName read FName write SetName stored False;

Wird eine Eigenschaft ohne die Angabe von '''stored''' deklariert, entspricht dies der Definition '''stored''' '''True'''.

Nach '''default''' muss eine Konstante angegeben werden, die denselben Datentyp wie die Eigenschaft hat. Beispiel:

property Tag: Longint read FTag write FTag default 0;

Mithilfe des Bezeichners '''nodefault''' kann ein geerbter '''default'''-Wert ohne Angabe eines neues Wertes außer Kraft gesetzt werden. Die Direktiven '''default''' und '''nodefault''' werden nur für Ordinal- und Mengentypen unterstützt, bei denen die Ober- und Untergrenze des Basistyps einen Ordinalwert zwischen 0 und 31 hat. Enthält eine Eigenschaftsdeklaration weder '''default''' noch '''nodefault''', gilt sie als mit '''nodefault''' definiert. Für Real-, Zeiger- und String-Typen gilt der implizite '''default'''-Wert 0 bzw. '''nil''' und <nowiki>''</nowiki> (leerer String).

{{Note| Sie können den ordinalen Wert -2147483648 nicht als Standardwert verwenden. Dieser Wert wird intern für die Darstellung von '''nodefault''' verwendet.}}

Beim Speichern einer Komponente werden die Speicherbezeichner ihrer '''published'''-Eigenschaften überprüft. Wenn sich der aktuelle Wert einer Eigenschaft von ihrem '''default'''-Wert unterscheidet (oder kein '''default'''-Wert vorhanden ist) und '''stored''' '''True''' ist, wird der Wert gespeichert. Treffen diese Bedingungen nicht zu, wird der Wert nicht gespeichert.

{{Note| Eigenschaftswerte werden nicht automatisch auf den Standardwert initialisiert, d.h. die Standarddirektive steuert nur das Speichern von Eigenschaftswerten in der Formulardatei und nicht das Speichern des ersten Werts der Eigenschaft in einer neu erstellten Instanz.}}

Bei Array-Eigenschaften werden Speicherbezeichner nicht unterstützt. Bei diesem Eigenschaftstyp hat '''default''' eine andere Bedeutung (siehe "Array-Eigenschaften" weiter oben).

==Eigenschaften überschreiben und neu deklarieren==

Das Deklarieren einer Eigenschaft ohne Angabe eines Typs nennt man Überschreiben. Diese Vorgehensweise ermöglicht das Ändern der geerbten Sichtbarkeit bzw. des geerbten Bezeichners einer Eigenschaft. In der einfachsten Form braucht nur das reservierte Wort '''property''' zusammen mit einem geerbten Eigenschaftsbezeichner angegeben zu werden. Auf diese Weise kann die Sichtbarkeit der betreffenden Eigenschaft geändert werden. So kann beispielsweise eine in einer Vorfahrklasse als '''protected''' deklarierte Eigenschaft im '''public'''- oder '''published'''-Abschnitt einer abgeleiteten Klasse neu deklariert werden. Eigenschaftsüberschreibungen können die Angaben '''read''', '''write''','''stored''', '''default''' und '''nodefault''' enthalten, durch die die entsprechende geerbte Direktive außer Kraft gesetzt wird. Mithilfe einer Überschreibung können Sie geerbte Zugriffsangaben ersetzen, fehlende Angaben hinzufügen oder den Gültigkeitsbereich einer Eigenschaft erweitern, jedoch keine Zugriffsbezeichner entfernen oder die Sichtbarkeit verringern. Optional kann auch mit der Direktive '''implements''' die Liste der implementierten Interfaces ergänzt werden, ohne die geerbten Interfaces zu entfernen.

Die folgenden Deklarationen zeigen, wie Eigenschaften überschrieben werden können:

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;

Beim Überschreiben von Size wird die Angabe '''write''' hinzugefügt, damit der Wert der Eigenschaft geändert werden kann. Die Sichtbarkeit der Eigenschaften Text und Color wird von '''protected''' in '''published''' geändert. Für die Eigenschaft Color wird außerdem festgelegt, dass sie in der Formulardatei gespeichert wird, wenn sie einen anderen Wert als clBlue hat.

Wenn Sie beim Redeklarieren einer Eigenschaft einen Typbezeichner angeben, wird die geerbte Eigenschaft nicht überschrieben, sondern lediglich verdeckt. Dadurch wird eine neue Eigenschaft mit demselben Namen wie die geerbte erstellt. Diese Art der Deklaration muss immer vollständig vorgenommen werden. Stets muss zumindest eine Zugriffsangabe vorhanden sein.

Unabhängig davon, ob eine Eigenschaft in einer abgeleiteten Klasse verdeckt oder überschrieben wird, erfolgt die Suche nach der Eigenschaft immer statisch. Der deklarierte (also zur Compilierzeit bekannte) Typ der Variable bestimmt die Interpretation des Eigenschaftsbezeichners. Aus diesem Grund wird nach dem Ausführen des folgenden Codes durch das Lesen oder Schreiben von MyObject.Value die Methode Method1 bzw. Method2 aufgerufen, obwohl MyObject eine Instanz von TDescendant enthält. Sie können aber durch eine Typumwandlung in TDescendant auf die Eigenschaften und Zugriffsangaben der abgeleiteten Klasse zugreifen.

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;

==Klasseneigenschaften==

Auf Klasseneigenschaften kann ohne Objektreferenz zugegriffen werden. Methoden für den Zugriff auf Klasseneigenschaften müssen als klassenstatisch bzw. als Klassenfelder deklariert sein. Eine Klasseneigenschaft wird mit dem Schlüsselwörtern '''class property''' deklariert. Klasseneigenschaften können nicht als '''published''' deklariert werden und keine '''stored'''- oder '''default'''-Wertdefinitionen haben.

Mithilfe einer '''class var'''-Deklaration können Sie einen Block von statischen Klassenfeldern innerhalb einer Klassendeklaration erzeugen. Alle nach '''class var''' deklarierten Felder haben statische Speicherattribute. Ein '''class var'''-Block wird durch Folgendes abgeschlossen:

# Eine weitere '''class var'''-Deklaration
# Eine [[Methoden (Delphi)|Prozedur- oder Funktionsdeklaration (Methodendeklaration)]] (einschließlich Klassenprozeduren und Klassenfunktionen)
# Eine Eigenschaftsdeklaration (einschließlich Klasseneigenschaften)
# Eine [[Methoden (Delphi)|Konstruktor- oder Destruktor-Deklaration]]
# Ein [[Klassen und Objekte (Delphi)|Sichtbarkeitsattribut]] ('''public''', '''private''', '''protected''', '''published''', '''strict private''' und '''strict protected''')

Beispiel:

type
TMyClass = class
strict private
class var // Felder müssen als Klassenfelder deklariert werden
FRed: Integer;
FGreen: Integer;
FBlue: Integer;
public // Ende des class var-Blocks
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;

Auf die obigen Klasseneigenschaften kann folgendermaßen zugegriffen werden:

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

==Siehe auch==

* [[Klassen und Objekte (Delphi)]]
* [[Felder (Delphi)]]
* [[Methoden (Delphi)]]
* [[Ereignisse (Delphi)]]
* [[Verschachtelte Typdeklarationen]]
* [[Klassenreferenzen]]
* [[Exceptions (Delphi)]]
* [[Überladene Operatoren (Delphi)]]
* [[Unterstützende Klassen und Records (Delphi)]]

[[Category:{{Delphi}}]]
[[Category:{{Delphi}}-Sprachreferenz]]
[[Category:AMMigrate]]

[[en:Properties (Delphi)]]
[[fr:Propriétés (Delphi)]]
[[ja:プロパティ]]

Automatische Referenzzählung in mobilen Delphi-Compilern

2021-03-04T14:06:41Z

Alejandra.Barrientos: /* Operatorüberladung für Klassen */ Added templates

{{Parent|Gesichtspunkte für geräteübergreifende Delphi-Anwendungen}}

{{Delphi}}-Benutzer sind seit langem mit dem Begriff der automatischen Referenzzählung (ARC, Automatic Reference Counting) vertraut. In der Vergangenheit haben die {{Delphi}}-Desktop-Compiler (DCC32, DCC64, DCCOSX) ARC für Interfaces (in '''{{Delphi}} 3''' eingeführt), dynamische Arrays und Strings ('''AnsiString''' wurde in '''{{Delphi}} 2''' eingeführt) unterstützt. Jetzt wurde für die mobilen {{Delphi}}-Compiler die automatische Referenzzählung auch für Klassen eingeführt. In diesem Zusammenhang wurde auch der Begriff der '''schwachen Referenz''' eingeführt, um "Zyklen" gemeinsam mit einem anderen Feature zu verwalten: '''Operatorüberladung für Klassen'''.

Eine detaillierte Beschreibung der automatischen Referenzzählung finden Sie unter '''[https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]'''

==Automatische Referenzzählung==

Die '''Automatische Referenzzählung''' ist eine Möglichkeit zur Verwaltung der Objektlebensdauer ohne Freigabe des Objekts, wenn es nicht mehr benötigt wird. Ein gutes Beispiel dafür ist eine lokale Variable, die ein Objekt referenziert, das den Gültigkeitsbereich verlässt. Daran anschließend wird das Objekt automatisch freigegeben. Wie oben erwähnt, hat {{Delphi}} immer schon die Referenzzählung für Strings und durch Variablen vom Typ Interface referenzierte Objekte unterstützt. ARC bietet aber in den mobilen {{Delphi}} -Compilern eine gewisse Flexibilität, um Probleme, wie zirkuläre Referenzen, zu beheben, die mit Variablen vom Typ Interface schwer zu handhaben sind.

Ein weiterer in den neuen mobilen {{Delphi}}-Compilern eingeführter Begriff ist '''schwache Referenz'''. Damit werden auch einige Probleme mit zirkulären Referenzen behoben.

Das Speicherverwaltungsschema ist dasselbe für Apps, die für iOS-Geräte oder den iOS-Simulator compiliert werden:

* DCCIOSARM (der {{Delphi}}-Compiler für das 32-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOSARM64 (der {{Delphi}}-Compiler für das 64-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOS32 (der {{Delphi}}-Compiler für den iOS-Simulator) aktiviert ARC auch, obwohl DCCIOS32 auf der herkömmlichen Compiler-Architektur basiert.

{{Note| Diese neuen Features erscheinen im Quellcode von {{Variables|Product}} ausschließlich in den konditionalen <code>{$AUTOREFCOUNT}</code>-Blöcken in der RTL (z. B. in ''System.pas''). }}

==Änderungen des Programmierstils==

Da die neuen mobilen Compiler die automatische Referenzzählung unterstützen, kann beim Verweisen auf temporäre Objekte in einer Methode der Code deutlich vereinfacht werden. Die Speicherverwaltung wird vollständig ignoriert:

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

Im obigen Beispiel wird der Destruktor für das Objekt aufgerufen, wenn das Programm die '''end'''-Anweisung erreicht, das heißt, wenn die Variable <code>MyObj</code> den Gültigkeitsbereich verlässt.

Die Verwendung des Objekts kann auch vor dem Ende der Methode beendet werden. Dies kann durch Setzen der Variable auf '''nil''' erreicht werden:

<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>

In diesem Fall wird das Objekt vor dem Ende der Methode freigegeben und zwar genau dann, wenn die Variable auf '''nil''' gesetzt wird. Falls die <code>DoSomething</code>-Prozedur eine Exception auslöst, wird die '''nil'''-Zuweisungsanweisung übersprungen. Wird die Methode schließlich beendet, wird auch das Objekt freigegeben.

Da sich die Lebensdauer des Objekts nach dem Programmfluss richtet, können Sie den Referenzzähler eines Objekts (nur auf Plattformen mit Referenzzählung) mit der neuen Eigenschaft RefCount abfragen:
<source lang="delphi">
public
property RefCount: Integer read FRefCount;
</source>

{{Note| Das Abfragen des Referenzzählers eines Objekts wird nicht empfohlen und sollte im Allgemeinen nicht verwendet werden. }}

===Geschwindigkeit von ineinandergreifenden Vorgängen===

Das Inkrementieren und Dekrementieren des Referenzzählers eines Objekts wird unter Verwendung von Thread-sicher Operationen durchgeführt, damit der Member der Referenzzählerinstanz Thread-sicher ist. Das bedeutet, dass die Referenzzähler-Instanzvariable korrekt durch '''Speicherbarrieren''' abgeschirmt ist, damit die Änderung von allen Threads sofort beachtet wird und sie keinen '''alten''' Wert ändern können.

{{Note| Der ARC-Mechanismus schützt nicht vor Racebedingungen und Deadlocks. }}

===ARC und die Direktive {$AUTOREFCOUNT}===

Mit der Direktive <code>{$IFDEF AUTOREFCOUNT}</code> kann unter Umständen der beste Code für beide Szenarien erzielt werden: ARC und traditionell. <code>AUTOREFCOUNT</code> definiert Code, der die automatische Referenzzählung verwendet, wie z. B. Code für die mobilen {{Delphi}}-Compiler. Diese Direktive ist sehr wichtig und unterscheidet sich von <code>{$IFDEF NEXTGEN}</code> (der Direktive, die die neuen Sprach-Features der mobilen Compiler definiert). <code>AUTOREFCOUNT</code> könnte zukünftig nützlich werden, für den Fall, dass ARC auch für die {{Delphi}}-Desktop-Compiler implementiert wird.

==Die Methoden [[lib_de:System.TObject.Free|Free]] und [[lib_de:System.TObject.DisposeOf|DisposeOf]] unter ARC==

Bei Klassen sind {{Delphi}}-Entwickler ein anderes Programmiermuster auf Basis der Methode <code>Free</code> und geschützt durch den <code>try-finally</code>-Block gewöhnt.

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

Bei den {{Delphi}}-Desktop-Compilern ist <code>Free</code> eine Methode von <code>TObject</code>, die überprüft, ob die aktuelle Referenz nicht nil ist, und in diesem Fall den <code>Destroy</code>-Destruktor aufruft, der das Objekt nach Ausführung des entsprechenden Destruktorcodes aus dem Speicher entfernt.

In den neuen mobilen {{Delphi}}-Compilern wird der Aufruf von <code>Free</code> durch die Zuweisung von '''nil''' zu der Variable ersetzt. Falls es sich dabei um die letzte Referenz auf das Objekt handelt, wird es weiterhin nach dem Aufruf des Destruktors aus dem Speicher entfernt. Falls es noch bestehende Referenzen gibt, passiert nichts (außer einer Verringerung des Referenzzählers).

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

Ebenso setzt ein Aufruf wie der obige das Objekt auf '''nil''' und löst wieder die Objektfreigabe nur dann aus, wenn keine anderen Variablen das Objekt referenzieren. In den meisten Fällen ist das korrekt, weil keine Objekte freigegeben werden sollen, die in anderen Programmteilen verwendet werden. Andererseits gibt es Szenarien, in denen der Destruktorcode sofort ausgeführt werden muss, unabhängig davon, ob andere ausstehende Referenzen auf das Objekt vorhanden sind. Damit Entwickler die Ausführung des Destruktors (ohne Freigabe des eigentlichen Objekts aus dem Speicher) erzwingen können, führen die neuen Compiler ein Freigabemuster ein:

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

Dieser Aufruf führt den Destruktorcode auch dann aus, wenn ausstehende Referenzen vorhanden sind. Das Objekt wird hierbei in einen speziellen Zustand versetzt, damit der Destruktor bei weiteren Freigabeoperationen oder wenn der Referenzzähler null erreicht, und Speicher tatsächlich freigegeben wird, nicht nochmals aufgerufen wird. Dieser '''freigegebene''' Zustand (oder '''Zombie'''-Zustand) ist ziemlich wichtig, und Sie können diesen Objektzustand mit der Eigenschaft <code>[[lib_de:System.TObject.Disposed|Disposed]]</code> abfragen.

Wie weiter oben bereits erwähnt, funktionieren die klassischen '''try-finally'''-Blöcke, die mit den {{Delphi}}-Desktop-Compiler verwendet werden, auch mit den neuen Compilern, auch wenn sie nicht erforderlich sind.
In den meisten Fällen sollten Sie aber den '''dispose'''-Programmierstil verwenden (außer Sie möchten den Code für frühere Versionen von {{Delphi}} compilieren).

Im folgenden Beispiel wird derselbe Effekt wie mit dem klassischen Compiler erzielt, weil <code>DisposeOf</code> Free aufruft. Der Code führt wie erwartet den Destruktor aus (zur selben Zeit wie der klassische Compiler, aber der Speicher wird vom ARC-Mechanismus verwaltet).
<source lang="delphi">
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.DisposeOf;
end;
end;
</source>

{{Note| Die Speicherung des Disposed-Flags wird durch ein Bit im Feld <code>FRefCount</code> erreicht, unter Berücksichtigung, dass die Obergrenze der Referenzen für ein Objekt bei 230 liegt. }}

==Erstellungs- und Freigabemethoden für TObject unter ARC==

Die folgenden Abschnitte enthalten eine Übersicht über die Methoden in der Klasse <code>TObject</code> in Bezug auf Erstellung und Freigabe.

Die Unterschiede zwischen <code>Free</code> und <code>DisposeOf</code> können auch unter Berücksichtigung des Zwecks betrachtet werden. <code>Free</code> wird verwendet, um eine bestimmte Referenz von einer Instanz zu trennen. Dabei ist eine Freigabe des Objekts oder von Speicher nicht impliziert. Im Gegensatz dazu teilt der Programmierer mit <code>DisposeOf</code> der Instanz explizit mit, "sich selbst zu bereinigen". Eine Speicherfreigabe ist dabei nicht notwendigerweise impliziert, <code>DisposeOf</code> führt eine explizite "Vorbereinigung" der Instanz durch. Anschließend ist die Instanz von der normalen Referenzzählungssemantik abhängig, die die Instanz dann schließlich freigeben kann.

==Schwache Referenzen==

Ein weiteres wichtiges Konzept für ARC ist die Rolle von '''schwachen Referenzen'''. Sie erstellen schwache Referenzen, indem Sie Referenzen mit dem Attribut <code>[weak]</code> versehen. Angenommen, zwei Objekte referenzieren sich gegenseitig über ein Feld, und eine externe Variable referenziert das erste Objekt. Der Referenzzähler des ersten Objekts ist 2 (die externe Variable und das zweite Objekt) und der Referenzzähler des zweiten Objekts ist 1. Wenn die externe Variable den Gültigkeitsbereich verlässt, haben beide Objekte einen Referenzzähler von 1, und sie verbleiben unendlich im Speicher.

Um diese Situation und viele ähnlichen Szenarien zu lösen, wird eine schwache Referenz verwendet, um die zirkulären Referenzen aufzuheben, wenn die letzte externe Referenz den Gültigkeitsbereich verlässt.

Eine '''schwache Referenz''' ist eine Referenz auf ein Objekt, dessen Referenzzähler nicht erhöht wird. Eine schwache Referenz wird mit dem Attribut <code>[weak]</code> deklariert, das von den mobilen {{Delphi}}-Compilern unterstützt wird.

Wenn in dem vorherigen Szenario die Referenz von dem zweiten Objekt auf das erste Objekt schwach ist, werden – sobald die externe Variable den Gültigkeitsbereich verlässt – beide Objekte freigegeben. Hier ist ein Beispiel für diese 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>

Im folgenden Codefragment erstellt der Konstruktor der komplexen Klasse ein Objekt der anderen Klasse:
<source lang="delphi">
constructor TMyComplexClass.Create;
begin
inherited Create;
FSimple := TMySimpleClass.Create;
FSimple.FOwnedBy := self;
end;
</source>

Weil das Feld <code>FOwnedBy</code> eine schwache Referenz ist, wird der Referenzzähler des Objekts, auf das es verweist – in diesem Fall auf das aktuelle Objekt ('''self''') – nicht erhöht.

Daher können Sie für diese Klassenstruktur Folgendes schreiben:
<source lang="delphi">
class procedure TMyComplexClass.CreateOnly;
var
MyComplex: TMyComplexClass;
begin
MyComplex := TMyComplexClass.Create;
MyComplex.fSimple.DoSomething;
end;
</source>

Dieser Code verursacht kein Speicherleck, vorausgesetzt, dass die schwache Referenz richtig angewendet wird.

Ein weiteres Beispiel für die Verwendung von schwachen Referenzen ist dieses Codefragment aus der {{Delphi}}-RTL, das Teil der Klassendeklaration von [[lib_de:System.Classes.TComponent|TComponent]] ist:
<source lang="delphi">
type
TComponent = class(TPersistent, IInterface,
IInterfaceComponentReference)
private
[Weak] FOwner: TComponent;
</source>

Wenn Sie das Attribut '''weak''' in Code angeben, der von einem der {{Delphi}}-Desktop-Compiler compiliert wird, dann wird das Attribut ignoriert. Für DCC32 müssen Sie sicherstellen, dass Sie den korrekten Code im Destruktor eines "Eigentümer"-Objekts angeben, damit auch das Objekt, das der Eigentümer "besitzt", freigegeben wird. Der Aufruf von <code>Free</code> ist zulässig, obwohl damit ein anderer Effekt als in den mobilen {{Delphi}}-Compilern erreicht wird. Das Verhalten ist in den meisten Fällen korrekt.

{{Note| Wenn für eine Instanz der Speicher freigegeben wird, werden alle aktiven '''[weak]'''-Referenzen auf '''nil''' gesetzt. Genau wie bei '''starken''' (normalen) Referenzen kann eine '''[weak]'''-Variable nur '''nil''' sein oder eine gültige Instanz referenzieren. Das ist der Hauptgrund, warum eine '''schwache''' Referenz vor dem Testen auf '''nil''' und dem Dereferenzieren einer '''starken''' Referenz zugewiesen werden soll. Durch Zuweisung zu einer starken Referenz kann die Instanz nicht vorzeitig freigegeben werden.}}
<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| Eine '''[weak]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[weak]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[weak]''' '''var'''- oder '''out'''-Parameter übergeben werden. }}

==Das Attribut "Unsafe"==

Verwenden Sie die folgende Syntax, um das Attribut '''unsafe''' für eine Funktion festzulegen:

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

{{Warning| '''[Unsafe]''' kann auch für Variablen (Member) und Parameter verwendet werden. Es sollte außerhalb der Unit [[lib_de:System|System]] nur in sehr seltenen Situationen verwendet werden. Es gilt als gefährlich, und die Verwendung von [Unsafe] wird nicht empfohlen, weil keine Referenzzählung generiert wird.}}

{{Note| Eine '''[Unsafe]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[Unsafe]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[Unsafe]''' '''var'''- oder '''out'''-Parameter übergeben werden. }}

==Operatorüberladung für Klassen==

Ein interessanter Nebeneffekt der ARC-Speicherverwaltung ist, dass der Compiler die Lebensdauer temporärer von Funktionen zurückgegebener Objekte handhaben kann. Einen speziellen Fall stellen temporäre von Operatoren zurückgegebene Objekte dar. Ein ganz neues Feature der neuen {{Delphi}}-Compiler ist die Möglichkeit, Operatoren für Klassen zu definieren, mit derselben Syntax und demselben Modell, das für Records seit {{Delphi}} 2006 verfügbar ist.

{{Note| Das folgende Codebeispiel funktioniert für die mobilen {{Delphi}}-Compiler (iOS), kann aber nicht von den {{Delphi}}-Desktop-Compilern compiliert werden. }}

Als Beispiel dient die folgende einfache Klasse:
<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>

==Siehe auch==

* [[Automatische Referenzzählung in C++|Automatische Referenzzählung in C++]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[DCCIOS32.EXE: Der Delphi-Compiler für den iOS-Simulator|DCCIOS32: Der Delphi-Compiler für den iOS-Simulator]]
* [[DCCIOSARM.EXE: Der Delphi-Compiler für 32-Bit-iOS-Geräte|DCCIOSARM: Der Delphi-Compiler für 32-Bit-iOS-Geräte]]
* [[DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte|DCCIOSARM64, Der Delphi-Compiler für 64-Bit-iOS-Geräte]]
* [https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]
* [[Referenzzählung einsetzen|Referenzzählung einsetzen]] (über Interfaces mit {{Delphi}}-Desktop-Compilern)

===Codebeispiel===

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

{{DEFAULTSORT:Automatische Referenzzahlung in mobilen Delphi-Compilern}}
[[Category:Delphi]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Automatic Reference Counting in Delphi Mobile Compilers]]
[[fr:Comptage automatique des références dans les compilateurs mobiles Delphi]]
[[ja:Delphi モバイルコンパイラでの自動参照カウント]]

Automatische Referenzzählung in mobilen Delphi-Compilern

2021-03-04T14:06:10Z

Alejandra.Barrientos: /* Das Attribut "Unsafe" */ Added templates

{{Parent|Gesichtspunkte für geräteübergreifende Delphi-Anwendungen}}

{{Delphi}}-Benutzer sind seit langem mit dem Begriff der automatischen Referenzzählung (ARC, Automatic Reference Counting) vertraut. In der Vergangenheit haben die {{Delphi}}-Desktop-Compiler (DCC32, DCC64, DCCOSX) ARC für Interfaces (in '''{{Delphi}} 3''' eingeführt), dynamische Arrays und Strings ('''AnsiString''' wurde in '''{{Delphi}} 2''' eingeführt) unterstützt. Jetzt wurde für die mobilen {{Delphi}}-Compiler die automatische Referenzzählung auch für Klassen eingeführt. In diesem Zusammenhang wurde auch der Begriff der '''schwachen Referenz''' eingeführt, um "Zyklen" gemeinsam mit einem anderen Feature zu verwalten: '''Operatorüberladung für Klassen'''.

Eine detaillierte Beschreibung der automatischen Referenzzählung finden Sie unter '''[https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]'''

==Automatische Referenzzählung==

Die '''Automatische Referenzzählung''' ist eine Möglichkeit zur Verwaltung der Objektlebensdauer ohne Freigabe des Objekts, wenn es nicht mehr benötigt wird. Ein gutes Beispiel dafür ist eine lokale Variable, die ein Objekt referenziert, das den Gültigkeitsbereich verlässt. Daran anschließend wird das Objekt automatisch freigegeben. Wie oben erwähnt, hat {{Delphi}} immer schon die Referenzzählung für Strings und durch Variablen vom Typ Interface referenzierte Objekte unterstützt. ARC bietet aber in den mobilen {{Delphi}} -Compilern eine gewisse Flexibilität, um Probleme, wie zirkuläre Referenzen, zu beheben, die mit Variablen vom Typ Interface schwer zu handhaben sind.

Ein weiterer in den neuen mobilen {{Delphi}}-Compilern eingeführter Begriff ist '''schwache Referenz'''. Damit werden auch einige Probleme mit zirkulären Referenzen behoben.

Das Speicherverwaltungsschema ist dasselbe für Apps, die für iOS-Geräte oder den iOS-Simulator compiliert werden:

* DCCIOSARM (der {{Delphi}}-Compiler für das 32-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOSARM64 (der {{Delphi}}-Compiler für das 64-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOS32 (der {{Delphi}}-Compiler für den iOS-Simulator) aktiviert ARC auch, obwohl DCCIOS32 auf der herkömmlichen Compiler-Architektur basiert.

{{Note| Diese neuen Features erscheinen im Quellcode von {{Variables|Product}} ausschließlich in den konditionalen <code>{$AUTOREFCOUNT}</code>-Blöcken in der RTL (z. B. in ''System.pas''). }}

==Änderungen des Programmierstils==

Da die neuen mobilen Compiler die automatische Referenzzählung unterstützen, kann beim Verweisen auf temporäre Objekte in einer Methode der Code deutlich vereinfacht werden. Die Speicherverwaltung wird vollständig ignoriert:

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

Im obigen Beispiel wird der Destruktor für das Objekt aufgerufen, wenn das Programm die '''end'''-Anweisung erreicht, das heißt, wenn die Variable <code>MyObj</code> den Gültigkeitsbereich verlässt.

Die Verwendung des Objekts kann auch vor dem Ende der Methode beendet werden. Dies kann durch Setzen der Variable auf '''nil''' erreicht werden:

<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>

In diesem Fall wird das Objekt vor dem Ende der Methode freigegeben und zwar genau dann, wenn die Variable auf '''nil''' gesetzt wird. Falls die <code>DoSomething</code>-Prozedur eine Exception auslöst, wird die '''nil'''-Zuweisungsanweisung übersprungen. Wird die Methode schließlich beendet, wird auch das Objekt freigegeben.

Da sich die Lebensdauer des Objekts nach dem Programmfluss richtet, können Sie den Referenzzähler eines Objekts (nur auf Plattformen mit Referenzzählung) mit der neuen Eigenschaft RefCount abfragen:
<source lang="delphi">
public
property RefCount: Integer read FRefCount;
</source>

{{Note| Das Abfragen des Referenzzählers eines Objekts wird nicht empfohlen und sollte im Allgemeinen nicht verwendet werden. }}

===Geschwindigkeit von ineinandergreifenden Vorgängen===

Das Inkrementieren und Dekrementieren des Referenzzählers eines Objekts wird unter Verwendung von Thread-sicher Operationen durchgeführt, damit der Member der Referenzzählerinstanz Thread-sicher ist. Das bedeutet, dass die Referenzzähler-Instanzvariable korrekt durch '''Speicherbarrieren''' abgeschirmt ist, damit die Änderung von allen Threads sofort beachtet wird und sie keinen '''alten''' Wert ändern können.

{{Note| Der ARC-Mechanismus schützt nicht vor Racebedingungen und Deadlocks. }}

===ARC und die Direktive {$AUTOREFCOUNT}===

Mit der Direktive <code>{$IFDEF AUTOREFCOUNT}</code> kann unter Umständen der beste Code für beide Szenarien erzielt werden: ARC und traditionell. <code>AUTOREFCOUNT</code> definiert Code, der die automatische Referenzzählung verwendet, wie z. B. Code für die mobilen {{Delphi}}-Compiler. Diese Direktive ist sehr wichtig und unterscheidet sich von <code>{$IFDEF NEXTGEN}</code> (der Direktive, die die neuen Sprach-Features der mobilen Compiler definiert). <code>AUTOREFCOUNT</code> könnte zukünftig nützlich werden, für den Fall, dass ARC auch für die {{Delphi}}-Desktop-Compiler implementiert wird.

==Die Methoden [[lib_de:System.TObject.Free|Free]] und [[lib_de:System.TObject.DisposeOf|DisposeOf]] unter ARC==

Bei Klassen sind {{Delphi}}-Entwickler ein anderes Programmiermuster auf Basis der Methode <code>Free</code> und geschützt durch den <code>try-finally</code>-Block gewöhnt.

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

Bei den {{Delphi}}-Desktop-Compilern ist <code>Free</code> eine Methode von <code>TObject</code>, die überprüft, ob die aktuelle Referenz nicht nil ist, und in diesem Fall den <code>Destroy</code>-Destruktor aufruft, der das Objekt nach Ausführung des entsprechenden Destruktorcodes aus dem Speicher entfernt.

In den neuen mobilen {{Delphi}}-Compilern wird der Aufruf von <code>Free</code> durch die Zuweisung von '''nil''' zu der Variable ersetzt. Falls es sich dabei um die letzte Referenz auf das Objekt handelt, wird es weiterhin nach dem Aufruf des Destruktors aus dem Speicher entfernt. Falls es noch bestehende Referenzen gibt, passiert nichts (außer einer Verringerung des Referenzzählers).

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

Ebenso setzt ein Aufruf wie der obige das Objekt auf '''nil''' und löst wieder die Objektfreigabe nur dann aus, wenn keine anderen Variablen das Objekt referenzieren. In den meisten Fällen ist das korrekt, weil keine Objekte freigegeben werden sollen, die in anderen Programmteilen verwendet werden. Andererseits gibt es Szenarien, in denen der Destruktorcode sofort ausgeführt werden muss, unabhängig davon, ob andere ausstehende Referenzen auf das Objekt vorhanden sind. Damit Entwickler die Ausführung des Destruktors (ohne Freigabe des eigentlichen Objekts aus dem Speicher) erzwingen können, führen die neuen Compiler ein Freigabemuster ein:

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

Dieser Aufruf führt den Destruktorcode auch dann aus, wenn ausstehende Referenzen vorhanden sind. Das Objekt wird hierbei in einen speziellen Zustand versetzt, damit der Destruktor bei weiteren Freigabeoperationen oder wenn der Referenzzähler null erreicht, und Speicher tatsächlich freigegeben wird, nicht nochmals aufgerufen wird. Dieser '''freigegebene''' Zustand (oder '''Zombie'''-Zustand) ist ziemlich wichtig, und Sie können diesen Objektzustand mit der Eigenschaft <code>[[lib_de:System.TObject.Disposed|Disposed]]</code> abfragen.

Wie weiter oben bereits erwähnt, funktionieren die klassischen '''try-finally'''-Blöcke, die mit den {{Delphi}}-Desktop-Compiler verwendet werden, auch mit den neuen Compilern, auch wenn sie nicht erforderlich sind.
In den meisten Fällen sollten Sie aber den '''dispose'''-Programmierstil verwenden (außer Sie möchten den Code für frühere Versionen von {{Delphi}} compilieren).

Im folgenden Beispiel wird derselbe Effekt wie mit dem klassischen Compiler erzielt, weil <code>DisposeOf</code> Free aufruft. Der Code führt wie erwartet den Destruktor aus (zur selben Zeit wie der klassische Compiler, aber der Speicher wird vom ARC-Mechanismus verwaltet).
<source lang="delphi">
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.DisposeOf;
end;
end;
</source>

{{Note| Die Speicherung des Disposed-Flags wird durch ein Bit im Feld <code>FRefCount</code> erreicht, unter Berücksichtigung, dass die Obergrenze der Referenzen für ein Objekt bei 230 liegt. }}

==Erstellungs- und Freigabemethoden für TObject unter ARC==

Die folgenden Abschnitte enthalten eine Übersicht über die Methoden in der Klasse <code>TObject</code> in Bezug auf Erstellung und Freigabe.

Die Unterschiede zwischen <code>Free</code> und <code>DisposeOf</code> können auch unter Berücksichtigung des Zwecks betrachtet werden. <code>Free</code> wird verwendet, um eine bestimmte Referenz von einer Instanz zu trennen. Dabei ist eine Freigabe des Objekts oder von Speicher nicht impliziert. Im Gegensatz dazu teilt der Programmierer mit <code>DisposeOf</code> der Instanz explizit mit, "sich selbst zu bereinigen". Eine Speicherfreigabe ist dabei nicht notwendigerweise impliziert, <code>DisposeOf</code> führt eine explizite "Vorbereinigung" der Instanz durch. Anschließend ist die Instanz von der normalen Referenzzählungssemantik abhängig, die die Instanz dann schließlich freigeben kann.

==Schwache Referenzen==

Ein weiteres wichtiges Konzept für ARC ist die Rolle von '''schwachen Referenzen'''. Sie erstellen schwache Referenzen, indem Sie Referenzen mit dem Attribut <code>[weak]</code> versehen. Angenommen, zwei Objekte referenzieren sich gegenseitig über ein Feld, und eine externe Variable referenziert das erste Objekt. Der Referenzzähler des ersten Objekts ist 2 (die externe Variable und das zweite Objekt) und der Referenzzähler des zweiten Objekts ist 1. Wenn die externe Variable den Gültigkeitsbereich verlässt, haben beide Objekte einen Referenzzähler von 1, und sie verbleiben unendlich im Speicher.

Um diese Situation und viele ähnlichen Szenarien zu lösen, wird eine schwache Referenz verwendet, um die zirkulären Referenzen aufzuheben, wenn die letzte externe Referenz den Gültigkeitsbereich verlässt.

Eine '''schwache Referenz''' ist eine Referenz auf ein Objekt, dessen Referenzzähler nicht erhöht wird. Eine schwache Referenz wird mit dem Attribut <code>[weak]</code> deklariert, das von den mobilen {{Delphi}}-Compilern unterstützt wird.

Wenn in dem vorherigen Szenario die Referenz von dem zweiten Objekt auf das erste Objekt schwach ist, werden – sobald die externe Variable den Gültigkeitsbereich verlässt – beide Objekte freigegeben. Hier ist ein Beispiel für diese 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>

Im folgenden Codefragment erstellt der Konstruktor der komplexen Klasse ein Objekt der anderen Klasse:
<source lang="delphi">
constructor TMyComplexClass.Create;
begin
inherited Create;
FSimple := TMySimpleClass.Create;
FSimple.FOwnedBy := self;
end;
</source>

Weil das Feld <code>FOwnedBy</code> eine schwache Referenz ist, wird der Referenzzähler des Objekts, auf das es verweist – in diesem Fall auf das aktuelle Objekt ('''self''') – nicht erhöht.

Daher können Sie für diese Klassenstruktur Folgendes schreiben:
<source lang="delphi">
class procedure TMyComplexClass.CreateOnly;
var
MyComplex: TMyComplexClass;
begin
MyComplex := TMyComplexClass.Create;
MyComplex.fSimple.DoSomething;
end;
</source>

Dieser Code verursacht kein Speicherleck, vorausgesetzt, dass die schwache Referenz richtig angewendet wird.

Ein weiteres Beispiel für die Verwendung von schwachen Referenzen ist dieses Codefragment aus der {{Delphi}}-RTL, das Teil der Klassendeklaration von [[lib_de:System.Classes.TComponent|TComponent]] ist:
<source lang="delphi">
type
TComponent = class(TPersistent, IInterface,
IInterfaceComponentReference)
private
[Weak] FOwner: TComponent;
</source>

Wenn Sie das Attribut '''weak''' in Code angeben, der von einem der {{Delphi}}-Desktop-Compiler compiliert wird, dann wird das Attribut ignoriert. Für DCC32 müssen Sie sicherstellen, dass Sie den korrekten Code im Destruktor eines "Eigentümer"-Objekts angeben, damit auch das Objekt, das der Eigentümer "besitzt", freigegeben wird. Der Aufruf von <code>Free</code> ist zulässig, obwohl damit ein anderer Effekt als in den mobilen {{Delphi}}-Compilern erreicht wird. Das Verhalten ist in den meisten Fällen korrekt.

{{Note| Wenn für eine Instanz der Speicher freigegeben wird, werden alle aktiven '''[weak]'''-Referenzen auf '''nil''' gesetzt. Genau wie bei '''starken''' (normalen) Referenzen kann eine '''[weak]'''-Variable nur '''nil''' sein oder eine gültige Instanz referenzieren. Das ist der Hauptgrund, warum eine '''schwache''' Referenz vor dem Testen auf '''nil''' und dem Dereferenzieren einer '''starken''' Referenz zugewiesen werden soll. Durch Zuweisung zu einer starken Referenz kann die Instanz nicht vorzeitig freigegeben werden.}}
<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| Eine '''[weak]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[weak]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[weak]''' '''var'''- oder '''out'''-Parameter übergeben werden. }}

==Das Attribut "Unsafe"==

Verwenden Sie die folgende Syntax, um das Attribut '''unsafe''' für eine Funktion festzulegen:

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

{{Warning| '''[Unsafe]''' kann auch für Variablen (Member) und Parameter verwendet werden. Es sollte außerhalb der Unit [[lib_de:System|System]] nur in sehr seltenen Situationen verwendet werden. Es gilt als gefährlich, und die Verwendung von [Unsafe] wird nicht empfohlen, weil keine Referenzzählung generiert wird.}}

{{Note| Eine '''[Unsafe]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[Unsafe]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[Unsafe]''' '''var'''- oder '''out'''-Parameter übergeben werden. }}

==Operatorüberladung für Klassen==

Ein interessanter Nebeneffekt der ARC-Speicherverwaltung ist, dass der Compiler die Lebensdauer temporärer von Funktionen zurückgegebener Objekte handhaben kann. Einen speziellen Fall stellen temporäre von Operatoren zurückgegebene Objekte dar. Ein ganz neues Feature der neuen {{Delphi}}-Compiler ist die Möglichkeit, Operatoren für Klassen zu definieren, mit derselben Syntax und demselben Modell, das für Records seit {{Delphi}} 2006 verfügbar ist.

<blockquote>'''Hinweis:''' Das folgende Codebeispiel funktioniert für die mobilen {{Delphi}}-Compiler (iOS), kann aber nicht von den {{Delphi}}-Desktop-Compilern compiliert werden. </blockquote>

Als Beispiel dient die folgende einfache Klasse:
<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>

==Siehe auch==

* [[Automatische Referenzzählung in C++|Automatische Referenzzählung in C++]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[DCCIOS32.EXE: Der Delphi-Compiler für den iOS-Simulator|DCCIOS32: Der Delphi-Compiler für den iOS-Simulator]]
* [[DCCIOSARM.EXE: Der Delphi-Compiler für 32-Bit-iOS-Geräte|DCCIOSARM: Der Delphi-Compiler für 32-Bit-iOS-Geräte]]
* [[DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte|DCCIOSARM64, Der Delphi-Compiler für 64-Bit-iOS-Geräte]]
* [https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]
* [[Referenzzählung einsetzen|Referenzzählung einsetzen]] (über Interfaces mit {{Delphi}}-Desktop-Compilern)

===Codebeispiel===

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

{{DEFAULTSORT:Automatische Referenzzahlung in mobilen Delphi-Compilern}}
[[Category:Delphi]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Automatic Reference Counting in Delphi Mobile Compilers]]
[[fr:Comptage automatique des références dans les compilateurs mobiles Delphi]]
[[ja:Delphi モバイルコンパイラでの自動参照カウント]]

Automatische Referenzzählung in mobilen Delphi-Compilern

2021-03-04T14:05:04Z

Alejandra.Barrientos: /* Schwache Referenzen */ Added template

{{Parent|Gesichtspunkte für geräteübergreifende Delphi-Anwendungen}}

{{Delphi}}-Benutzer sind seit langem mit dem Begriff der automatischen Referenzzählung (ARC, Automatic Reference Counting) vertraut. In der Vergangenheit haben die {{Delphi}}-Desktop-Compiler (DCC32, DCC64, DCCOSX) ARC für Interfaces (in '''{{Delphi}} 3''' eingeführt), dynamische Arrays und Strings ('''AnsiString''' wurde in '''{{Delphi}} 2''' eingeführt) unterstützt. Jetzt wurde für die mobilen {{Delphi}}-Compiler die automatische Referenzzählung auch für Klassen eingeführt. In diesem Zusammenhang wurde auch der Begriff der '''schwachen Referenz''' eingeführt, um "Zyklen" gemeinsam mit einem anderen Feature zu verwalten: '''Operatorüberladung für Klassen'''.

Eine detaillierte Beschreibung der automatischen Referenzzählung finden Sie unter '''[https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]'''

==Automatische Referenzzählung==

Die '''Automatische Referenzzählung''' ist eine Möglichkeit zur Verwaltung der Objektlebensdauer ohne Freigabe des Objekts, wenn es nicht mehr benötigt wird. Ein gutes Beispiel dafür ist eine lokale Variable, die ein Objekt referenziert, das den Gültigkeitsbereich verlässt. Daran anschließend wird das Objekt automatisch freigegeben. Wie oben erwähnt, hat {{Delphi}} immer schon die Referenzzählung für Strings und durch Variablen vom Typ Interface referenzierte Objekte unterstützt. ARC bietet aber in den mobilen {{Delphi}} -Compilern eine gewisse Flexibilität, um Probleme, wie zirkuläre Referenzen, zu beheben, die mit Variablen vom Typ Interface schwer zu handhaben sind.

Ein weiterer in den neuen mobilen {{Delphi}}-Compilern eingeführter Begriff ist '''schwache Referenz'''. Damit werden auch einige Probleme mit zirkulären Referenzen behoben.

Das Speicherverwaltungsschema ist dasselbe für Apps, die für iOS-Geräte oder den iOS-Simulator compiliert werden:

* DCCIOSARM (der {{Delphi}}-Compiler für das 32-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOSARM64 (der {{Delphi}}-Compiler für das 64-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOS32 (der {{Delphi}}-Compiler für den iOS-Simulator) aktiviert ARC auch, obwohl DCCIOS32 auf der herkömmlichen Compiler-Architektur basiert.

{{Note| Diese neuen Features erscheinen im Quellcode von {{Variables|Product}} ausschließlich in den konditionalen <code>{$AUTOREFCOUNT}</code>-Blöcken in der RTL (z. B. in ''System.pas''). }}

==Änderungen des Programmierstils==

Da die neuen mobilen Compiler die automatische Referenzzählung unterstützen, kann beim Verweisen auf temporäre Objekte in einer Methode der Code deutlich vereinfacht werden. Die Speicherverwaltung wird vollständig ignoriert:

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

Im obigen Beispiel wird der Destruktor für das Objekt aufgerufen, wenn das Programm die '''end'''-Anweisung erreicht, das heißt, wenn die Variable <code>MyObj</code> den Gültigkeitsbereich verlässt.

Die Verwendung des Objekts kann auch vor dem Ende der Methode beendet werden. Dies kann durch Setzen der Variable auf '''nil''' erreicht werden:

<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>

In diesem Fall wird das Objekt vor dem Ende der Methode freigegeben und zwar genau dann, wenn die Variable auf '''nil''' gesetzt wird. Falls die <code>DoSomething</code>-Prozedur eine Exception auslöst, wird die '''nil'''-Zuweisungsanweisung übersprungen. Wird die Methode schließlich beendet, wird auch das Objekt freigegeben.

Da sich die Lebensdauer des Objekts nach dem Programmfluss richtet, können Sie den Referenzzähler eines Objekts (nur auf Plattformen mit Referenzzählung) mit der neuen Eigenschaft RefCount abfragen:
<source lang="delphi">
public
property RefCount: Integer read FRefCount;
</source>

{{Note| Das Abfragen des Referenzzählers eines Objekts wird nicht empfohlen und sollte im Allgemeinen nicht verwendet werden. }}

===Geschwindigkeit von ineinandergreifenden Vorgängen===

Das Inkrementieren und Dekrementieren des Referenzzählers eines Objekts wird unter Verwendung von Thread-sicher Operationen durchgeführt, damit der Member der Referenzzählerinstanz Thread-sicher ist. Das bedeutet, dass die Referenzzähler-Instanzvariable korrekt durch '''Speicherbarrieren''' abgeschirmt ist, damit die Änderung von allen Threads sofort beachtet wird und sie keinen '''alten''' Wert ändern können.

{{Note| Der ARC-Mechanismus schützt nicht vor Racebedingungen und Deadlocks. }}

===ARC und die Direktive {$AUTOREFCOUNT}===

Mit der Direktive <code>{$IFDEF AUTOREFCOUNT}</code> kann unter Umständen der beste Code für beide Szenarien erzielt werden: ARC und traditionell. <code>AUTOREFCOUNT</code> definiert Code, der die automatische Referenzzählung verwendet, wie z. B. Code für die mobilen {{Delphi}}-Compiler. Diese Direktive ist sehr wichtig und unterscheidet sich von <code>{$IFDEF NEXTGEN}</code> (der Direktive, die die neuen Sprach-Features der mobilen Compiler definiert). <code>AUTOREFCOUNT</code> könnte zukünftig nützlich werden, für den Fall, dass ARC auch für die {{Delphi}}-Desktop-Compiler implementiert wird.

==Die Methoden [[lib_de:System.TObject.Free|Free]] und [[lib_de:System.TObject.DisposeOf|DisposeOf]] unter ARC==

Bei Klassen sind {{Delphi}}-Entwickler ein anderes Programmiermuster auf Basis der Methode <code>Free</code> und geschützt durch den <code>try-finally</code>-Block gewöhnt.

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

Bei den {{Delphi}}-Desktop-Compilern ist <code>Free</code> eine Methode von <code>TObject</code>, die überprüft, ob die aktuelle Referenz nicht nil ist, und in diesem Fall den <code>Destroy</code>-Destruktor aufruft, der das Objekt nach Ausführung des entsprechenden Destruktorcodes aus dem Speicher entfernt.

In den neuen mobilen {{Delphi}}-Compilern wird der Aufruf von <code>Free</code> durch die Zuweisung von '''nil''' zu der Variable ersetzt. Falls es sich dabei um die letzte Referenz auf das Objekt handelt, wird es weiterhin nach dem Aufruf des Destruktors aus dem Speicher entfernt. Falls es noch bestehende Referenzen gibt, passiert nichts (außer einer Verringerung des Referenzzählers).

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

Ebenso setzt ein Aufruf wie der obige das Objekt auf '''nil''' und löst wieder die Objektfreigabe nur dann aus, wenn keine anderen Variablen das Objekt referenzieren. In den meisten Fällen ist das korrekt, weil keine Objekte freigegeben werden sollen, die in anderen Programmteilen verwendet werden. Andererseits gibt es Szenarien, in denen der Destruktorcode sofort ausgeführt werden muss, unabhängig davon, ob andere ausstehende Referenzen auf das Objekt vorhanden sind. Damit Entwickler die Ausführung des Destruktors (ohne Freigabe des eigentlichen Objekts aus dem Speicher) erzwingen können, führen die neuen Compiler ein Freigabemuster ein:

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

Dieser Aufruf führt den Destruktorcode auch dann aus, wenn ausstehende Referenzen vorhanden sind. Das Objekt wird hierbei in einen speziellen Zustand versetzt, damit der Destruktor bei weiteren Freigabeoperationen oder wenn der Referenzzähler null erreicht, und Speicher tatsächlich freigegeben wird, nicht nochmals aufgerufen wird. Dieser '''freigegebene''' Zustand (oder '''Zombie'''-Zustand) ist ziemlich wichtig, und Sie können diesen Objektzustand mit der Eigenschaft <code>[[lib_de:System.TObject.Disposed|Disposed]]</code> abfragen.

Wie weiter oben bereits erwähnt, funktionieren die klassischen '''try-finally'''-Blöcke, die mit den {{Delphi}}-Desktop-Compiler verwendet werden, auch mit den neuen Compilern, auch wenn sie nicht erforderlich sind.
In den meisten Fällen sollten Sie aber den '''dispose'''-Programmierstil verwenden (außer Sie möchten den Code für frühere Versionen von {{Delphi}} compilieren).

Im folgenden Beispiel wird derselbe Effekt wie mit dem klassischen Compiler erzielt, weil <code>DisposeOf</code> Free aufruft. Der Code führt wie erwartet den Destruktor aus (zur selben Zeit wie der klassische Compiler, aber der Speicher wird vom ARC-Mechanismus verwaltet).
<source lang="delphi">
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.DisposeOf;
end;
end;
</source>

{{Note| Die Speicherung des Disposed-Flags wird durch ein Bit im Feld <code>FRefCount</code> erreicht, unter Berücksichtigung, dass die Obergrenze der Referenzen für ein Objekt bei 230 liegt. }}

==Erstellungs- und Freigabemethoden für TObject unter ARC==

Die folgenden Abschnitte enthalten eine Übersicht über die Methoden in der Klasse <code>TObject</code> in Bezug auf Erstellung und Freigabe.

Die Unterschiede zwischen <code>Free</code> und <code>DisposeOf</code> können auch unter Berücksichtigung des Zwecks betrachtet werden. <code>Free</code> wird verwendet, um eine bestimmte Referenz von einer Instanz zu trennen. Dabei ist eine Freigabe des Objekts oder von Speicher nicht impliziert. Im Gegensatz dazu teilt der Programmierer mit <code>DisposeOf</code> der Instanz explizit mit, "sich selbst zu bereinigen". Eine Speicherfreigabe ist dabei nicht notwendigerweise impliziert, <code>DisposeOf</code> führt eine explizite "Vorbereinigung" der Instanz durch. Anschließend ist die Instanz von der normalen Referenzzählungssemantik abhängig, die die Instanz dann schließlich freigeben kann.

==Schwache Referenzen==

Ein weiteres wichtiges Konzept für ARC ist die Rolle von '''schwachen Referenzen'''. Sie erstellen schwache Referenzen, indem Sie Referenzen mit dem Attribut <code>[weak]</code> versehen. Angenommen, zwei Objekte referenzieren sich gegenseitig über ein Feld, und eine externe Variable referenziert das erste Objekt. Der Referenzzähler des ersten Objekts ist 2 (die externe Variable und das zweite Objekt) und der Referenzzähler des zweiten Objekts ist 1. Wenn die externe Variable den Gültigkeitsbereich verlässt, haben beide Objekte einen Referenzzähler von 1, und sie verbleiben unendlich im Speicher.

Um diese Situation und viele ähnlichen Szenarien zu lösen, wird eine schwache Referenz verwendet, um die zirkulären Referenzen aufzuheben, wenn die letzte externe Referenz den Gültigkeitsbereich verlässt.

Eine '''schwache Referenz''' ist eine Referenz auf ein Objekt, dessen Referenzzähler nicht erhöht wird. Eine schwache Referenz wird mit dem Attribut <code>[weak]</code> deklariert, das von den mobilen {{Delphi}}-Compilern unterstützt wird.

Wenn in dem vorherigen Szenario die Referenz von dem zweiten Objekt auf das erste Objekt schwach ist, werden – sobald die externe Variable den Gültigkeitsbereich verlässt – beide Objekte freigegeben. Hier ist ein Beispiel für diese 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>

Im folgenden Codefragment erstellt der Konstruktor der komplexen Klasse ein Objekt der anderen Klasse:
<source lang="delphi">
constructor TMyComplexClass.Create;
begin
inherited Create;
FSimple := TMySimpleClass.Create;
FSimple.FOwnedBy := self;
end;
</source>

Weil das Feld <code>FOwnedBy</code> eine schwache Referenz ist, wird der Referenzzähler des Objekts, auf das es verweist – in diesem Fall auf das aktuelle Objekt ('''self''') – nicht erhöht.

Daher können Sie für diese Klassenstruktur Folgendes schreiben:
<source lang="delphi">
class procedure TMyComplexClass.CreateOnly;
var
MyComplex: TMyComplexClass;
begin
MyComplex := TMyComplexClass.Create;
MyComplex.fSimple.DoSomething;
end;
</source>

Dieser Code verursacht kein Speicherleck, vorausgesetzt, dass die schwache Referenz richtig angewendet wird.

Ein weiteres Beispiel für die Verwendung von schwachen Referenzen ist dieses Codefragment aus der {{Delphi}}-RTL, das Teil der Klassendeklaration von [[lib_de:System.Classes.TComponent|TComponent]] ist:
<source lang="delphi">
type
TComponent = class(TPersistent, IInterface,
IInterfaceComponentReference)
private
[Weak] FOwner: TComponent;
</source>

Wenn Sie das Attribut '''weak''' in Code angeben, der von einem der {{Delphi}}-Desktop-Compiler compiliert wird, dann wird das Attribut ignoriert. Für DCC32 müssen Sie sicherstellen, dass Sie den korrekten Code im Destruktor eines "Eigentümer"-Objekts angeben, damit auch das Objekt, das der Eigentümer "besitzt", freigegeben wird. Der Aufruf von <code>Free</code> ist zulässig, obwohl damit ein anderer Effekt als in den mobilen {{Delphi}}-Compilern erreicht wird. Das Verhalten ist in den meisten Fällen korrekt.

{{Note| Wenn für eine Instanz der Speicher freigegeben wird, werden alle aktiven '''[weak]'''-Referenzen auf '''nil''' gesetzt. Genau wie bei '''starken''' (normalen) Referenzen kann eine '''[weak]'''-Variable nur '''nil''' sein oder eine gültige Instanz referenzieren. Das ist der Hauptgrund, warum eine '''schwache''' Referenz vor dem Testen auf '''nil''' und dem Dereferenzieren einer '''starken''' Referenz zugewiesen werden soll. Durch Zuweisung zu einer starken Referenz kann die Instanz nicht vorzeitig freigegeben werden.}}
<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| Eine '''[weak]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[weak]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[weak]''' '''var'''- oder '''out'''-Parameter übergeben werden. }}

==Das Attribut "Unsafe"==

Verwenden Sie die folgende Syntax, um das Attribut '''unsafe''' für eine Funktion festzulegen:

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

<blockquote>'''Warnung:''' '''[Unsafe]''' kann auch für Variablen (Member) und Parameter verwendet werden. Es sollte außerhalb der Unit [[lib_de:System|System]] nur in sehr seltenen Situationen verwendet werden. Es gilt als gefährlich, und die Verwendung von [Unsafe] wird nicht empfohlen, weil keine Referenzzählung generiert wird.</blockquote>

<blockquote>'''Hinweis:''' Eine '''[Unsafe]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[Unsafe]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[Unsafe]''' '''var'''- oder '''out'''-Parameter übergeben werden. </blockquote>

==Operatorüberladung für Klassen==

Ein interessanter Nebeneffekt der ARC-Speicherverwaltung ist, dass der Compiler die Lebensdauer temporärer von Funktionen zurückgegebener Objekte handhaben kann. Einen speziellen Fall stellen temporäre von Operatoren zurückgegebene Objekte dar. Ein ganz neues Feature der neuen {{Delphi}}-Compiler ist die Möglichkeit, Operatoren für Klassen zu definieren, mit derselben Syntax und demselben Modell, das für Records seit {{Delphi}} 2006 verfügbar ist.

<blockquote>'''Hinweis:''' Das folgende Codebeispiel funktioniert für die mobilen {{Delphi}}-Compiler (iOS), kann aber nicht von den {{Delphi}}-Desktop-Compilern compiliert werden. </blockquote>

Als Beispiel dient die folgende einfache Klasse:
<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>

==Siehe auch==

* [[Automatische Referenzzählung in C++|Automatische Referenzzählung in C++]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[DCCIOS32.EXE: Der Delphi-Compiler für den iOS-Simulator|DCCIOS32: Der Delphi-Compiler für den iOS-Simulator]]
* [[DCCIOSARM.EXE: Der Delphi-Compiler für 32-Bit-iOS-Geräte|DCCIOSARM: Der Delphi-Compiler für 32-Bit-iOS-Geräte]]
* [[DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte|DCCIOSARM64, Der Delphi-Compiler für 64-Bit-iOS-Geräte]]
* [https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]
* [[Referenzzählung einsetzen|Referenzzählung einsetzen]] (über Interfaces mit {{Delphi}}-Desktop-Compilern)

===Codebeispiel===

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

{{DEFAULTSORT:Automatische Referenzzahlung in mobilen Delphi-Compilern}}
[[Category:Delphi]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Automatic Reference Counting in Delphi Mobile Compilers]]
[[fr:Comptage automatique des références dans les compilateurs mobiles Delphi]]
[[ja:Delphi モバイルコンパイラでの自動参照カウント]]

Automatische Referenzzählung in mobilen Delphi-Compilern

2021-03-04T13:58:35Z

Alejandra.Barrientos: /* Die Methoden Free und DisposeOf unter ARC */ Added Template

{{Parent|Gesichtspunkte für geräteübergreifende Delphi-Anwendungen}}

{{Delphi}}-Benutzer sind seit langem mit dem Begriff der automatischen Referenzzählung (ARC, Automatic Reference Counting) vertraut. In der Vergangenheit haben die {{Delphi}}-Desktop-Compiler (DCC32, DCC64, DCCOSX) ARC für Interfaces (in '''{{Delphi}} 3''' eingeführt), dynamische Arrays und Strings ('''AnsiString''' wurde in '''{{Delphi}} 2''' eingeführt) unterstützt. Jetzt wurde für die mobilen {{Delphi}}-Compiler die automatische Referenzzählung auch für Klassen eingeführt. In diesem Zusammenhang wurde auch der Begriff der '''schwachen Referenz''' eingeführt, um "Zyklen" gemeinsam mit einem anderen Feature zu verwalten: '''Operatorüberladung für Klassen'''.

Eine detaillierte Beschreibung der automatischen Referenzzählung finden Sie unter '''[https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]'''

==Automatische Referenzzählung==

Die '''Automatische Referenzzählung''' ist eine Möglichkeit zur Verwaltung der Objektlebensdauer ohne Freigabe des Objekts, wenn es nicht mehr benötigt wird. Ein gutes Beispiel dafür ist eine lokale Variable, die ein Objekt referenziert, das den Gültigkeitsbereich verlässt. Daran anschließend wird das Objekt automatisch freigegeben. Wie oben erwähnt, hat {{Delphi}} immer schon die Referenzzählung für Strings und durch Variablen vom Typ Interface referenzierte Objekte unterstützt. ARC bietet aber in den mobilen {{Delphi}} -Compilern eine gewisse Flexibilität, um Probleme, wie zirkuläre Referenzen, zu beheben, die mit Variablen vom Typ Interface schwer zu handhaben sind.

Ein weiterer in den neuen mobilen {{Delphi}}-Compilern eingeführter Begriff ist '''schwache Referenz'''. Damit werden auch einige Probleme mit zirkulären Referenzen behoben.

Das Speicherverwaltungsschema ist dasselbe für Apps, die für iOS-Geräte oder den iOS-Simulator compiliert werden:

* DCCIOSARM (der {{Delphi}}-Compiler für das 32-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOSARM64 (der {{Delphi}}-Compiler für das 64-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOS32 (der {{Delphi}}-Compiler für den iOS-Simulator) aktiviert ARC auch, obwohl DCCIOS32 auf der herkömmlichen Compiler-Architektur basiert.

{{Note| Diese neuen Features erscheinen im Quellcode von {{Variables|Product}} ausschließlich in den konditionalen <code>{$AUTOREFCOUNT}</code>-Blöcken in der RTL (z. B. in ''System.pas''). }}

==Änderungen des Programmierstils==

Da die neuen mobilen Compiler die automatische Referenzzählung unterstützen, kann beim Verweisen auf temporäre Objekte in einer Methode der Code deutlich vereinfacht werden. Die Speicherverwaltung wird vollständig ignoriert:

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

Im obigen Beispiel wird der Destruktor für das Objekt aufgerufen, wenn das Programm die '''end'''-Anweisung erreicht, das heißt, wenn die Variable <code>MyObj</code> den Gültigkeitsbereich verlässt.

Die Verwendung des Objekts kann auch vor dem Ende der Methode beendet werden. Dies kann durch Setzen der Variable auf '''nil''' erreicht werden:

<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>

In diesem Fall wird das Objekt vor dem Ende der Methode freigegeben und zwar genau dann, wenn die Variable auf '''nil''' gesetzt wird. Falls die <code>DoSomething</code>-Prozedur eine Exception auslöst, wird die '''nil'''-Zuweisungsanweisung übersprungen. Wird die Methode schließlich beendet, wird auch das Objekt freigegeben.

Da sich die Lebensdauer des Objekts nach dem Programmfluss richtet, können Sie den Referenzzähler eines Objekts (nur auf Plattformen mit Referenzzählung) mit der neuen Eigenschaft RefCount abfragen:
<source lang="delphi">
public
property RefCount: Integer read FRefCount;
</source>

{{Note| Das Abfragen des Referenzzählers eines Objekts wird nicht empfohlen und sollte im Allgemeinen nicht verwendet werden. }}

===Geschwindigkeit von ineinandergreifenden Vorgängen===

Das Inkrementieren und Dekrementieren des Referenzzählers eines Objekts wird unter Verwendung von Thread-sicher Operationen durchgeführt, damit der Member der Referenzzählerinstanz Thread-sicher ist. Das bedeutet, dass die Referenzzähler-Instanzvariable korrekt durch '''Speicherbarrieren''' abgeschirmt ist, damit die Änderung von allen Threads sofort beachtet wird und sie keinen '''alten''' Wert ändern können.

{{Note| Der ARC-Mechanismus schützt nicht vor Racebedingungen und Deadlocks. }}

===ARC und die Direktive {$AUTOREFCOUNT}===

Mit der Direktive <code>{$IFDEF AUTOREFCOUNT}</code> kann unter Umständen der beste Code für beide Szenarien erzielt werden: ARC und traditionell. <code>AUTOREFCOUNT</code> definiert Code, der die automatische Referenzzählung verwendet, wie z. B. Code für die mobilen {{Delphi}}-Compiler. Diese Direktive ist sehr wichtig und unterscheidet sich von <code>{$IFDEF NEXTGEN}</code> (der Direktive, die die neuen Sprach-Features der mobilen Compiler definiert). <code>AUTOREFCOUNT</code> könnte zukünftig nützlich werden, für den Fall, dass ARC auch für die {{Delphi}}-Desktop-Compiler implementiert wird.

==Die Methoden [[lib_de:System.TObject.Free|Free]] und [[lib_de:System.TObject.DisposeOf|DisposeOf]] unter ARC==

Bei Klassen sind {{Delphi}}-Entwickler ein anderes Programmiermuster auf Basis der Methode <code>Free</code> und geschützt durch den <code>try-finally</code>-Block gewöhnt.

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

Bei den {{Delphi}}-Desktop-Compilern ist <code>Free</code> eine Methode von <code>TObject</code>, die überprüft, ob die aktuelle Referenz nicht nil ist, und in diesem Fall den <code>Destroy</code>-Destruktor aufruft, der das Objekt nach Ausführung des entsprechenden Destruktorcodes aus dem Speicher entfernt.

In den neuen mobilen {{Delphi}}-Compilern wird der Aufruf von <code>Free</code> durch die Zuweisung von '''nil''' zu der Variable ersetzt. Falls es sich dabei um die letzte Referenz auf das Objekt handelt, wird es weiterhin nach dem Aufruf des Destruktors aus dem Speicher entfernt. Falls es noch bestehende Referenzen gibt, passiert nichts (außer einer Verringerung des Referenzzählers).

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

Ebenso setzt ein Aufruf wie der obige das Objekt auf '''nil''' und löst wieder die Objektfreigabe nur dann aus, wenn keine anderen Variablen das Objekt referenzieren. In den meisten Fällen ist das korrekt, weil keine Objekte freigegeben werden sollen, die in anderen Programmteilen verwendet werden. Andererseits gibt es Szenarien, in denen der Destruktorcode sofort ausgeführt werden muss, unabhängig davon, ob andere ausstehende Referenzen auf das Objekt vorhanden sind. Damit Entwickler die Ausführung des Destruktors (ohne Freigabe des eigentlichen Objekts aus dem Speicher) erzwingen können, führen die neuen Compiler ein Freigabemuster ein:

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

Dieser Aufruf führt den Destruktorcode auch dann aus, wenn ausstehende Referenzen vorhanden sind. Das Objekt wird hierbei in einen speziellen Zustand versetzt, damit der Destruktor bei weiteren Freigabeoperationen oder wenn der Referenzzähler null erreicht, und Speicher tatsächlich freigegeben wird, nicht nochmals aufgerufen wird. Dieser '''freigegebene''' Zustand (oder '''Zombie'''-Zustand) ist ziemlich wichtig, und Sie können diesen Objektzustand mit der Eigenschaft <code>[[lib_de:System.TObject.Disposed|Disposed]]</code> abfragen.

Wie weiter oben bereits erwähnt, funktionieren die klassischen '''try-finally'''-Blöcke, die mit den {{Delphi}}-Desktop-Compiler verwendet werden, auch mit den neuen Compilern, auch wenn sie nicht erforderlich sind.
In den meisten Fällen sollten Sie aber den '''dispose'''-Programmierstil verwenden (außer Sie möchten den Code für frühere Versionen von {{Delphi}} compilieren).

Im folgenden Beispiel wird derselbe Effekt wie mit dem klassischen Compiler erzielt, weil <code>DisposeOf</code> Free aufruft. Der Code führt wie erwartet den Destruktor aus (zur selben Zeit wie der klassische Compiler, aber der Speicher wird vom ARC-Mechanismus verwaltet).
<source lang="delphi">
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.DisposeOf;
end;
end;
</source>

{{Note| Die Speicherung des Disposed-Flags wird durch ein Bit im Feld <code>FRefCount</code> erreicht, unter Berücksichtigung, dass die Obergrenze der Referenzen für ein Objekt bei 230 liegt. }}

==Erstellungs- und Freigabemethoden für TObject unter ARC==

Die folgenden Abschnitte enthalten eine Übersicht über die Methoden in der Klasse <code>TObject</code> in Bezug auf Erstellung und Freigabe.

Die Unterschiede zwischen <code>Free</code> und <code>DisposeOf</code> können auch unter Berücksichtigung des Zwecks betrachtet werden. <code>Free</code> wird verwendet, um eine bestimmte Referenz von einer Instanz zu trennen. Dabei ist eine Freigabe des Objekts oder von Speicher nicht impliziert. Im Gegensatz dazu teilt der Programmierer mit <code>DisposeOf</code> der Instanz explizit mit, "sich selbst zu bereinigen". Eine Speicherfreigabe ist dabei nicht notwendigerweise impliziert, <code>DisposeOf</code> führt eine explizite "Vorbereinigung" der Instanz durch. Anschließend ist die Instanz von der normalen Referenzzählungssemantik abhängig, die die Instanz dann schließlich freigeben kann.

==Schwache Referenzen==

Ein weiteres wichtiges Konzept für ARC ist die Rolle von '''schwachen Referenzen'''. Sie erstellen schwache Referenzen, indem Sie Referenzen mit dem Attribut <code>[weak]</code> versehen. Angenommen, zwei Objekte referenzieren sich gegenseitig über ein Feld, und eine externe Variable referenziert das erste Objekt. Der Referenzzähler des ersten Objekts ist 2 (die externe Variable und das zweite Objekt) und der Referenzzähler des zweiten Objekts ist 1. Wenn die externe Variable den Gültigkeitsbereich verlässt, haben beide Objekte einen Referenzzähler von 1, und sie verbleiben unendlich im Speicher.

Um diese Situation und viele ähnlichen Szenarien zu lösen, wird eine schwache Referenz verwendet, um die zirkulären Referenzen aufzuheben, wenn die letzte externe Referenz den Gültigkeitsbereich verlässt.

Eine '''schwache Referenz''' ist eine Referenz auf ein Objekt, dessen Referenzzähler nicht erhöht wird. Eine schwache Referenz wird mit dem Attribut <code>[weak]</code> deklariert, das von den mobilen {{Delphi}}-Compilern unterstützt wird.

Wenn in dem vorherigen Szenario die Referenz von dem zweiten Objekt auf das erste Objekt schwach ist, werden – sobald die externe Variable den Gültigkeitsbereich verlässt – beide Objekte freigegeben. Hier ist ein Beispiel für diese 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>

Im folgenden Codefragment erstellt der Konstruktor der komplexen Klasse ein Objekt der anderen Klasse:
<source lang="delphi">
constructor TMyComplexClass.Create;
begin
inherited Create;
FSimple := TMySimpleClass.Create;
FSimple.FOwnedBy := self;
end;
</source>

Weil das Feld <code>FOwnedBy</code> eine schwache Referenz ist, wird der Referenzzähler des Objekts, auf das es verweist – in diesem Fall auf das aktuelle Objekt ('''self''') – nicht erhöht.

Daher können Sie für diese Klassenstruktur Folgendes schreiben:
<source lang="delphi">
class procedure TMyComplexClass.CreateOnly;
var
MyComplex: TMyComplexClass;
begin
MyComplex := TMyComplexClass.Create;
MyComplex.fSimple.DoSomething;
end;
</source>

Dieser Code verursacht kein Speicherleck, vorausgesetzt, dass die schwache Referenz richtig angewendet wird.

Ein weiteres Beispiel für die Verwendung von schwachen Referenzen ist dieses Codefragment aus der {{Delphi}}-RTL, das Teil der Klassendeklaration von [[lib_de:System.Classes.TComponent|TComponent]] ist:
<source lang="delphi">
type
TComponent = class(TPersistent, IInterface,
IInterfaceComponentReference)
private
[Weak] FOwner: TComponent;
</source>

Wenn Sie das Attribut '''weak''' in Code angeben, der von einem der {{Delphi}}-Desktop-Compiler compiliert wird, dann wird das Attribut ignoriert. Für DCC32 müssen Sie sicherstellen, dass Sie den korrekten Code im Destruktor eines "Eigentümer"-Objekts angeben, damit auch das Objekt, das der Eigentümer "besitzt", freigegeben wird. Der Aufruf von <code>Free</code> ist zulässig, obwohl damit ein anderer Effekt als in den mobilen {{Delphi}}-Compilern erreicht wird. Das Verhalten ist in den meisten Fällen korrekt.

<blockquote>'''Hinweis:''' Wenn für eine Instanz der Speicher freigegeben wird, werden alle aktiven '''[weak]'''-Referenzen auf '''nil''' gesetzt. Genau wie bei '''starken''' (normalen) Referenzen kann eine '''[weak]'''-Variable nur '''nil''' sein oder eine gültige Instanz referenzieren. Das ist der Hauptgrund, warum eine '''schwache''' Referenz vor dem Testen auf '''nil''' und dem Dereferenzieren einer '''starken''' Referenz zugewiesen werden soll. Durch Zuweisung zu einer starken Referenz kann die Instanz nicht vorzeitig freigegeben werden.
<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>

<blockquote>'''Hinweis:''' Eine '''[weak]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[weak]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[weak]''' '''var'''- oder '''out'''-Parameter übergeben werden. </blockquote>

==Das Attribut "Unsafe"==

Verwenden Sie die folgende Syntax, um das Attribut '''unsafe''' für eine Funktion festzulegen:

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

<blockquote>'''Warnung:''' '''[Unsafe]''' kann auch für Variablen (Member) und Parameter verwendet werden. Es sollte außerhalb der Unit [[lib_de:System|System]] nur in sehr seltenen Situationen verwendet werden. Es gilt als gefährlich, und die Verwendung von [Unsafe] wird nicht empfohlen, weil keine Referenzzählung generiert wird.</blockquote>

<blockquote>'''Hinweis:''' Eine '''[Unsafe]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[Unsafe]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[Unsafe]''' '''var'''- oder '''out'''-Parameter übergeben werden. </blockquote>

==Operatorüberladung für Klassen==

Ein interessanter Nebeneffekt der ARC-Speicherverwaltung ist, dass der Compiler die Lebensdauer temporärer von Funktionen zurückgegebener Objekte handhaben kann. Einen speziellen Fall stellen temporäre von Operatoren zurückgegebene Objekte dar. Ein ganz neues Feature der neuen {{Delphi}}-Compiler ist die Möglichkeit, Operatoren für Klassen zu definieren, mit derselben Syntax und demselben Modell, das für Records seit {{Delphi}} 2006 verfügbar ist.

<blockquote>'''Hinweis:''' Das folgende Codebeispiel funktioniert für die mobilen {{Delphi}}-Compiler (iOS), kann aber nicht von den {{Delphi}}-Desktop-Compilern compiliert werden. </blockquote>

Als Beispiel dient die folgende einfache Klasse:
<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>

==Siehe auch==

* [[Automatische Referenzzählung in C++|Automatische Referenzzählung in C++]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[DCCIOS32.EXE: Der Delphi-Compiler für den iOS-Simulator|DCCIOS32: Der Delphi-Compiler für den iOS-Simulator]]
* [[DCCIOSARM.EXE: Der Delphi-Compiler für 32-Bit-iOS-Geräte|DCCIOSARM: Der Delphi-Compiler für 32-Bit-iOS-Geräte]]
* [[DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte|DCCIOSARM64, Der Delphi-Compiler für 64-Bit-iOS-Geräte]]
* [https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]
* [[Referenzzählung einsetzen|Referenzzählung einsetzen]] (über Interfaces mit {{Delphi}}-Desktop-Compilern)

===Codebeispiel===

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

{{DEFAULTSORT:Automatische Referenzzahlung in mobilen Delphi-Compilern}}
[[Category:Delphi]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Automatic Reference Counting in Delphi Mobile Compilers]]
[[fr:Comptage automatique des références dans les compilateurs mobiles Delphi]]
[[ja:Delphi モバイルコンパイラでの自動参照カウント]]

Automatische Referenzzählung in mobilen Delphi-Compilern

2021-03-04T13:57:26Z

Alejandra.Barrientos: /* Änderungen des Programmierstils */ Added templates

{{Parent|Gesichtspunkte für geräteübergreifende Delphi-Anwendungen}}

{{Delphi}}-Benutzer sind seit langem mit dem Begriff der automatischen Referenzzählung (ARC, Automatic Reference Counting) vertraut. In der Vergangenheit haben die {{Delphi}}-Desktop-Compiler (DCC32, DCC64, DCCOSX) ARC für Interfaces (in '''{{Delphi}} 3''' eingeführt), dynamische Arrays und Strings ('''AnsiString''' wurde in '''{{Delphi}} 2''' eingeführt) unterstützt. Jetzt wurde für die mobilen {{Delphi}}-Compiler die automatische Referenzzählung auch für Klassen eingeführt. In diesem Zusammenhang wurde auch der Begriff der '''schwachen Referenz''' eingeführt, um "Zyklen" gemeinsam mit einem anderen Feature zu verwalten: '''Operatorüberladung für Klassen'''.

Eine detaillierte Beschreibung der automatischen Referenzzählung finden Sie unter '''[https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]'''

==Automatische Referenzzählung==

Die '''Automatische Referenzzählung''' ist eine Möglichkeit zur Verwaltung der Objektlebensdauer ohne Freigabe des Objekts, wenn es nicht mehr benötigt wird. Ein gutes Beispiel dafür ist eine lokale Variable, die ein Objekt referenziert, das den Gültigkeitsbereich verlässt. Daran anschließend wird das Objekt automatisch freigegeben. Wie oben erwähnt, hat {{Delphi}} immer schon die Referenzzählung für Strings und durch Variablen vom Typ Interface referenzierte Objekte unterstützt. ARC bietet aber in den mobilen {{Delphi}} -Compilern eine gewisse Flexibilität, um Probleme, wie zirkuläre Referenzen, zu beheben, die mit Variablen vom Typ Interface schwer zu handhaben sind.

Ein weiterer in den neuen mobilen {{Delphi}}-Compilern eingeführter Begriff ist '''schwache Referenz'''. Damit werden auch einige Probleme mit zirkulären Referenzen behoben.

Das Speicherverwaltungsschema ist dasselbe für Apps, die für iOS-Geräte oder den iOS-Simulator compiliert werden:

* DCCIOSARM (der {{Delphi}}-Compiler für das 32-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOSARM64 (der {{Delphi}}-Compiler für das 64-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOS32 (der {{Delphi}}-Compiler für den iOS-Simulator) aktiviert ARC auch, obwohl DCCIOS32 auf der herkömmlichen Compiler-Architektur basiert.

{{Note| Diese neuen Features erscheinen im Quellcode von {{Variables|Product}} ausschließlich in den konditionalen <code>{$AUTOREFCOUNT}</code>-Blöcken in der RTL (z. B. in ''System.pas''). }}

==Änderungen des Programmierstils==

Da die neuen mobilen Compiler die automatische Referenzzählung unterstützen, kann beim Verweisen auf temporäre Objekte in einer Methode der Code deutlich vereinfacht werden. Die Speicherverwaltung wird vollständig ignoriert:

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

Im obigen Beispiel wird der Destruktor für das Objekt aufgerufen, wenn das Programm die '''end'''-Anweisung erreicht, das heißt, wenn die Variable <code>MyObj</code> den Gültigkeitsbereich verlässt.

Die Verwendung des Objekts kann auch vor dem Ende der Methode beendet werden. Dies kann durch Setzen der Variable auf '''nil''' erreicht werden:

<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>

In diesem Fall wird das Objekt vor dem Ende der Methode freigegeben und zwar genau dann, wenn die Variable auf '''nil''' gesetzt wird. Falls die <code>DoSomething</code>-Prozedur eine Exception auslöst, wird die '''nil'''-Zuweisungsanweisung übersprungen. Wird die Methode schließlich beendet, wird auch das Objekt freigegeben.

Da sich die Lebensdauer des Objekts nach dem Programmfluss richtet, können Sie den Referenzzähler eines Objekts (nur auf Plattformen mit Referenzzählung) mit der neuen Eigenschaft RefCount abfragen:
<source lang="delphi">
public
property RefCount: Integer read FRefCount;
</source>

{{Note| Das Abfragen des Referenzzählers eines Objekts wird nicht empfohlen und sollte im Allgemeinen nicht verwendet werden. }}

===Geschwindigkeit von ineinandergreifenden Vorgängen===

Das Inkrementieren und Dekrementieren des Referenzzählers eines Objekts wird unter Verwendung von Thread-sicher Operationen durchgeführt, damit der Member der Referenzzählerinstanz Thread-sicher ist. Das bedeutet, dass die Referenzzähler-Instanzvariable korrekt durch '''Speicherbarrieren''' abgeschirmt ist, damit die Änderung von allen Threads sofort beachtet wird und sie keinen '''alten''' Wert ändern können.

{{Note| Der ARC-Mechanismus schützt nicht vor Racebedingungen und Deadlocks. }}

===ARC und die Direktive {$AUTOREFCOUNT}===

Mit der Direktive <code>{$IFDEF AUTOREFCOUNT}</code> kann unter Umständen der beste Code für beide Szenarien erzielt werden: ARC und traditionell. <code>AUTOREFCOUNT</code> definiert Code, der die automatische Referenzzählung verwendet, wie z. B. Code für die mobilen {{Delphi}}-Compiler. Diese Direktive ist sehr wichtig und unterscheidet sich von <code>{$IFDEF NEXTGEN}</code> (der Direktive, die die neuen Sprach-Features der mobilen Compiler definiert). <code>AUTOREFCOUNT</code> könnte zukünftig nützlich werden, für den Fall, dass ARC auch für die {{Delphi}}-Desktop-Compiler implementiert wird.

==Die Methoden [[lib_de:System.TObject.Free|Free]] und [[lib_de:System.TObject.DisposeOf|DisposeOf]] unter ARC==

Bei Klassen sind {{Delphi}}-Entwickler ein anderes Programmiermuster auf Basis der Methode <code>Free</code> und geschützt durch den <code>try-finally</code>-Block gewöhnt.

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

Bei den {{Delphi}}-Desktop-Compilern ist <code>Free</code> eine Methode von <code>TObject</code>, die überprüft, ob die aktuelle Referenz nicht nil ist, und in diesem Fall den <code>Destroy</code>-Destruktor aufruft, der das Objekt nach Ausführung des entsprechenden Destruktorcodes aus dem Speicher entfernt.

In den neuen mobilen {{Delphi}}-Compilern wird der Aufruf von <code>Free</code> durch die Zuweisung von '''nil''' zu der Variable ersetzt. Falls es sich dabei um die letzte Referenz auf das Objekt handelt, wird es weiterhin nach dem Aufruf des Destruktors aus dem Speicher entfernt. Falls es noch bestehende Referenzen gibt, passiert nichts (außer einer Verringerung des Referenzzählers).

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

Ebenso setzt ein Aufruf wie der obige das Objekt auf '''nil''' und löst wieder die Objektfreigabe nur dann aus, wenn keine anderen Variablen das Objekt referenzieren. In den meisten Fällen ist das korrekt, weil keine Objekte freigegeben werden sollen, die in anderen Programmteilen verwendet werden. Andererseits gibt es Szenarien, in denen der Destruktorcode sofort ausgeführt werden muss, unabhängig davon, ob andere ausstehende Referenzen auf das Objekt vorhanden sind. Damit Entwickler die Ausführung des Destruktors (ohne Freigabe des eigentlichen Objekts aus dem Speicher) erzwingen können, führen die neuen Compiler ein Freigabemuster ein:

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

Dieser Aufruf führt den Destruktorcode auch dann aus, wenn ausstehende Referenzen vorhanden sind. Das Objekt wird hierbei in einen speziellen Zustand versetzt, damit der Destruktor bei weiteren Freigabeoperationen oder wenn der Referenzzähler null erreicht, und Speicher tatsächlich freigegeben wird, nicht nochmals aufgerufen wird. Dieser '''freigegebene''' Zustand (oder '''Zombie'''-Zustand) ist ziemlich wichtig, und Sie können diesen Objektzustand mit der Eigenschaft <code>[[lib_de:System.TObject.Disposed|Disposed]]</code> abfragen.

Wie weiter oben bereits erwähnt, funktionieren die klassischen '''try-finally'''-Blöcke, die mit den {{Delphi}}-Desktop-Compiler verwendet werden, auch mit den neuen Compilern, auch wenn sie nicht erforderlich sind.
In den meisten Fällen sollten Sie aber den '''dispose'''-Programmierstil verwenden (außer Sie möchten den Code für frühere Versionen von {{Delphi}} compilieren).

Im folgenden Beispiel wird derselbe Effekt wie mit dem klassischen Compiler erzielt, weil <code>DisposeOf</code> Free aufruft. Der Code führt wie erwartet den Destruktor aus (zur selben Zeit wie der klassische Compiler, aber der Speicher wird vom ARC-Mechanismus verwaltet).
<source lang="delphi">
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.DisposeOf;
end;
end;
</source>

<blockquote>'''Hinweis:''' Die Speicherung des Disposed-Flags wird durch ein Bit im Feld <code>FRefCount</code> erreicht, unter Berücksichtigung, dass die Obergrenze der Referenzen für ein Objekt bei 230 liegt. </blockquote>

==Erstellungs- und Freigabemethoden für TObject unter ARC==

Die folgenden Abschnitte enthalten eine Übersicht über die Methoden in der Klasse <code>TObject</code> in Bezug auf Erstellung und Freigabe.

Die Unterschiede zwischen <code>Free</code> und <code>DisposeOf</code> können auch unter Berücksichtigung des Zwecks betrachtet werden. <code>Free</code> wird verwendet, um eine bestimmte Referenz von einer Instanz zu trennen. Dabei ist eine Freigabe des Objekts oder von Speicher nicht impliziert. Im Gegensatz dazu teilt der Programmierer mit <code>DisposeOf</code> der Instanz explizit mit, "sich selbst zu bereinigen". Eine Speicherfreigabe ist dabei nicht notwendigerweise impliziert, <code>DisposeOf</code> führt eine explizite "Vorbereinigung" der Instanz durch. Anschließend ist die Instanz von der normalen Referenzzählungssemantik abhängig, die die Instanz dann schließlich freigeben kann.

==Schwache Referenzen==

Ein weiteres wichtiges Konzept für ARC ist die Rolle von '''schwachen Referenzen'''. Sie erstellen schwache Referenzen, indem Sie Referenzen mit dem Attribut <code>[weak]</code> versehen. Angenommen, zwei Objekte referenzieren sich gegenseitig über ein Feld, und eine externe Variable referenziert das erste Objekt. Der Referenzzähler des ersten Objekts ist 2 (die externe Variable und das zweite Objekt) und der Referenzzähler des zweiten Objekts ist 1. Wenn die externe Variable den Gültigkeitsbereich verlässt, haben beide Objekte einen Referenzzähler von 1, und sie verbleiben unendlich im Speicher.

Um diese Situation und viele ähnlichen Szenarien zu lösen, wird eine schwache Referenz verwendet, um die zirkulären Referenzen aufzuheben, wenn die letzte externe Referenz den Gültigkeitsbereich verlässt.

Eine '''schwache Referenz''' ist eine Referenz auf ein Objekt, dessen Referenzzähler nicht erhöht wird. Eine schwache Referenz wird mit dem Attribut <code>[weak]</code> deklariert, das von den mobilen {{Delphi}}-Compilern unterstützt wird.

Wenn in dem vorherigen Szenario die Referenz von dem zweiten Objekt auf das erste Objekt schwach ist, werden – sobald die externe Variable den Gültigkeitsbereich verlässt – beide Objekte freigegeben. Hier ist ein Beispiel für diese 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>

Im folgenden Codefragment erstellt der Konstruktor der komplexen Klasse ein Objekt der anderen Klasse:
<source lang="delphi">
constructor TMyComplexClass.Create;
begin
inherited Create;
FSimple := TMySimpleClass.Create;
FSimple.FOwnedBy := self;
end;
</source>

Weil das Feld <code>FOwnedBy</code> eine schwache Referenz ist, wird der Referenzzähler des Objekts, auf das es verweist – in diesem Fall auf das aktuelle Objekt ('''self''') – nicht erhöht.

Daher können Sie für diese Klassenstruktur Folgendes schreiben:
<source lang="delphi">
class procedure TMyComplexClass.CreateOnly;
var
MyComplex: TMyComplexClass;
begin
MyComplex := TMyComplexClass.Create;
MyComplex.fSimple.DoSomething;
end;
</source>

Dieser Code verursacht kein Speicherleck, vorausgesetzt, dass die schwache Referenz richtig angewendet wird.

Ein weiteres Beispiel für die Verwendung von schwachen Referenzen ist dieses Codefragment aus der {{Delphi}}-RTL, das Teil der Klassendeklaration von [[lib_de:System.Classes.TComponent|TComponent]] ist:
<source lang="delphi">
type
TComponent = class(TPersistent, IInterface,
IInterfaceComponentReference)
private
[Weak] FOwner: TComponent;
</source>

Wenn Sie das Attribut '''weak''' in Code angeben, der von einem der {{Delphi}}-Desktop-Compiler compiliert wird, dann wird das Attribut ignoriert. Für DCC32 müssen Sie sicherstellen, dass Sie den korrekten Code im Destruktor eines "Eigentümer"-Objekts angeben, damit auch das Objekt, das der Eigentümer "besitzt", freigegeben wird. Der Aufruf von <code>Free</code> ist zulässig, obwohl damit ein anderer Effekt als in den mobilen {{Delphi}}-Compilern erreicht wird. Das Verhalten ist in den meisten Fällen korrekt.

<blockquote>'''Hinweis:''' Wenn für eine Instanz der Speicher freigegeben wird, werden alle aktiven '''[weak]'''-Referenzen auf '''nil''' gesetzt. Genau wie bei '''starken''' (normalen) Referenzen kann eine '''[weak]'''-Variable nur '''nil''' sein oder eine gültige Instanz referenzieren. Das ist der Hauptgrund, warum eine '''schwache''' Referenz vor dem Testen auf '''nil''' und dem Dereferenzieren einer '''starken''' Referenz zugewiesen werden soll. Durch Zuweisung zu einer starken Referenz kann die Instanz nicht vorzeitig freigegeben werden.
<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>

<blockquote>'''Hinweis:''' Eine '''[weak]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[weak]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[weak]''' '''var'''- oder '''out'''-Parameter übergeben werden. </blockquote>

==Das Attribut "Unsafe"==

Verwenden Sie die folgende Syntax, um das Attribut '''unsafe''' für eine Funktion festzulegen:

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

<blockquote>'''Warnung:''' '''[Unsafe]''' kann auch für Variablen (Member) und Parameter verwendet werden. Es sollte außerhalb der Unit [[lib_de:System|System]] nur in sehr seltenen Situationen verwendet werden. Es gilt als gefährlich, und die Verwendung von [Unsafe] wird nicht empfohlen, weil keine Referenzzählung generiert wird.</blockquote>

<blockquote>'''Hinweis:''' Eine '''[Unsafe]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[Unsafe]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[Unsafe]''' '''var'''- oder '''out'''-Parameter übergeben werden. </blockquote>

==Operatorüberladung für Klassen==

Ein interessanter Nebeneffekt der ARC-Speicherverwaltung ist, dass der Compiler die Lebensdauer temporärer von Funktionen zurückgegebener Objekte handhaben kann. Einen speziellen Fall stellen temporäre von Operatoren zurückgegebene Objekte dar. Ein ganz neues Feature der neuen {{Delphi}}-Compiler ist die Möglichkeit, Operatoren für Klassen zu definieren, mit derselben Syntax und demselben Modell, das für Records seit {{Delphi}} 2006 verfügbar ist.

<blockquote>'''Hinweis:''' Das folgende Codebeispiel funktioniert für die mobilen {{Delphi}}-Compiler (iOS), kann aber nicht von den {{Delphi}}-Desktop-Compilern compiliert werden. </blockquote>

Als Beispiel dient die folgende einfache Klasse:
<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>

==Siehe auch==

* [[Automatische Referenzzählung in C++|Automatische Referenzzählung in C++]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[DCCIOS32.EXE: Der Delphi-Compiler für den iOS-Simulator|DCCIOS32: Der Delphi-Compiler für den iOS-Simulator]]
* [[DCCIOSARM.EXE: Der Delphi-Compiler für 32-Bit-iOS-Geräte|DCCIOSARM: Der Delphi-Compiler für 32-Bit-iOS-Geräte]]
* [[DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte|DCCIOSARM64, Der Delphi-Compiler für 64-Bit-iOS-Geräte]]
* [https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]
* [[Referenzzählung einsetzen|Referenzzählung einsetzen]] (über Interfaces mit {{Delphi}}-Desktop-Compilern)

===Codebeispiel===

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

{{DEFAULTSORT:Automatische Referenzzahlung in mobilen Delphi-Compilern}}
[[Category:Delphi]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Automatic Reference Counting in Delphi Mobile Compilers]]
[[fr:Comptage automatique des références dans les compilateurs mobiles Delphi]]
[[ja:Delphi モバイルコンパイラでの自動参照カウント]]

Automatische Referenzzählung in mobilen Delphi-Compilern

2021-03-04T13:49:39Z

Alejandra.Barrientos: /* Automatische Referenzzählung */ Added templates

{{Parent|Gesichtspunkte für geräteübergreifende Delphi-Anwendungen}}

{{Delphi}}-Benutzer sind seit langem mit dem Begriff der automatischen Referenzzählung (ARC, Automatic Reference Counting) vertraut. In der Vergangenheit haben die {{Delphi}}-Desktop-Compiler (DCC32, DCC64, DCCOSX) ARC für Interfaces (in '''{{Delphi}} 3''' eingeführt), dynamische Arrays und Strings ('''AnsiString''' wurde in '''{{Delphi}} 2''' eingeführt) unterstützt. Jetzt wurde für die mobilen {{Delphi}}-Compiler die automatische Referenzzählung auch für Klassen eingeführt. In diesem Zusammenhang wurde auch der Begriff der '''schwachen Referenz''' eingeführt, um "Zyklen" gemeinsam mit einem anderen Feature zu verwalten: '''Operatorüberladung für Klassen'''.

Eine detaillierte Beschreibung der automatischen Referenzzählung finden Sie unter '''[https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]'''

==Automatische Referenzzählung==

Die '''Automatische Referenzzählung''' ist eine Möglichkeit zur Verwaltung der Objektlebensdauer ohne Freigabe des Objekts, wenn es nicht mehr benötigt wird. Ein gutes Beispiel dafür ist eine lokale Variable, die ein Objekt referenziert, das den Gültigkeitsbereich verlässt. Daran anschließend wird das Objekt automatisch freigegeben. Wie oben erwähnt, hat {{Delphi}} immer schon die Referenzzählung für Strings und durch Variablen vom Typ Interface referenzierte Objekte unterstützt. ARC bietet aber in den mobilen {{Delphi}} -Compilern eine gewisse Flexibilität, um Probleme, wie zirkuläre Referenzen, zu beheben, die mit Variablen vom Typ Interface schwer zu handhaben sind.

Ein weiterer in den neuen mobilen {{Delphi}}-Compilern eingeführter Begriff ist '''schwache Referenz'''. Damit werden auch einige Probleme mit zirkulären Referenzen behoben.

Das Speicherverwaltungsschema ist dasselbe für Apps, die für iOS-Geräte oder den iOS-Simulator compiliert werden:

* DCCIOSARM (der {{Delphi}}-Compiler für das 32-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOSARM64 (der {{Delphi}}-Compiler für das 64-Bit-iOS-Gerät) verfügt standardmäßig über ARC (Automatic Reference Counting).
* DCCIOS32 (der {{Delphi}}-Compiler für den iOS-Simulator) aktiviert ARC auch, obwohl DCCIOS32 auf der herkömmlichen Compiler-Architektur basiert.

{{Note| Diese neuen Features erscheinen im Quellcode von {{Variables|Product}} ausschließlich in den konditionalen <code>{$AUTOREFCOUNT}</code>-Blöcken in der RTL (z. B. in ''System.pas''). }}

==Änderungen des Programmierstils==

Da die neuen mobilen Compiler die automatische Referenzzählung unterstützen, kann beim Verweisen auf temporäre Objekte in einer Methode der Code deutlich vereinfacht werden. Die Speicherverwaltung wird vollständig ignoriert:

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

Im obigen Beispiel wird der Destruktor für das Objekt aufgerufen, wenn das Programm die '''end'''-Anweisung erreicht, das heißt, wenn die Variable <code>MyObj</code> den Gültigkeitsbereich verlässt.

Die Verwendung des Objekts kann auch vor dem Ende der Methode beendet werden. Dies kann durch Setzen der Variable auf '''nil''' erreicht werden:

<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>

In diesem Fall wird das Objekt vor dem Ende der Methode freigegeben und zwar genau dann, wenn die Variable auf '''nil''' gesetzt wird. Falls die <code>DoSomething</code>-Prozedur eine Exception auslöst, wird die '''nil'''-Zuweisungsanweisung übersprungen. Wird die Methode schließlich beendet, wird auch das Objekt freigegeben.

Da sich die Lebensdauer des Objekts nach dem Programmfluss richtet, können Sie den Referenzzähler eines Objekts (nur auf Plattformen mit Referenzzählung) mit der neuen Eigenschaft RefCount abfragen:
<source lang="delphi">
public
property RefCount: Integer read FRefCount;
</source>

<blockquote>'''Hinweis:''' Das Abfragen des Referenzzählers eines Objekts wird nicht empfohlen und sollte im Allgemeinen nicht verwendet werden. </blockquote>

===Geschwindigkeit von ineinandergreifenden Vorgängen===

Das Inkrementieren und Dekrementieren des Referenzzählers eines Objekts wird unter Verwendung von Thread-sicher Operationen durchgeführt, damit der Member der Referenzzählerinstanz Thread-sicher ist. Das bedeutet, dass die Referenzzähler-Instanzvariable korrekt durch '''Speicherbarrieren''' abgeschirmt ist, damit die Änderung von allen Threads sofort beachtet wird und sie keinen '''alten''' Wert ändern können.

<blockquote>'''Hinweis:''' Der ARC-Mechanismus schützt nicht vor Racebedingungen und Deadlocks. </blockquote>

===ARC und die Direktive {$AUTOREFCOUNT}===

Mit der Direktive <code>{$IFDEF AUTOREFCOUNT}</code> kann unter Umständen der beste Code für beide Szenarien erzielt werden: ARC und traditionell. <code>AUTOREFCOUNT</code> definiert Code, der die automatische Referenzzählung verwendet, wie z. B. Code für die mobilen {{Delphi}}-Compiler. Diese Direktive ist sehr wichtig und unterscheidet sich von <code>{$IFDEF NEXTGEN}</code> (der Direktive, die die neuen Sprach-Features der mobilen Compiler definiert). <code>AUTOREFCOUNT</code> könnte zukünftig nützlich werden, für den Fall, dass ARC auch für die {{Delphi}}-Desktop-Compiler implementiert wird.

==Die Methoden [[lib_de:System.TObject.Free|Free]] und [[lib_de:System.TObject.DisposeOf|DisposeOf]] unter ARC==

Bei Klassen sind {{Delphi}}-Entwickler ein anderes Programmiermuster auf Basis der Methode <code>Free</code> und geschützt durch den <code>try-finally</code>-Block gewöhnt.

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

Bei den {{Delphi}}-Desktop-Compilern ist <code>Free</code> eine Methode von <code>TObject</code>, die überprüft, ob die aktuelle Referenz nicht nil ist, und in diesem Fall den <code>Destroy</code>-Destruktor aufruft, der das Objekt nach Ausführung des entsprechenden Destruktorcodes aus dem Speicher entfernt.

In den neuen mobilen {{Delphi}}-Compilern wird der Aufruf von <code>Free</code> durch die Zuweisung von '''nil''' zu der Variable ersetzt. Falls es sich dabei um die letzte Referenz auf das Objekt handelt, wird es weiterhin nach dem Aufruf des Destruktors aus dem Speicher entfernt. Falls es noch bestehende Referenzen gibt, passiert nichts (außer einer Verringerung des Referenzzählers).

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

Ebenso setzt ein Aufruf wie der obige das Objekt auf '''nil''' und löst wieder die Objektfreigabe nur dann aus, wenn keine anderen Variablen das Objekt referenzieren. In den meisten Fällen ist das korrekt, weil keine Objekte freigegeben werden sollen, die in anderen Programmteilen verwendet werden. Andererseits gibt es Szenarien, in denen der Destruktorcode sofort ausgeführt werden muss, unabhängig davon, ob andere ausstehende Referenzen auf das Objekt vorhanden sind. Damit Entwickler die Ausführung des Destruktors (ohne Freigabe des eigentlichen Objekts aus dem Speicher) erzwingen können, führen die neuen Compiler ein Freigabemuster ein:

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

Dieser Aufruf führt den Destruktorcode auch dann aus, wenn ausstehende Referenzen vorhanden sind. Das Objekt wird hierbei in einen speziellen Zustand versetzt, damit der Destruktor bei weiteren Freigabeoperationen oder wenn der Referenzzähler null erreicht, und Speicher tatsächlich freigegeben wird, nicht nochmals aufgerufen wird. Dieser '''freigegebene''' Zustand (oder '''Zombie'''-Zustand) ist ziemlich wichtig, und Sie können diesen Objektzustand mit der Eigenschaft <code>[[lib_de:System.TObject.Disposed|Disposed]]</code> abfragen.

Wie weiter oben bereits erwähnt, funktionieren die klassischen '''try-finally'''-Blöcke, die mit den {{Delphi}}-Desktop-Compiler verwendet werden, auch mit den neuen Compilern, auch wenn sie nicht erforderlich sind.
In den meisten Fällen sollten Sie aber den '''dispose'''-Programmierstil verwenden (außer Sie möchten den Code für frühere Versionen von {{Delphi}} compilieren).

Im folgenden Beispiel wird derselbe Effekt wie mit dem klassischen Compiler erzielt, weil <code>DisposeOf</code> Free aufruft. Der Code führt wie erwartet den Destruktor aus (zur selben Zeit wie der klassische Compiler, aber der Speicher wird vom ARC-Mechanismus verwaltet).
<source lang="delphi">
var
MyObj: TMySimpleClass;
begin
MyObj := TMySimpleClass.Create;
try
MyObj.DoSomething;
finally
MyObj.DisposeOf;
end;
end;
</source>

<blockquote>'''Hinweis:''' Die Speicherung des Disposed-Flags wird durch ein Bit im Feld <code>FRefCount</code> erreicht, unter Berücksichtigung, dass die Obergrenze der Referenzen für ein Objekt bei 230 liegt. </blockquote>

==Erstellungs- und Freigabemethoden für TObject unter ARC==

Die folgenden Abschnitte enthalten eine Übersicht über die Methoden in der Klasse <code>TObject</code> in Bezug auf Erstellung und Freigabe.

Die Unterschiede zwischen <code>Free</code> und <code>DisposeOf</code> können auch unter Berücksichtigung des Zwecks betrachtet werden. <code>Free</code> wird verwendet, um eine bestimmte Referenz von einer Instanz zu trennen. Dabei ist eine Freigabe des Objekts oder von Speicher nicht impliziert. Im Gegensatz dazu teilt der Programmierer mit <code>DisposeOf</code> der Instanz explizit mit, "sich selbst zu bereinigen". Eine Speicherfreigabe ist dabei nicht notwendigerweise impliziert, <code>DisposeOf</code> führt eine explizite "Vorbereinigung" der Instanz durch. Anschließend ist die Instanz von der normalen Referenzzählungssemantik abhängig, die die Instanz dann schließlich freigeben kann.

==Schwache Referenzen==

Ein weiteres wichtiges Konzept für ARC ist die Rolle von '''schwachen Referenzen'''. Sie erstellen schwache Referenzen, indem Sie Referenzen mit dem Attribut <code>[weak]</code> versehen. Angenommen, zwei Objekte referenzieren sich gegenseitig über ein Feld, und eine externe Variable referenziert das erste Objekt. Der Referenzzähler des ersten Objekts ist 2 (die externe Variable und das zweite Objekt) und der Referenzzähler des zweiten Objekts ist 1. Wenn die externe Variable den Gültigkeitsbereich verlässt, haben beide Objekte einen Referenzzähler von 1, und sie verbleiben unendlich im Speicher.

Um diese Situation und viele ähnlichen Szenarien zu lösen, wird eine schwache Referenz verwendet, um die zirkulären Referenzen aufzuheben, wenn die letzte externe Referenz den Gültigkeitsbereich verlässt.

Eine '''schwache Referenz''' ist eine Referenz auf ein Objekt, dessen Referenzzähler nicht erhöht wird. Eine schwache Referenz wird mit dem Attribut <code>[weak]</code> deklariert, das von den mobilen {{Delphi}}-Compilern unterstützt wird.

Wenn in dem vorherigen Szenario die Referenz von dem zweiten Objekt auf das erste Objekt schwach ist, werden – sobald die externe Variable den Gültigkeitsbereich verlässt – beide Objekte freigegeben. Hier ist ein Beispiel für diese 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>

Im folgenden Codefragment erstellt der Konstruktor der komplexen Klasse ein Objekt der anderen Klasse:
<source lang="delphi">
constructor TMyComplexClass.Create;
begin
inherited Create;
FSimple := TMySimpleClass.Create;
FSimple.FOwnedBy := self;
end;
</source>

Weil das Feld <code>FOwnedBy</code> eine schwache Referenz ist, wird der Referenzzähler des Objekts, auf das es verweist – in diesem Fall auf das aktuelle Objekt ('''self''') – nicht erhöht.

Daher können Sie für diese Klassenstruktur Folgendes schreiben:
<source lang="delphi">
class procedure TMyComplexClass.CreateOnly;
var
MyComplex: TMyComplexClass;
begin
MyComplex := TMyComplexClass.Create;
MyComplex.fSimple.DoSomething;
end;
</source>

Dieser Code verursacht kein Speicherleck, vorausgesetzt, dass die schwache Referenz richtig angewendet wird.

Ein weiteres Beispiel für die Verwendung von schwachen Referenzen ist dieses Codefragment aus der {{Delphi}}-RTL, das Teil der Klassendeklaration von [[lib_de:System.Classes.TComponent|TComponent]] ist:
<source lang="delphi">
type
TComponent = class(TPersistent, IInterface,
IInterfaceComponentReference)
private
[Weak] FOwner: TComponent;
</source>

Wenn Sie das Attribut '''weak''' in Code angeben, der von einem der {{Delphi}}-Desktop-Compiler compiliert wird, dann wird das Attribut ignoriert. Für DCC32 müssen Sie sicherstellen, dass Sie den korrekten Code im Destruktor eines "Eigentümer"-Objekts angeben, damit auch das Objekt, das der Eigentümer "besitzt", freigegeben wird. Der Aufruf von <code>Free</code> ist zulässig, obwohl damit ein anderer Effekt als in den mobilen {{Delphi}}-Compilern erreicht wird. Das Verhalten ist in den meisten Fällen korrekt.

<blockquote>'''Hinweis:''' Wenn für eine Instanz der Speicher freigegeben wird, werden alle aktiven '''[weak]'''-Referenzen auf '''nil''' gesetzt. Genau wie bei '''starken''' (normalen) Referenzen kann eine '''[weak]'''-Variable nur '''nil''' sein oder eine gültige Instanz referenzieren. Das ist der Hauptgrund, warum eine '''schwache''' Referenz vor dem Testen auf '''nil''' und dem Dereferenzieren einer '''starken''' Referenz zugewiesen werden soll. Durch Zuweisung zu einer starken Referenz kann die Instanz nicht vorzeitig freigegeben werden.
<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>

<blockquote>'''Hinweis:''' Eine '''[weak]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[weak]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[weak]''' '''var'''- oder '''out'''-Parameter übergeben werden. </blockquote>

==Das Attribut "Unsafe"==

Verwenden Sie die folgende Syntax, um das Attribut '''unsafe''' für eine Funktion festzulegen:

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

<blockquote>'''Warnung:''' '''[Unsafe]''' kann auch für Variablen (Member) und Parameter verwendet werden. Es sollte außerhalb der Unit [[lib_de:System|System]] nur in sehr seltenen Situationen verwendet werden. Es gilt als gefährlich, und die Verwendung von [Unsafe] wird nicht empfohlen, weil keine Referenzzählung generiert wird.</blockquote>

<blockquote>'''Hinweis:''' Eine '''[Unsafe]'''-Variable kann nur einem '''var'''- oder '''out'''-Parameter übergeben werden, der auch mit '''[Unsafe]''' gekennzeichnet ist. Eine normale '''starke''' Referenz kann keinem '''[Unsafe]''' '''var'''- oder '''out'''-Parameter übergeben werden. </blockquote>

==Operatorüberladung für Klassen==

Ein interessanter Nebeneffekt der ARC-Speicherverwaltung ist, dass der Compiler die Lebensdauer temporärer von Funktionen zurückgegebener Objekte handhaben kann. Einen speziellen Fall stellen temporäre von Operatoren zurückgegebene Objekte dar. Ein ganz neues Feature der neuen {{Delphi}}-Compiler ist die Möglichkeit, Operatoren für Klassen zu definieren, mit derselben Syntax und demselben Modell, das für Records seit {{Delphi}} 2006 verfügbar ist.

<blockquote>'''Hinweis:''' Das folgende Codebeispiel funktioniert für die mobilen {{Delphi}}-Compiler (iOS), kann aber nicht von den {{Delphi}}-Desktop-Compilern compiliert werden. </blockquote>

Als Beispiel dient die folgende einfache Klasse:
<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>

==Siehe auch==

* [[Automatische Referenzzählung in C++|Automatische Referenzzählung in C++]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[DCCIOS32.EXE: Der Delphi-Compiler für den iOS-Simulator|DCCIOS32: Der Delphi-Compiler für den iOS-Simulator]]
* [[DCCIOSARM.EXE: Der Delphi-Compiler für 32-Bit-iOS-Geräte|DCCIOSARM: Der Delphi-Compiler für 32-Bit-iOS-Geräte]]
* [[DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte|DCCIOSARM64, Der Delphi-Compiler für 64-Bit-iOS-Geräte]]
* [https://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html Release Notes for ARC (Apple Computers)]
* [[Referenzzählung einsetzen|Referenzzählung einsetzen]] (über Interfaces mit {{Delphi}}-Desktop-Compilern)

===Codebeispiel===

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

{{DEFAULTSORT:Automatische Referenzzahlung in mobilen Delphi-Compilern}}
[[Category:Delphi]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Automatic Reference Counting in Delphi Mobile Compilers]]
[[fr:Comptage automatique des références dans les compilateurs mobiles Delphi]]
[[ja:Delphi モバイルコンパイラでの自動参照カウント]]

Debugger auf einem externen Computer installieren

2021-01-05T23:24:59Z

Alejandra.Barrientos: /* Remote-Debugger-Dateien werden auf dem externen Computer installiert */ RS-98408

{{Parent|Remote-Debuggen - Alte Verfahren|Remote-Debugging - Alte Verfahren}}

<blockquote>'''Hinweis:''' In diesem Thema wird die Installation des alten Remote-Debuggers beschrieben. 
'''Hinweis:''' Obwohl die herkömmliche Lösung für das Remote-Debugging weiterhin unterstützt wird, sollten Sie die neue [[Debuggen von geräteübergreifenden Anwendungen|Lösung für Remote- und geräteübergreifendes Debugging]] verwenden. Damit können Sie:
* Mit dem integrierten Debugger Remote- und geräteübergreifende Anwendungen debuggen.
* Mit dem [[Bereitstellungs-Manager|Bereitstellungs-Manager]] Ihre Anwendungen konfigurieren und bereitstellen.
</blockquote>

==Remote-Debugger-Dateien werden auf dem externen Computer installiert==

Auf einem Windows-PC werden beim [[PAServer: Die Platform Assistant Server-Anwendung|Installieren des '''Platform Assistant''']] die Remote-Debugger-Dateien standardmäßig in {{Path|{{InstallPath}}\PAServer}} installiert. Sie können aber auch ein anderes Installationsverzeichnis auswählen. Wenn Sie den "Platform Assistant" nicht installieren, müssen Sie allerdings die folgenden Remote-Debugger-Dateien auf den Remote-Computer kopieren:

* {{Path|rmtdbg{{PackageVersion}}.exe}}
* {{Path|bccide.dll}}
* {{Path|bordbk{{PackageVersion}}.dll}}
* {{Path|bordbk{{PackageVersion}}N.dll}}
* {{Path|comp32x.dll}}
* {{Path|dcc32{{PackageVersion}}.dll}} für ein Win32-System
* {{Path|dcc64{{PackageVersion}}.dll}} für ein Win64-System
* {{Path|dccosx{{PackageVersion}}.dll}} für ein OS X-System

:
::'''Hinweis:''' Auf dem Entwicklungs-PC werden die Remote-Debugger-Dateien in {{Path|{{InstallPath}}\bin}} bereitgestellt.

==So registrieren Sie den Remote-Debugger:==

Registrieren Sie auf dem Remote-Computer die Dateien {{Path|bordbk{{PackageVersion}}.dll}} und {{Path|bordbk{{PackageVersion}}.dll}} durch Ausführen des Registrierungs-Tools {{Path|regsvr32.exe}}. 

Unter Windows 7 geben Sie beispielsweise an der Eingabeaufforderung {{Code|C:\Windows\System32\regsvr32.exe bordbk{{PackageVersion}}.dll}} und dann

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

==Siehe auch==

* [[Überblick zum externen Debugger|Überblick zum externen Debugger]]
* [[Verbindung für das externe Debuggen einrichten|Verbindung für das externe Debuggen einrichten]]
* [[Dateien für das externe Debuggen vorbereiten|Dateien für das externe Debuggen vorbereiten]]
* [[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen (Neue Remote-Debugging-Lösung)]]

[[Category:Mit RAD Studio arbeiten]]
[[Category:Delphi]]
[[Category:C++]]

[[en:Installing a Debugger on a Remote Machine]]
[[fr:Installation d'un débogueur sur une machine distante]]
[[ja:リモートマシンへデバッガをインストールする]]

Verwenden eines HTTP-Clients

2020-12-10T18:41:50Z

Alejandra.Barrientos: /* Behandeln der HTTP-Basiszugriffsauthentifizierung */ RS-102658

{{Parent|Verwenden der RTL in geräteübergreifenden Anwendungen}}

Die RTL enthält zwei Komponenten, mit denen Sie HTTP-Anforderungen an Server senden und deren Antworten verwalten können:

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

: {{Note| Alternativ können Sie eine Instanz von [[lib_de:System.Net.HttpClient.THTTPClient|THTTPClient]] zum Verwalten Ihrer HTTP-Anforderungen verwenden.}}

==Konfigurieren Ihre Anwendung beim Entwurf==

===Erstellen eines HTTP-Clients===

Um einen HTTP-Client zu erstellen, mit dem Sie HTTP-Anforderungen senden können, ziehen Sie eine [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient|TNetHTTPClient]]-Komponente aus der '''[[Tool-Palette|Tool-Palette]]''' in ein Formular oder ein Datenmodul Ihrer Anwendung. Für die Komponente [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient|TNetHTTPClient]] ist keine Anfangskonfiguration erforderlich.

===Erstellen und Konfigurieren von HTTP-Anforderungen===

Sie müssen auch mindestens eine [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest|TNetHTTPRequest]]-Komponente in Ihr Formular oder Datenmodul aufnehmen.

Wenn Sie die neue HTTP-Anforderungs-Komponente eingefügt haben, doppelklicken Sie im '''[[Objektinspektor|Objektinspektor]]''' auf deren Eigenschaft [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Client|Client]], damit der Wert auf die zuvor hinzugefügte HTTP-Client-Komponente gesetzt wird.

Sie können eine beliebige Anzahl von Anforderungs-Komponenten verwenden. Wenn Sie mehrere unterschiedliche HTTP-Anforderungen senden müssen, wäre das geeignetere Vorgehen jedoch, nur eine HTTP-Anforderungs-Komponente zu verwenden und diese zur Laufzeit für jede Anforderung neu zu konfigurieren.

==Senden einer Anforderung und Behandeln der Antwort==

===Senden einer HTTP-Anforderung===

Um eine HTTP-Anforderung zu senden, müssen Sie mindestens Folgendes angeben:

* [[Wikipedia:Hypertext Transfer Protocol#Request methods|HTTP-Anforderungsmethoden]]
* Einen Ressourcen-URL

Die HTTP-Anforderungsmethode bestimmt die Aktion, die der Server für die Ressource an dem angegebenen URL ausführen soll, z. B. Senden der Daten der Ressource oder Aktualisieren der Ressource mit Daten aus der Anforderung.

Wie eine HTTP-Anforderung mit einer [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest|TNetHTTPRequest]]-Komponente gesendet wird, hängt von der HTTP-Anforderungsmethode ab, die Sie verwenden möchten.

: {{Note| Funktionen, die eine Anforderung senden, entweder [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Execute|Execute]] oder methodenspezifische Funktionen, sind alle blockierend. Das heißt, diese Funktionen kehren erst zurück, wenn eine Antwort vom Server vorliegt. Siehe [[#Verfolgen des Fortschritts beim Herunterladen der Antwortdaten|Verfolgen des Fortschritts beim Herunterladen der Antwortdaten]] weiter unten.}}

====Senden einer HTTP-Anforderung mit den HTTP-Anforderungsmethoden DELETE, GET, HEAD, OPTIONS oder TRACE====

Die folgenden HTTP-Anforderungsmethoden benötigen als Eingabedaten nur den Zielressourcen-URL:

* [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)]

Konfigurieren Sie Ihre Anforderung zuerst beim Entwurf, um eine HTTP-Anforderung mit einer dieser HTTP-Anforderungsmethoden zu senden:

# Konfigurieren Sie die Eigenschaft [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.URL|URL]] mit dem URL der Zielressource.
# Konfigurieren Sie die Eigenschaft [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.MethodString|MethodString]] mit dem Namen der HTTP-Anforderungsmethode, die Sie verwenden möchten.
#: {{Note| Namen von HTTP-Anforderungsmethoden [http://tools.ietf.org/html/rfc7230 berücksichtigen die Groß-/Kleinschreibung (EN)].}}

Rufen Sie dann '''[[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Execute|Execute]]''' auf, um Ihre Anforderung zu senden.

====Senden einer HTTP-Anforderung mit den HTTP-Anforderungsmethoden MERGE, PATCH oder PUT====

Die folgenden HTTP-Anforderungsmethoden benötigen außer dem Zielressourcen-URL Eingabedaten:

* [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)]

Um eine HTTP-Anforderung mit einer dieser HTTP-Anforderungsmethoden zu senden, rufen Sie die zugehörige Funktion auf (siehe die folgenden Tabelle). Geben Sie in Ihrem Aufruf den URL der Zielressource als erstes Argument und eine Instanz von [[lib_de:System.Classes.TStream|TStream]] als zweites Argument an.

{| class="wikitable"
|-
! HTTP-Anforderungsmethode
! TNetHTTPRequest-Funktion
|-
| PUT
| [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Put|Put]]
|-
| PATCH
| [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Patch|Patch]]
|-
| MERGE
| [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Merge|Merge]]
|-
| PATCH über PUT*
| [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.PatchAlternative|PatchAlternative]]
|-
| MERGE über PUT*
| [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.MergeAlternative|MergeAlternative]]
|}

: <nowiki>*</nowiki> Einige HTTP-Proxies unterstützen die neuesten Standard-HTTP-Anforderungsmethoden (wie PATCH) oder Nicht-Standard-HTTP-Anforderungsmethoden (wie MERGE) nicht. In diesen Fällen können Sie die HTTP-Anforderungsmethoden über andere HTTP-Anforderungsmethoden tarnen. Dazu müssen in der Anforderung Header enthalten sein, die die gewünschte HTTP-Anforderungsmethode angeben.

====Senden einer HTTP-Anforderung mit der HTTP-Anforderungsmethode POST====

Die HTTP-Anforderungsmethode [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.5 POST (EN)] benötigt außer dem Zielressourcen-URL Eingabedaten.

Um eine HTTP-Anforderung mit der HTTP-Anforderungsmethode POST zu senden, rufen Sie [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Post|Post]] auf. In Ihrem Aufruf müssen Sie den URL der Zielressource als erstes Argument angeben. Die anderen Argumente hängen davon ab, wie Sie die Eingabedaten für Ihre Anforderung zur Verfügung stellen möchten:

* Um den Inhalt einer lokalen Datei zu senden, geben Sie den lokalen Pfad zu dieser Datei als zweites Argument Ihres Aufrufs an.
* Um den Inhalt eines Streams zu senden, geben Sie Ihre Instanz von [[lib_de:System.Classes.TStream|TStream]] als zweites Argument Ihres Aufrufs an.
* Um Formulardaten zu senden, die entsprechend dem [http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.2 HTML 4-Standard (EN)] als [[Wikipedia:MIME#Multipart messages|mehrteilige MIME-Nachricht]] codiert sind, geben Sie Ihre Instanz von [[lib_de:System.Net.Mime.TMultipartFormData|TMultipartFormData]] als zweites Argument Ihres Aufrufs an.
* Um den Inhalt einer String-Liste zu senden, geben Sie Ihre Instanz von [[lib_de:System.Classes.TStrings|TStrings]] als zweites Argument Ihres Aufrufs an, und falls Ihre Strings nicht in UTF-8 codiert sind, geben Sie eine Instanz von [[lib_de:System.SysUtils.TEncoding|TEncoding]] als viertes Argument an. Zum Beispiel:

<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" />

===Behandeln einer HTTP-Antwort===

Wenn der Zielserver eine Antwort auf Ihre Anforderung sendet, wird das Ereignis [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestCompleted|OnRequestCompleted]] Ihrer HTTP-Anforderungs-Komponente ausgelöst. Definieren Sie eine [[Ereignisbehandlungsroutinen|Ereignisbehandlungsroutine]] für dieses Ereignis, um die Daten aus der Serverantwort zu lesen. Wenn während Ihrer Anforderung ein Fehler auftritt, wird stattdessen das Ereignis [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestError|OnRequestError]] Ihrer HTTP-Anforderungs-Komponente ausgelöst.

Die Ereignisbehandlungsroutine von [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestCompleted|OnRequestCompleted]] erhält zwei Parameter:

* {{Arg|Sender}} ist Ihre HTTP-Anforderungs-Komponente.
* {{Arg|AResponse}} ist ein Objekt, das das Interface [[lib_de:System.Net.HttpClient.IHTTPResponse|IHTTPResponse]] implementiert.

Sie können alle Antwortdaten aus {{Arg|AResponse}} abrufen:

* [[lib_de:System.Net.HttpClient.IHTTPResponse.Version|Version]] gibt die Version des HTTP-Protokolls an, das der Server verwendet.
* [[lib_de:System.Net.HttpClient.IHTTPResponse.StatusCode|StatusCode]] enthält den [[Wikipedia:List of HTTP status codes|Statuscode]] der Antwort, und [[lib_de:System.Net.HttpClient.IHTTPResponse.StatusText|StatusText]] enthält einen lesbaren Text, der den Status beschreibt, wie z. B. "OK" für den StatusCode 200.
* [[lib_de:System.Net.URLClient.IURLResponse.ContentAsString|ContentAsString]] enthält den Rumpf der Antwort als String. Sie können auch die Rohantwortdaten (einschließlich der Header und des Rumpfs) als Stream aus [[lib_de:System.Net.URLClient.IURLResponse.ContentStream|ContentStream]] lesen.
* Sie können die Antwort-Header mit [[lib_de:System.Net.URLClient.IURLResponse.Headers|Headers]], [[lib_de:System.Net.HttpClient.IHTTPResponse.HeaderValue|HeaderValue]], [[lib_de:System.Net.HttpClient.IHTTPResponse.ContainsHeader|ContainsHeader]] oder einer der folgenden Hilfseigenschaften lesen, die den Wert von allgemeinen HTTP-Antwort-Header-Feldern enthalten: [[lib_de:System.Net.HttpClient.IHTTPResponse.ContentCharSet|ContentCharSet]], [[lib_de:System.Net.HttpClient.IHTTPResponse.ContentEncoding|ContentEncoding]], [[lib_de:System.Net.HttpClient.IHTTPResponse.ContentLanguage|ContentLanguage]], [[lib_de:System.Net.HttpClient.IHTTPResponse.ContentLength|ContentLength]], [[lib_de:System.Net.HttpClient.IHTTPResponse.Date|Date]], [[lib_de:System.Net.HttpClient.IHTTPResponse.LastModified|LastModified]], [[lib_de:System.Net.URLClient.IURLResponse.MimeType|MimeType]].
* [[lib_de:System.Net.HttpClient.IHTTPResponse.Cookies|Cookies]] enthält die [[lib_de:System.Net.HttpClient.TCookies|Cookies]] der Serverantwort.

==Verwalten von Cookies==

Mit der Eigenschaft [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.AllowCookies|AllowCookies]] der HTTP-Client-Komponente können Sie festlegen, ob Sie die vom Server in der Antwort gesendeten Cookies akzeptieren möchten.
Wenn [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.AllowCookies|AllowCookies]] {{True}} ist, speichert der HTTP-Client die empfangenen Cookies in seinem [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.CookieManager|CookieManager]].

:{{Note| Der HTTP-Client fügt seine [[lib_de:System.Net.HttpClient.TCookieManager.Cookies|vorhandenen Cookies]] immer der Anforderung hinzu, unabhängig vom Wert von [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.AllowCookies|AllowCookies]].}}

==Behandeln von Umleitungen==

Mit der Eigenschaft [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.HandleRedirects|HandleRedirects]] steuern Sie, wie die HTTP-Client-Komponente Umleitungen behandelt. Der Standardwert ist {{True}}, was bedeutet, dass die HTTP-Client-Komponente Umleitungen automatisch folgt.

Mit der Eigenschaft [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.MaxRedirects|MaxRedirects]] der HTTP-Client-Komponente geben Sie die maximale Anzahl an Umleitungen an, der die Komponente folgen darf. Wenn die HTTP-Client-Komponente die angegebene Anzahl an maximalen Umleitungen erreicht, löst sie eine Exception mit dem Typ [[lib_de:System.Net.HttpClient.ENetHTTPRequestException|ENetHTTPRequestException]] aus.

==Behandeln des Herunterladens der Antwortdaten==

Beim Herunterladen der Antwort auf Ihre Anforderung durch den HTTP-Client wird laufend das Ereignis [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]] Ihrer HTTP-Anforderung ausgelöst. Sehen Sie eine Ereignisbehandlungsroutine für [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]] vor, um den Fortschritt beim Herunterladen der Antwortdaten zu verfolgen. Ihre Ereignisbehandlungsroutine erhält die folgenden Parameter:

* {{Arg|Sender}} ist Ihr HTTP-Anforderungsobjekt.
* {{Arg|AContentLength}} ist die erwartete Länge der Antwortdaten in Byte.
* {{Arg|AReadCount}} ist die Länge der Antwortdaten in Byte, die der HTTP-Client bisher heruntergeladen hat.
* {{Arg|Abort}} ist ein boolescher Parameter zum Abbrechen des Herunterladens.

Am Ende des Herunterladens wird [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]] zum letzten Mal ausgelöst, und {{Arg|AContentLength}} und {{Arg|AReadCount}} enthalten die gleichen Werte. Kurz danach wird [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnRequestCompleted|OnRequestCompleted]] ausgelöst.

===Verfolgen des Fortschritts beim Herunterladen der Antwortdaten===

Verwenden Sie zum Verfolgen des Fortschritts der heruntergeladenen Daten die Werte von {{Arg|AContentLength}} und {{Arg|AReadCount}} in der Ereignisbehandlungsroutine [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]].
In folgendem Beispiel wird der Prozentsatz der heruntergeladenen Daten berechnet:

<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" />

===Abbrechen des Herunterladens der Antwortdaten===

Ändern Sie in der Ereignisbehandlungsroutine [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnReceiveData|OnReceiveData]] den Wert von {{Arg|Abort}} in {{True}}, um das Herunterladen der Antwortdaten abzubrechen.

==Senden einer Anforderung mit benutzerdefinierten Headern==

Sie können sowohl mit der HTTP-Client-Komponente als auch mit der HTTP-Anforderungs-Komponente benutzerdefinierte Header festlegen.
Folgende benutzerdefinierte Header können Sie festlegen:

* In der HTTP-Client-Komponente:
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.Accept|Accept]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.AcceptCharSet|AcceptCharSet]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.AcceptEncoding|AcceptEncoding]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.AcceptLanguage|AcceptLanguage]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.ContentType|ContentType]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.UserAgent|UserAgent]]

* In der HTTP-Anforderungs-Komponente:
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Accept|Accept]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.AcceptCharSet|AcceptCharSet]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.AcceptEncoding|AcceptEncoding]]
** [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.AcceptLanguage|AcceptLanguage]]

Beim [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Execute|Ausführen]] einer Anforderung kombiniert die Methode [[lib_de:System.Net.HttpClient.THTTPClient.Execute|THTTPClient.Execute]] des HTTP-Frameworks die benutzerdefinierten Header aus der HTTP-Client-Komponente und aus der entsprechenden HTTP-Anforderungs-Komponente und fügt diese Header der endgültigen Anforderung hinzu.

==Behandeln von sicheren Verbindungen==

Die HTTP-Client-Komponente unterstützt sichere Verbindungen (HTTPS). Das HTTP-Framework behandelt jede auftretende Zertifikatsanforderung automatisch und löst bei Bedarf das passende Ereignis aus:

* [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnNeedClientCertificate|OnNeedClientCertificate]], wenn ein Server ein Zertifikat vom Client anfordert.
* [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnValidateServerCertificate|OnValidateServerCertificate]], wenn der Server ein ungültiges Zertifikat bereitstellt.

Weitere Informationen über die Behandlung von Zertifikaten finden Sie in den Abschnitten [[Verwenden eines HTTP-Clients#Behandeln serverseitiger Zertifikate|Behandeln serverseitiger Zertifikate]] und [[Verwenden eines HTTP-Clients#Behandeln clientseitiger Zertifikate|Behandeln clientseitiger Zertifikate]].

==Behandeln von Authentifizierung und Zertifikaten==

===Behandeln der HTTP-Basiszugriffsauthentifizierung===

Wenn Sie eine HTTP-Anforderung an einen Server senden, der eine [[Wikipedia:Basic access authentication|HTTP-Basiszugriffsauthentifizierung]] erfordert, wird das Ereignis [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.OnAuthEvent|OnAuthEvent]] Ihres HTTP-Client-Objekts ausgelöst. Um Ihre Anmeldedaten für den Zugriff zu übermitteln, erstellen Sie eine Ereignisbehandlungsroutine für dieses Ereignis. Falls der Wert des zweiten Parameters, den die Ereignisbehandlungsroutine erhält ({{Arg|AnAuthTarget}}), [[lib_de:System.Net.URLClient.TAuthTargetType|TAuthTargetType.Server]] ist, füllen Sie die Variablen {{Arg|AUserName}} und {{Arg|APassword}} mit Ihrem Benutzernamen und Passwort für den Proxy. Zum Beispiel:
<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" />

Ihre Ereignisbehandlungsroutine erhält auch den Bereich des HTTP-Servers, für den eine Authentifizierung erforderlich ist ({{Arg|ARealm}}), und den Ziel-URL Ihrer Anforderung ({{Arg|AURL}}).

Um die HTTP-Authentifizierung abzubrechen, ändern Sie den Wert von {{Arg|AbortAuth}} in {{True}}.

===Senden einer Anforderung hinter einem Proxy===

Wenn Sie sich hinter einem [[Wikipedia:Proxy server|Proxy]] befinden, für den eine Authentifizierung erforderlich ist, können Sie die [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.ProxySettings|Proxy-Einstellungen]] festlegen, die für die Authentifizierung verwendet werden.
Das folgende Beispiel zeigt das Vorgehen dabei:

<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" />

Eine andere Möglichkeit zum Festlegen Ihrer Proxy-Einstellungen stellt ein URL-String mit den Proxy-bezogenen Informationen dar:

<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" />

Alternativ können Sie die Anmeldeinformationen für die Proxy-Authentifizierung in der Ereignisbehandlungsroutine [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.OnAuthEvent|OnAuthEvent]] angeben. Siehe den Abschnitt [[Verwenden eines HTTP-Clients#Behandeln der HTTP-Basiszugriffsauthentifizierung|Behandeln der HTTP-Basiszugriffsauthentifizierung]]. Der Wert von {{Code|AnAuthTarget}} muss {{Const|TAuthTargetType.Proxy}} anstelle von {{Const|TAuthTargetType.Server}} sein.

'''Behandeln von System-Proxy-Einstellungen mit einem HTTP-Client'''

In der folgenden Tabelle wird erklärt, wie der HTTP-Client die System-Proxy-Einstellungen auf verschiedenen Plattformen behandelt:

{|
|-
!Plattform
!Verhalten
|-
|
Windows
|
Der HTTP-Client verwendet die System-Proxy-Einstellungen. Sie können die System-Proxy-Einstellungen umgehen und alternative Proxy-Einstellungen für den HTTP-Client bereitstellen.

Um die System-Proxy-Einstellungen zu umgehen, erstellen Sie Proxy-Einstellungen für den HTTP-Client und geben {{Code|<nowiki>http://direct</nowiki>}} als URL an.
|-
|
OS X
|
Der HTTP-Client verwendet immer die System-Proxy-Einstellungen. Auch wenn Sie alternative Proxy-Einstellungen für den HTTP-Client bereitstellen, verwendet der HTTP-Client die System-Proxy-Einstellungen.
|-
|
iOS
|
Der HTTP-Client verwendet immer die System-Proxy-Einstellungen. Auch wenn Sie alternative Proxy-Einstellungen für den HTTP-Client bereitstellen, verwendet der HTTP-Client die System-Proxy-Einstellungen.
|-
|
Android
|
Der HTTP-Client verwendet die System-Proxy-Einstellungen. Sie können diese Einstellungen nicht umgehen, aber Sie können alternative Proxy-Einstellungen für den HTTP-Client bereitstellen.
|-
|
Linux
|
Der HTTP-Client verwendet die System-Proxy-Einstellungen. Sie können diese Einstellungen nicht umgehen, aber Sie können alternative Proxy-Einstellungen für den HTTP-Client bereitstellen.
|}

:{{Note| Wenn das System keine Proxy-Einstellungen festlegt (die Verbindung ist direkt), wird dies auch als "Einstellung" betrachtet. Auf iOS oder OS X ohne System-Proxy-Einstellungen können Sie beispielsweise keine Proxy-Einstellungen für den HTTP-Client bereitstellen. Die Einstellungen, die Sie bereitstellen, werden ignoriert, weil die Systemeinstellungen (die Einstellung "Kein Proxy") verwendet werden.}}

===Verwalten der Speicherung von Benutzer-Anmeldeinformationen===

Mit [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient|TNetHTTPClient]] können Sie Anmeldeinformationen für die HTTP- oder Proxy-Authentifizierung speichern. Gespeicherte [[lib_de:System.Net.URLClient.TCredentialsStorage.TCredential|Anmeldeinformationen]] können einen Benutzernamen, ein Passwort, einen [[lib_de:System.Net.URLClient.TAuthTargetType|Zieltyp für die Authentifizierung]], einen Bereich und einen Ziel-URL umfassen.

Das folgende Beispiel zeigt, wie mit [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.CredentialsStorage|TNetHTTPClient.CredentialsStorage]] Anmeldeinformationen gespeichert werden und dann mit diesen Anmeldeinformationen die Authentifizierung bei der Verbindung mit einem HTTP-Server, der eine grundlegende Authentifizierung erfordert, vorgenommen wird:

<ol><li>Erstellen der Anmeldeinformationen und Hinzufügen zu Ihrem Anmeldeinformationsspeicher:
<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>Verwenden der gespeicherten Anmeldeinformationen.

Sie können beispielsweise eine [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.OnAuthEvent|OnAuthEvent]]-Ereignisbehandlungsroutine schreiben, in der Sie:
* Mit [[lib_de:System.Net.URLClient.TCredentialsStorage.FindAccurateCredential|TCredentialsStorage.FindAccurateCredential]] nach Anmeldeinformationen suchen, die dem erforderlichen Authentifizierungstyp entsprechen ({{Code|TAuthTargetType.Server}}).
* Den Benutzernamen und das Passwort aus den entsprechenden Anmeldeinformationen für die Authentifizierung verwenden.
<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>

===Behandeln serverseitiger Zertifikate===

Wenn der Server ein SSL-Zertifikat bereitstellt, dieses Zertifikat aber ungültig ist, wird das Ereignis [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnValidateServerCertificate|OnValidateServerCertificate]] ausgelöst. Erstellen Sie eine Ereignisbehandlungsroutine für {{Code|OnValidateServerCertificate}}, damit Sie das Serverzertifikat ({{Arg|Certificate}}) überprüfen und festlegen können, ob Sie es akzeptieren oder nicht. Wenn Sie das Serverzertifikat akzeptieren, ändern Sie den Wert des Parameters {{Arg|Accept}} in {{True}}.

===Behandeln clientseitiger Zertifikate===

Wenn für den Server ein Client-Zertifikat erforderlich ist, wird das Ereignis [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.OnNeedClientCertificate|OnNeedClientCertificate]] ausgelöst. Erstellen Sie eine Ereignisbehandlungsroutine für {{Code|OnNeedClientCertificate}}, damit Sie Ihre Liste der Client-Zertifikate ({{Arg|ACertificateList}}) überprüfen und das Zertifikat festlegen können, das Sie an den Server senden möchten. Um ein Zertifikat aus der Liste zu senden, ändern Sie den Wert von {{Arg|AnIndex}} in den Index des Zielzertifikats in {{Arg|ACertificateList}}.

: {{Note| Wenn die HTTP-Methode der ersten Anforderung an einen Server, der ein clientseitiges Zertifikat erfordert, nicht HEAD oder GET (z. B. POST) ist, lautet der Statuscode der Serverantwort 413. Senden Sie immer zuerst eine HEAD- oder GET-Anforderung. Eine HEAD-Anforderung ist normalerweise vorzuziehen, weil weniger Daten übertragen werden.}}

==Anfragen asynchron machen==

Anfragen sind standardmäßig synchron. Während der Anfrage wird die Ausführung Ihrer Anwendung gestoppt, wenn Sie Ihre Anfrage starten, und wird nur fortgesetzt, wenn Sie eine Antwort vom Server oder der Anfrage-Zeitüberschreitung erhalten.

Wenn Sie möchten, dass Ihre Anfrage asynchron sind, damit die Anfragen nicht bei der Ausführung nicht gestoppt werden, müssen Sie die [[lib_de:System.Net.HttpClientComponent.TNetHTTPClient.Asynchronous|Asynchronous]]-Eigenschaft der Client-Komponente oder die [[lib_de:System.Net.HttpClientComponent.TNetHTTPRequest.Asynchronous|Asynchronous]]-Eigenschaft der Anfragekomponente aktivieren, abhängig von der Komponente, mit der Sie Ihre Anforderung ausführen möchten.

==Siehe auch==

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

* [[Verwenden von App-Tethering|Verwenden von App-Tethering]]
* [[Verwenden von Bluetooth|Verwenden von Bluetooth]]

[[Category:Geräteübergreifend]]
[[Category:AMMigrate]]

[[en:Using an HTTP Client]]
[[fr:Utilisation d'un client HTTP]]
[[ja:HTTP クライアントの使用]]