RAD Studio - Benutzerbeiträge [de]

Prozeduren und Funktionen (Delphi)

2026-08-31T19:49:57Z

Nicolas.rios: /* Eine Routine unter einem anderen Namen importieren */

{{Parent|Prozeduren und Funktionen - Index}}
Dieses Thema enthält Informationen zu folgenden Bereichen:

* Prozeduren und Funktionen deklarieren
* Aufrufkonventionen
* forward- und interface-Deklarationen
* external-Deklarationen
* Prozeduren und Funktionen überladen
* Lokale Deklarationen und verschachtelte Routinen

==Allgemeines zu Prozeduren und Funktionen==

Prozeduren und Funktionen, die zusammenfassend auch als ''Routinen'' bezeichnet werden, sind abgeschlossene Anweisungsblöcke, die von unterschiedlichen Positionen in einem Programm aufgerufen werden können. Eine ''Funktion'' ist eine Routine, die nach Ausführung einen Wert zurückgibt. Eine ''Prozedur'' ist eine Routine, die keinen Wert zurückgibt.

Funktionsaufrufe können auch in Zuweisungen und Operationen eingesetzt werden, da sie einen Wert zurückgeben. Zum Beispiel:

<source lang="delphi">
I := SomeFunction(X);</source>

Diese Anweisung ruft die Funktion SomeFunction auf und weist das Ergebnis der Variable I zu. Funktionsaufrufe dürfen nicht auf der linken Seite einer Zuweisungsanweisung stehen.

Prozeduraufrufe können als eigenständige Anweisungen eingesetzt werden. Bei Funktionsaufrufen ist dies ebenfalls möglich, wenn die erweiterte Syntax ({$X+}) aktiviert ist. Zum Beispiel:

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

Diese Anweisung ruft die Routine DoSomething auf. Ist DoSomething eine Funktion, wird der Rückgabewert verworfen.

Prozeduren und Funktionen können auch rekursiv aufgerufen werden.

==Prozeduren und Funktionen deklarieren==

Beim Deklarieren einer Prozedur oder Funktion geben Sie den Namen, die Anzahl und den Typ der Parameter sowie bei Funktionen den Typ des Rückgabewertes an. Dieser Teil der Deklaration wird auch Prototyp, Kopf oder Header genannt. Anschließend schreiben Sie den Code, der beim Aufrufen der Prozedur oder Funktion ausgeführt werden soll. Dieser Teil wird auch als Rumpf oder Block der Routine bezeichnet.

===Prozedurdeklarationen===

Eine Prozedurdeklaration hat folgende Form:

<source lang="delphi">
procedure procedureName(parameterList); directives;
localDeclarations;
begin
statements
end;</source>

''Prozedurname'' ist ein beliebiger gültiger Bezeichner, ''Anweisungen'' eine Folge von Anweisungen, die beim Aufruf der Prozedur ausgeführt werden. ''(Parameterliste)'', ''Direktiven'' und ''LokaleDeklarationen'' sind optional.

Ein Beispiel für eine Prozedurdeklaration:

<source lang="delphi">
procedure NumString(N: Integer; var S: string);
var
V: Integer;
begin
V := Abs(N);
S := '';
repeat
S := Chr(V mod 10 + Ord('0')) + S;
V := V div 10;
until V = 0;
if N < 0 then S := '-' + S;
end;</source>

Nach dieser Deklaration können Sie die Prozedur NumString folgendermaßen aufrufen:

<source lang="delphi">
NumString(17, MyString);</source>

Dieser Prozeduraufruf weist der Variable MyString (es muss sich um eine Variable vom Typ '''String''' handeln) den Wert 17 zu.

Im Anweisungsblock einer Prozedur können Sie Variablen und Bezeichner verwenden, die im Abschnitt ''localDeclarations'' der Prozedur deklariert wurden. Sie können außerdem die Parameternamen aus der Parameterliste (N und S in diesem Beispiel) verwenden. Die Parameterliste definiert eine Gruppe lokaler Variablen. Aus diesem Grund dürfen im Abschnitt ''localDeclarations'' keine gleichlautenden Parameternamen auftauchen. Natürlich können Sie auch alle Bezeichner verwenden, in deren Gültigkeitsbereich die Prozedur deklariert wurde.

===Funktionsdeklarationen===

Eine Funktionsdeklaration entspricht einer Prozedurdeklaration, definiert aber zusätzlich einen Rückgabetyp und einen Rückgabewert. Funktionsdeklarationen haben folgende Form:

<source lang="delphi">
function functionName(parameterList): returnType; directives;
localDeclarations;
begin
statements
end;</source>

''Funktionsname'' ist ein beliebiger gültiger Bezeichner, ''Rückgabetyp'' ein Typbezeichner, ''Anweisungen'' enthält die Folge von Anweisungen, die beim Aufruf der Funktion ausgeführt werden sollen. ''(Parameterliste)'', ''Direktiven;'' und ''LokaleDeklarationen;'' sind optional.

Für den Anweisungsblock der Funktion gelten die Regeln, die bereits für Prozeduren erläutert wurden. Sie können Variablen und andere Bezeichner, die im Abschnitt ''localDeclarations'' der Funktion deklariert wurden, die Parameternamen aus der Parameterliste und alle Bezeichner verwenden, in deren Gültigkeitsbereich die Funktion deklariert wurde. Der Funktionsname dient als spezielle Variable, die wie die vordefinierte Variable '''Result''' den Rückgabewert der Funktion enthält.

Wenn die erweiterte Syntax ({$X+}) aktiviert ist, wird '''Result''' implizit in jeder Funktion deklariert. Sie dürfen diese Variable deshalb nicht manuell deklarieren.

Zum Beispiel:

<source lang="delphi">
function WF: Integer;
begin
WF := 17;
end;</source>

Diese Deklaration definiert eine Konstantenfunktion namens WF, die keine Parameter entgegennimmt und immer den Integerwert 17 zurückgibt. Diese Deklaration ist zur folgenden äquivalent:

<source lang="delphi">
function WF: Integer;
begin
Result := 17;
end;</source>

Das nächste Beispiel enthält eine etwas komplexere Funktionsdeklaration:

<source lang="delphi">
function Max(A: array of Real; N: Integer): Real;
var
X: Real;
I: Integer;
begin
X := A[0];
for I := 1 to N - 1 do
if X < A[I] then X := A[I];
Max := X;
end;</source>

Sie können der Variable '''Result''' oder dem Funktionsnamen im Anweisungsblock mehrmals einen Wert zuweisen. Die zugewiesenen Werte müssen jedoch dem deklarierten Rückgabetyp entsprechen. Sobald die Ausführung der Funktion beendet wird, bildet der Wert, der zuletzt der Variable '''Result''' oder dem Funktionsnamen zugewiesen wurde, den Rückgabewert der Funktion. Zum Beispiel:

<source lang="delphi">
function Power(X: Real; Y: Integer): Real;
var
I: Integer;
begin
Result := 1.0;
I := Y;
while I > 0 do
begin
if Odd(I) then Result := Result * X;
I := I div 2;
X := Sqr(X);
end;
end;</source>

'''Result''' und der Funktionsname repräsentieren immer denselben Wert. Deshalb gibt die Deklaration

<source lang="delphi">
function MyFunction: Integer;
begin
MyFunction := 5;
Result := Result * 2;
MyFunction := Result + 1;
end;</source>

den Wert 11 zurück. '''Result''' ist jedoch nicht vollständig mit dem Funktionsnamen austauchbar. Wenn der Funktionsname auf der linken Seite einer Zuweisungsanweisung angegeben ist, verwendet der Compiler den Funktionsnamen als Variable (wie '''Result''') zur Aufzeichnung des Rückgabewerts. Taucht der Funktionsname dagegen an einer anderen Stelle im Anweisungsblock auf, wird er vom Compiler als rekursiver Aufruf der Funktion interpretiert. '''Result''' kann als Variable in Operationen eingesetzt werden, beispielsweise bei Typkonvertierungen, in Konstruktoren, Indizes und in Aufrufen anderer Routinen.

Wenn die Ausführung einer Funktion beendet wird, bevor '''Result''' oder dem Funktionsnamen ein Wert zugewiesen wurde, ist der Rückgabewert der Funktion nicht definiert.

==Aufrufkonventionen==

Wenn Sie eine Prozedur oder Funktion deklarieren, können Sie eine Aufrufkonvention mit einer der Direktiven '''register''', '''pascal''', '''cdecl''', '''stdcall''', '''safecall''' und '''winapi''' angeben. Zum Beispiel:

<source lang="delphi">
function MyFunction(X, Y: Real): Real; cdecl;</source>

Aufrufkonventionen bestimmen die Reihenfolge, in der Parameter an die Routine übergeben werden. Sie beeinflussen außerdem das Entfernen der Parameter vom Stack, den Einsatz der Register zur Übergabe von Parametern sowie die Fehler- und Exception-Behandlung. Die Standard-Aufrufkonvention ist '''register'''.

* Für die Konventionen '''register''' und '''pascal''' ist die Auswertungsreihenfolge nicht definiert.
* Die Konventionen '''cdecl''', '''stdcall''' und '''safecall''' übergeben die Parameter von rechts nach links.
* Bei allen Konventionen mit Ausnahme von '''cdecl''' entfernt die Prozedur bzw. Funktion die Parameter vom Stack, sobald die Steuerung zurückgegeben wird. Bei der Konvention '''cdecl''' entfernt die aufrufende Routine die Parameter vom Stack, sobald sie wieder die Steuerung erhält.
* Die Konvention '''register''' verwendet bis zu drei CPU-Register zur Übergabe der Parameter, alle anderen Konventionen übergeben die Parameter an den Stack.
* Die Konvention '''safecall''' implementiert "Exception-Firewalls" und in Win32 die prozessübergreifende COM-Fehlerbenachrichtigung.
* '''winapi''' ist eigentlich keine Aufrufkonvention. '''winapi''' legt fest, dass die standardmäßige Aufrufkonvention der Plattform verwendet wird. Unter Win32 entspricht '''winapi''' der Aufrufkonvention '''stdcall'''.

Die folgende Tabelle beschreibt die Aufrufkonventionen.

''' Aufrufkonventionen '''

{| border="1" frame="hsides" rules="rows"
|-
! ''' Direktive ''' 
! ''' Parameterreihenfolge ''' 
! ''' Bereinigung ''' 
! ''' Parameterübergabe in Registern? '''
|-
| style="text-align: left; vertical-align: top;" |
'''register''' 
| style="text-align: left; vertical-align: top;" |
Undefiniert 
| style="text-align: left; vertical-align: top;" |
Routine 
| style="text-align: left; vertical-align: top;" |
Ja
|-
| style="text-align: left; vertical-align: top;" |
'''pascal'''
| style="text-align: left; vertical-align: top;" |
Undefiniert
| style="text-align: left; vertical-align: top;" |
Routine
| style="text-align: left; vertical-align: top;" |
Nein
|-
| style="text-align: left; vertical-align: top;" |
'''cdecl'''
| style="text-align: left; vertical-align: top;" |
Von rechts nach links
| style="text-align: left; vertical-align: top;" |
Aufrufender
| style="text-align: left; vertical-align: top;" |
Nein
|-
| style="text-align: left; vertical-align: top;" |
'''stdcall'''
| style="text-align: left; vertical-align: top;" |
Von rechts nach links
| style="text-align: left; vertical-align: top;" |
Routine
| style="text-align: left; vertical-align: top;" |
Nein
|-
| style="text-align: left; vertical-align: top;" |
'''safecall'''
| style="text-align: left; vertical-align: top;" |
Von rechts nach links
| style="text-align: left; vertical-align: top;" |
Routine
| style="text-align: left; vertical-align: top;" |
Nein
|}

Die weitaus effizienteste Aufrufkonvention ist '''register''', da hier meistens kein Stack-Frame für die Parameter angelegt werden muss. (Zugriffsmethoden für Eigenschaften, die als '''published''' deklariert sind, müssen '''register''' verwenden.) Die Konvention '''cdecl''' ist hilfreich, wenn Funktionen in gemeinsam benutzten Bibliotheken aufgerufen werden, die in C oder C++ geschrieben wurden. Die Konventionen '''stdcall''' und '''safecall''' sollten für Aufrufe von externem Quelltext benutzt werden. In Win32 verwenden die Betriebssystem-APIs die Konventionen '''stdcall''' und '''safecall'''. Andere Betriebssysteme verwenden normalerweise die Konvention '''cdecl''' (beachten Sie, dass '''stdcall''' effizienter ist als '''cdecl''').

Die Konvention '''safecall''' muss bei der Deklaration von Methoden für duale Interfaces verwendet werden. Die Konvention '''pascal''' gewährleistet die Abwärtskompatibilität.

Die Direktiven '''near''', '''far''' und '''export''' beziehen sich auf die Aufrufkonventionen bei der Programmierung für 16-Bit-Windows-Umgebungen. Sie haben keine Auswirkungen auf die aktuellen Plattformziele und werden nur aus Gründen der Abwärtskompatibilität beibehalten.

==forward- und interface-Deklarationen==

Die Direktive '''forward''' in einer Prozedur- oder Funktionsdeklaration wird durch einen Rumpf mit Anweisungen und lokalen Variablendeklarationen ersetzt. Zum Beispiel:

<source lang="delphi">
function Calculate(X, Y: Integer): Real; forward;</source>

Die hier deklarierte Funktion Calculate enthält die Direktive '''forward'''. An einer anderen Position muss der Rumpf der Routine deklariert werden. Diese definierende Deklaration für Calculate kann beispielsweise folgendermaßen aussehen:

<source lang="delphi">
function Calculate;
... { declarations }
begin
... { statement block }
end;</source>

Grundsätzlich muss eine definierende Deklaration die Parameterliste oder den Rückgabetyp der Routine nicht wiederholen. Werden diese Angaben jedoch wiederholt, müssen sie denen in der '''forward'''-Deklaration exakt entsprechen. Standardparameter in der definierenden Deklaration können aber weggelassen werden. Wenn die '''forward'''-Deklaration eine überladene Prozedur oder Funktion angibt, muss die Parameterliste in der definierenden Deklaration wiederholt werden.

Eine '''forward'''-Deklaration und die dazugehörige definierende Deklaration müssen in demselben '''type'''-Deklarationsabschnitt enthalten sein. Sie können also keinen neuen Abschnitt (z. B. einen '''var'''- oder '''const'''-Abschnitt) zwischen der forward-Deklaration und der definierenden Deklaration einfügen. Die definierende Deklaration kann eine '''external'''- oder '''assembler'''-Deklaration sein, es darf sich jedoch nicht um eine weitere '''forward'''-Deklaration handeln.

Mit einer '''forward'''-Deklaration kann der Gültigkeitsbereich eines Prozedur- oder Funktionsbezeichners auf einen früheren Punkt im Quelltext ausgedehnt werden. Andere Prozeduren und Funktionen können also die mit '''forward''' deklarierte Routine aufrufen, bevor sie tatsächlich definiert wurde. '''forward'''-Deklarationen bieten nicht nur mehr Flexibilität bei der Programmierung, sie werden auch gelegentlich für Rekursionen benötigt.

Die Direktive '''forward''' hat keine Auswirkung im '''interface'''-Abschnitt einer Unit. Prozedur- und Funktions-Header im '''interface'''-Abschnitt verhalten sich wie '''forward'''-Deklarationen. Die zugehörigen definierenden Deklarationen müssen in den '''implementation'''-Abschnitt eingefügt werden. Eine im '''interface'''-Abschnitt deklarierte Routine ist von jeder Position in der Unit und für jede Unit und jedes Programm verfügbar, die bzw. das die Unit mit der Deklaration einbindet.

==external-Deklarationen==

Die Direktive '''external''' ersetzt den Anweisungsblock in einer Prozedur- oder Funktionsdeklaration. Sie ermöglicht das Aufrufen von Routinen, die unabhängig vom aktuellen Programm compiliert wurden. Externe Routinen stammen aus Objektdateien oder aus dynamisch ladbaren Bibliotheken.

Verwenden Sie zum Importieren einer C-Funktion, die eine variable Anzahl von Parametern übernimmt, die Direktive '''varargs'''. Zum Beispiel:

<source lang="delphi">
function printf(Format: PChar): Integer; cdecl; varargs;</source>

Die Direktive '''varargs''' kann nur bei externen Routinen und zusammen mit der Aufrufkonvention '''cdecl''' eingesetzt werden.

===Objektdateien linken===

Um Routinen aus einer separat compilierten Objektdatei aufrufen zu können, müssen Sie die Objektdatei mit der Compiler-Direktive $L (oder $LINK) zur gewünschten Anwendung linken. Zum Beispiel:

<source lang="delphi">
{$L BLOCK.OBJ}</source>

Diese Anweisung linkt die Datei BLOCK.OBJ zu dem Programm bzw. der Unit, in der die Anweisung verwendet wird. Anschließend müssen Sie die aufzurufenden Funktionen und Prozeduren deklarieren:

<source lang="delphi">
procedure MoveWord(var Source, Dest; Count: Integer); external;
procedure FillWord(var Dest; Data: Integer; Count: Integer); external;</source>

Jetzt können Sie die Routinen MoveWord und FillWord in BLOCK.OBJ aufrufen.

In Win32 werden Deklarationen wie die oben gezeigten häufig verwendet, um auf externe Assembler-Routinen zuzugreifen. Assembler-Routinen können auch direkt in {{Delphi}}-Quelltext eingefügt werden.

===Funktionen aus Bibliotheken importieren===

Mit einer Direktive der Form

: {{Code|external StringKonstante;}}

können Sie Routinen aus einer dynamisch ladbaren Bibliothek (.DLL-Datei) importieren. Die Anweisung muss an das Ende des Prozedur- bzw. Funktions-Headers angefügt werden. {{Code|stringConstant}} gibt die Bibliotheksdatei in einfachen Anführungszeichen (Hochkommas) an. Ein Beispiel:

<source lang="delphi">
function SomeFunction(S: string): string; external 'strlib.dll';</source>

Mit dieser Anweisung wird in Win32 die Funktion {{Code|SomeFunction}} aus der Datei {{Path|strlib.dll}} importiert.

====Interne und externe Linker verwenden====

Der Delphi-Compiler interpretiert "External" unterschiedlich, je nachdem, ob der Compiler einen externen Linker verwendet nicht.

1. Von Delphi unterstützte Plattformen können in die zwei folgenden Gruppen unterteilt werden:

*Der Compiler verwendet den eigenen internen Linker.

*Der Compiler verwendet einen externen Linker.

{| border="1" frame="hsides" rules="rows"
|-
| style="text-align: left; vertical-align: top;" |
Verwenden des '''internen''' Linkers 
| style="text-align: left; vertical-align: top;" |
WIN32 und WIN64
|-
| style="text-align: left; vertical-align: top;" |
Verwenden eines '''externen''' Linkers 
| style="text-align: left; vertical-align: top;" |
iOS-Device, Android, Linux, macOS64 
|}

2. Auf Plattformen, auf denen Delphi einen internen Linker verwendet, gibt {{Code|external <StringKonstante>}} an, dass sich die Funktion/Prozedur in einer DLL befindet.

Auf diesen Plattformen geht Delphi davon aus, dass das Symbol aus einer {{Code|.dll}} importiert wird. Beim Linken wird keine Validierung vorgenommen. Delphi generiert ein Bild mit einer Referenz auf das Symbol/die Bibliothek. Wenn sich das Symbol nicht in dieser Bibliothek befindet, werden Sie bei der Ausführung darauf hingewiesen.

3. Auf Plattformen, auf denen Delphi einen externen Linker verwendet, beispielsweise wenn die iOSDevice64-Plattform das Ziel ist, wird der in {{Code|external <StringKonstante>}} angegebene Bezeichner an den externen Linker übergeben.

Der Delphi-Compiler übergibt {{Code|<StringKonstante>}} an ld.exe. Wenn der Compiler die Bibliothek nicht findet, wird die folgende Fehlermeldung angezeigt: {{Code|Fehler: E2597 ld: Datei nicht gefunden: <StringKonstante>}}.

====Funktionen aus Objektdateien importieren (nur externer Linker)====

Wenn ein externer Linker verwendet wird, können Sie die Verwendung der Compiler-Direktive $L (oder $LINK) unterdrücken, indem Sie die Objektdatei mit der external-Direktive angeben. Zum Beispiel:

<source lang="delphi">
procedure FunctionName; cdecl; external object 'ObjectFile.o' name '_FunctionName';</source>

====Funktionen aus Frameworks importieren====

Sie können keine Routinen aus einem externen Framework importieren. Zum Beispiel:

<source lang="delphi">
Function foo: Integer; external framework '<framework name>'</source>

Dies gilt nur für iOS64, macOS64 ARM und macOS64.

====Eine Routine unter einem anderen Namen importieren====

Sie können Routinen unter einem anderen als dem in der Bibliothek verwendeten Namen importieren, indem Sie den Originalnamen in der '''external'''-Direktive angeben:

: {{Code|external <StringKonstante1> name <StringKonstante2>;}}

{{Code|<StringKonstante1>}} gibt den Namen der Bibliotheksdatei an und {{Code|<StringKonstante2>}} ist der Originalname der Routine.

Die folgende Deklaration importiert eine Funktion aus {{Path|user32.dll}} (Bestandteil der Windows-API):

<source lang="delphi">
function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer; stdcall; external 'user32.dll' name 'MessageBoxW';</source>

Der Originalname der Funktion lautet {{Code|MessageBoxW}}, sie wird jedoch unter dem Namen {{Code|MessageBox}} importiert.

Stellen Sie in Ihrer Import-Deklaration sicher, dass die Schreibweise und der Fall des Routinenamens übereinstimmen. Beim Aufruf der importierten Routine wird die Groß-/Kleinschreibung nicht mehr berücksichtigt.

====Eine Routine über den Index importieren====

Sie können die zu importierende Routine auch über eine Nummer angeben:

: {{Code|external <StringKonstante> Index <IntegerKonstante>;}}

{{Code|<IntegerKonstante>}} ist der Index der Routine in der Exporttabelle.

====Laden der Bibliothek verzögern====

Um das Laden der Bibliothek, die die Funktion enthält, bis zu dem Moment zu verzögern, an dem die Funktion wirklich benötigt wird, hängen Sie die Direktive {{Code|delayed}} an die importierte Funktion an:

<source lang="delphi">
function ExternalMethod(const SomeString: PChar): Integer; stdcall; external 'cstyle.dll' delayed;</source>

{{Code|delayed}} stellt sicher, dass die Bibliothek, die die importierte Funktion enthält, nicht beim Start der Anwendung geladen wird, sondern erst, wenn die Funktion aufgerufen wird. Weitere Informationen zu diesem Thema finden Sie unter [[Bibliotheken und Packages (Delphi)#Verzögertes Laden|Bibliotheken und Packages - Verzögertes Laden]].

====Abhängigkeit von der Bibliothek festlegen====

Wenn die Bibliothek, die die Zielroutine beinhaltet, von anderen Bibliotheken abhängt, verwenden Sie die {{Code|dependency}}-Direktive, um diese Abhängigkeit festzulegen.

Um die {{Code|dependency}}-Direktive zu verwenden, fügen Sie das Schlüsselwort {{Code|dependency}}, gefolgt von einer durch ein Komma getrennten String-Liste an. Jeder String muss einen Namen einer Bibliothek enthalten, die von einer externen Zielbibliothek abhängig ist:

: {{Code|external {{Placeholder|library}} dependency {{Placeholder|dependency1}}, {{Placeholder|dependency2}}, …}}

Die folgende Deklaration gibt an, dass {{Path|libmidas.a}} von der Standard-C++-Bibliothek abhängig ist:

<source lang="delphi">
function DllGetDataSnapClassObject(const [REF] CLSID, [REF] IID: TGUID; var Obj): HResult; cdecl; external 'libmidas.a' dependency 'stdc++';</source>

==Prozeduren und Funktionen überladen==

Sie können mehrere Routinen mit identischen Namen in demselben Gültigkeitsbereich deklarieren. Dieses Verfahren wird Überladen genannt. Überladene Routinen müssen mit der Direktive '''overload''' deklariert werden und unterschiedliche Parameterlisten haben. Beispiele:

<source lang="delphi">
function Divide(X, Y: Real): Real; overload;
begin
Result := X/Y;
end

function Divide(X, Y: Integer): Integer; overload;
begin
Result := X div Y;
end;</source>

Diese Deklarationen definieren zwei Funktionen namens Divide, die Parameter mit unterschiedlichen Typen entgegennehmen. Wenn Sie Divide aufrufen, ermittelt der Compiler die zu verwendende Funktion durch Prüfung des übergebenen Parametertyps. Divide(6.0, 3.0) ruft beispielsweise die erste Divide-Funktion auf, weil es sich bei den Argumenten um reelle Zahlen handelt.

Einer überladenen Routine können Parameter übergeben werden, deren Typ keinem der in den Routinendeklarationen verwendeten Typen entspricht. Voraussetzung dafür ist, dass diese Parameter zuweisungskompatibel mit den Parametern in mehr als einer Deklaration sind. Dieses Vorgehen wird meist beim Überladen von Routinen mit unterschiedlichen Integer- oder Real-Typen verwendet:

<source lang="delphi">
procedure Store(X: Longint); overload;
procedure Store(X: Shortint); overload;</source>

Wenn die Eindeutigkeit gewährleistet ist, ruft der Compiler in diesen Fällen die Routine auf, deren Parametertyp für den Wertebereich der tatsächlich übergebenen Parameter mindestens erforderlich ist. (Beachten Sie, dass konstante Ausdrücke, die reelle Zahlen sind, immer vom Typ '''Extended''' sind.)

Überladene Routinen müssen hinsichtlich der Anzahl der entgegengenommenen Parameter oder der Typen dieser Parameter eindeutig sein. Die folgenden beiden Deklarationen führen deshalb zu einem Fehler bei der Compilierung:

<source lang="delphi">
function Cap(S: string): string; overload;
...
procedure Cap(var Str: string); overload;
...</source>

Dagegen sind die Deklarationen

<source lang="delphi">
function Func(X: Real; Y: Integer): Real; overload;
...
function Func(X: Integer; Y: Real): Real; overload;
...</source>

zulässig.

Wird eine überladene Routine mit '''forward''' oder "interface" deklariert, muss die Parameterliste in der definierenden Deklaration der Routine wiederholt werden.

Der Compiler kann zwischen überladenen Funktionen unterscheiden, die '''AnsiString'''/'''PAnsiChar''', '''UnicodeString'''/'''PChar''' und '''WideString'''/'''PWideChar''' Parameter in derselben Parameterposition enthalten. String-Konstanten oder String-Literale, die in eine solche überladene Position übergeben werden, werden in den nativen String- oder Zeichentyp übersetzt, der '''UnicodeString'''/'''PChar''' lautet.

<source lang="delphi">
procedure test(const A: AnsiString); overload;
procedure test(const W: WideString); overload;
procedure test(const U: UnicodeString); overload;
procedure test(const PW: PWideChar); overload;
var
a: AnsiString;
b: WideString;
c: UnicodeString;
d: PWideChar;
e: string;
begin
a := 'a';
b := 'b';
c := 'c';
d := 'd';
e := 'e';
test(a); // calls AnsiString version
test(b); // calls WideString version
test(c); // calls UnicodeString version
test(d); // calls PWideChar version
test(e); // calls UnicodeString version
test('abc'); // calls UnicodeString version
test(AnsiString ('abc')); // calls AnsiString version
test(WideString('abc')); // calls WideString version
test(PWideChar('PWideChar')); // calls PWideChar version
end;</source>

Varianten können ebenfalls als Parameter in überladenen Funktionsdeklarationen verwendet werden. Eine Variante wird allgemeiner angesehen als ein beliebiger einfacher Typ. Exakte Typübereinstimmungen werden stets gegenüber Variantenübereinstimmungen bevorzugt. Wird eine Variante an eine solche überladene Position übergeben, und ist eine overload-Anweisung an dieser Parameterposition vorhanden, die eine Variante akzeptiert, wird diese als exakte Übereinstimmung für den Variant-Typ angesehen.

Dies kann bei Gleitkommatypen einige geringe Nebeneffekte bewirken. Gleitkommatypen werden anhand der Größe verglichen. Falls es keine genaue Übereinstimmung für die Gleitkommavariable gibt, die an den overload-Aufruf übergeben wird, aber ein varianter Parameter vorhanden ist, erhält die Variante den Vorzug gegenüber dem kleineren Gleitkommatyp.

Zum Beispiel:

<source lang="delphi">
procedure foo(i: integer); overload;
procedure foo(d: double); overload;
procedure foo(v: variant); overload;
var
v: variant;
begin
foo(1); // integer version
foo(v); // variant version
foo(1.2); // variant version (float literals -> extended precision)
end;</source>

Dieses Beispiel ruft die variant-Version von foo, nicht die double-Version auf, da die Konstante 1.2 implizit ein extended-Typ ist. extended ist jedoch keine genaue Übereinstimmung für double. '''Extended''' ist auch keine Übereinstimmung für '''Variant''', aber '''Variant''' wird als allgemeinerer Typ angesehen (während '''Double''' ein kleinerer Typ als '''Extended''' ist).

<source lang="delphi">
foo(Double(1.2));</source>

Diese Typumwandlung funktioniert nicht. Verwenden Sie stattdessen typisierte Konstanten:

<source lang="delphi">
const d: double = 1.2;
begin
foo(d);
end;</source>

Dieser Quelltext arbeitet korrekt und ruft die double-Version auf.

<source lang="delphi">
const s: single = 1.2;
begin
foo(s);
end;</source>

Dieser Quelltext funktioniert und ruft die double-Version von foo auf. '''Single''' passt besser zu double als '''variant'''.

Bei der Deklaration von überladenen Routinen besteht die beste Möglichkeit zur Vermeidung einer Gleitkommapromotion zu Variant darin, eine Version ihrer überladenen Funktion für jeden Gleitkommatyp ('''Single''', '''Double''', '''Extended''') zusammen mit der '''Variant'''-Version zu deklarieren.

Bei Verwendung von Standardparametern in überladenen Routinen müssen Sie mehrdeutige Parametersignaturen vermeiden.

Die möglichen Auswirkungen des Überladens lassen sich beschränken, indem Sie beim Aufruf den qualifizierten Routinennamen verwenden. Mit Unit1.MyProcedure(X, Y) können nur die in Unit1; deklarierten Routinen aufgerufen werden. Wenn der Name und die Parameterliste keiner Routine in Unit1 entsprechen, gibt der Compiler einen Fehler aus.

==Lokale Deklarationen==

Der Rumpf einer Funktion oder Prozedur beginnt in vielen Fällen mit der Deklaration lokaler Variablen, die im Anweisungsblock der Routine verwendet werden. Sie können beispielsweise Konstanten, Typen und andere Routinen deklarieren. Der Gültigkeitsbereich lokaler Bezeichner ist auf die Routine beschränkt, in der sich die Deklaration befindet.

===Verschachtelte Routinen===

Funktionen und Prozeduren können im Abschnitt mit den lokalen Deklarationen ihrerseits Funktionen und Prozeduren enthalten. Die folgende Deklaration der Prozedur DoSomething enthält beispielsweise eine verschachtelte Prozedur:

<source lang="delphi">
procedure DoSomething(S: string);
var
X, Y: Integer;

procedure NestedProc(S: string);
begin
...
end;

begin
...
NestedProc(S);
...
end;</source>

Der Gültigkeitsbereich einer verschachtelten Routine ist auf die Funktion bzw. Prozedur beschränkt, in der sie deklariert ist. Im letzten Beispiel kann NestedProc nur in DoSomething aufgerufen werden..

Echte Beispiele verschachtelter Routinen sind die Prozedur DateTimeToString, die Funktion'''ScanDate''' und andere Routinen in der Unit SysUtils.

==Siehe auch==

* [[Parameter (Delphi)|Parameter (Delphi)]]
*[[Prozeduren und Funktionen aufrufen (Delphi)|Prozeduren und Funktionen aufrufen (Delphi)]]
* [[Deklarationen und Anweisungen (Delphi)|Deklarationen und Anweisungen (Delphi)]]
* [[Methoden (Delphi)|Methoden (Delphi)]]
* [[Ablaufsteuerung (Delphi)|Ablaufsteuerung (Delphi)]]
* [[Prozedurale Typen|Prozedurale Typen (Delphi)]]

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

Hilfe zur Hilfe - CHM

2025-10-22T15:26:37Z

Nicolas.rios: /* Die Offline-CHM-Hilfe aktualisieren */

{{Parent|Hilfe zur Hilfe}}

Die CHM-Hilfe von {{Product}} wird mit {{Product}} ausgeliefert und reagiert auf die '''Hilfe'''-Schaltfläche oder die Taste {{Key|F1}} in der IDE. Diese Hilfe liegt im Format '''[[Wikipedia:Microsoft Compiled HTML Help|Microsoft Compilierte HTML-Hilfe]]''', auch als CHM bezeichnet, vor.

Im '''HTML-Hilfe-Viewer unter Windows''' gibt es zwei Bereiche:

* Im linken Bereich können Sie auf Navigationsfunktionen: '''Inhalt''', '''Index''', '''Suchen''', '''Favoriten''' zugreifen.
* Im rechten Bereich wird das aktuelle Hilfethema angezeigt.

==Kontextsensitive F1-Hilfe in der IDE==

Kontextsensitive Hilfe wird durch Auswahl eines Elements in der IDE und Drücken von {{Key|F1}} aufgerufen:

* Im '''[[Quelltext-Editor#Verwenden_von_F1-Hilfe|Quelltext-Editor]]''' können Sie:
** Auf einen {{Code|identifier}} zeigen, der einem Namen einer Prozedur, Funktion, Konstanten, Eigenschaft, Variablen, Feld, Typ, Programm, Unit, Bibliothek oder Package, das in den installierten CHM-Hilfedateien beschrieben wird, entspricht.
** Auf ein {{Code|word}} (oder {{Code|token}}) zeigen, der einem [[Grundlegende syntaktische Elemente (Delphi)#Reservierte_Wörter|reservierten Wort]], [[Grundlegende syntaktische Elemente (Delphi)#Directiven|Directive]] oder [[Schlüsselwörter|C++-Schlüsselwort]] entspricht.
** Einen qualifizierten Bezeichner {{Code|identifier1.identifier2}} auswählen. Hier qualifiziert {{Code|identifier1}} {{Code|identifier2}}. Sie können z. B. {{Code|TCollection.Clear}} auswählen.
** Im '''Quelltext-Editor''' auf eine beliebe Stelle zeigen.
* In einem Formular im '''[[Formular-Designer|Formular-Designer]]''' markieren Sie die Komponente.
* Im Fenster '''[[Fenster: Meldungen|Meldungen]]''' markieren Sie eine Meldung.
* In IDE-Fenstern, wie der '''[[Projekte-Fenster|Projektverwaltung]]''' oder der '''[[Modellansicht|Modellansicht]]''', klicken Sie in das Fenster.

==DocWiki enthält die aktuellen Informationen==

Die {{Product}}-Hilfe wird aus einem Wiki erzeugt: '''[[Hilfe zur Hilfe: DocWiki|DocWiki]]'''. Die Hilfe mit den neuesten Informationen finden Sie stets im DocWiki. Alle Benutzer von {{Product}} sind eingeladen, sich am DocWiki zu beteiligen. Sie können ein eigenes Benutzerkonto erstellen, indem Sie auf einer beliebigen Seite im DocWiki auf '''Anmelden/Benutzerkonto anlegen''' klicken.

Das DocWiki ist in drei einzelne DocWikis unterteilt:

* Themenbezogene Seiten: {{f|radstudio|[http://docwiki.embarcadero.com/RADStudio/en/Main_Page}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/topics/en/Main_Page}} http://docwiki.embarcadero.com/RADStudio/de/Hauptseite}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/topics/de/Hauptseite}}]
* Bibliotheksreferenz: {{f|radstudio|[http://docwiki.embarcadero.com/Libraries/en/Main_Page}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/libraries/en/Main_Page}} http://docwiki.embarcadero.com/Libraries/de/Hauptseite}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/libraries/de/Hauptseite}}]
* Code- und Produktbeispiele: {{f|radstudio|[http://docwiki.embarcadero.com/CodeExamples/en/Main_Page}}{{f|appmethod|docwiki.appmethod.com/appmethod/codeexamples/en/Main_Page}} http://docwiki.embarcadero.com/CodeExamples/en/Main_Page}}{{f|appmethod|docwiki.appmethod.com/appmethod/codeexamples/en/Main_Page}}]

In der Offline-CHM-Hilfe wird auf jeder Seite ein Link, '''Aktuelle Wiki-Seite''' angezeigt: Klicken Sie auf diesen Link, um auf die aktuelle Docwiki-Version der angezeigten Seite zuzugreifen.

===Die Offline-CHM-Hilfe aktualisieren===

Gelegentlich<nowiki>*</nowiki> wird eine neuere Version der Offline-CHM-Hilfe als separater Download bereitgestellt. Um die neuere Version anzuwenden, folgenden Sie den unten genannten Schritten:
<section begin="steps" />

# Schließen Sie {{Product}}.
# Laden Sie die [http://docwiki.embarcadero.com/docs/products/rad_studio/{{RadstudioVersion}}/{{RadstudioVersion}}-CHM-de.zip Zip-Datei] mit den CHM-Dateien herunter.
# Extrahieren Sie die ZIP-Datei.
# Navigieren Sie zum Speicherort der CHM-Dateien (standardmäßig {{Path|{{InstallPath}}\Help\Doc\de}}).
# Überschreiben Sie die vorhandenen CHM-Dateien mit denen aus der ZIP-Datei (Sie können vorher eine Sicherung der alten CHM-Dateien erstellen).
# Öffnen Sie {{Product}}.
# Starten Sie die Hilfe.

<section end="steps" />
<nowiki>*</nowiki>Sie finden das Datum, an dem die CHM-Dateien aktualisiert wurden, [https://docwiki.embarcadero.com/docs/products/rad_studio/index.php hier] oder in der Readme-Datei, di in der [http://docwiki.embarcadero.com/docs/products/rad_studio/{{RadstudioVersion}}/{{RadstudioVersion}}-CHM-de.zip Zip-Datei] enthalten ist.

==Siehe auch==

* [[Hilfe für Ihre Komponenten bereitstellen|Hilfe für Ihre Komponenten bereitstellen]]
* [[Einführung in RAD Studio|Einführung in {{Product}}]]
* [[Hilfe zur Hilfe: DocWiki|Hilfe zur Hilfe: DocWiki]]

[[Category:Einführung]]
[[Category:XE8]]
[[Category:AMMigrate]]

[[en:Help on Help - CHM]]
[[fr:Utilisation de l'aide - CHM]]
[[ja:ヘルプの使用方法 - CHM]]

Hilfe zur Hilfe - CHM

2025-10-22T15:21:07Z

Nicolas.rios: RS-130010

{{Parent|Hilfe zur Hilfe}}

Die CHM-Hilfe von {{Product}} wird mit {{Product}} ausgeliefert und reagiert auf die '''Hilfe'''-Schaltfläche oder die Taste {{Key|F1}} in der IDE. Diese Hilfe liegt im Format '''[[Wikipedia:Microsoft Compiled HTML Help|Microsoft Compilierte HTML-Hilfe]]''', auch als CHM bezeichnet, vor.

Im '''HTML-Hilfe-Viewer unter Windows''' gibt es zwei Bereiche:

* Im linken Bereich können Sie auf Navigationsfunktionen: '''Inhalt''', '''Index''', '''Suchen''', '''Favoriten''' zugreifen.
* Im rechten Bereich wird das aktuelle Hilfethema angezeigt.

==Kontextsensitive F1-Hilfe in der IDE==

Kontextsensitive Hilfe wird durch Auswahl eines Elements in der IDE und Drücken von {{Key|F1}} aufgerufen:

* Im '''[[Quelltext-Editor#Verwenden_von_F1-Hilfe|Quelltext-Editor]]''' können Sie:
** Auf einen {{Code|identifier}} zeigen, der einem Namen einer Prozedur, Funktion, Konstanten, Eigenschaft, Variablen, Feld, Typ, Programm, Unit, Bibliothek oder Package, das in den installierten CHM-Hilfedateien beschrieben wird, entspricht.
** Auf ein {{Code|word}} (oder {{Code|token}}) zeigen, der einem [[Grundlegende syntaktische Elemente (Delphi)#Reservierte_Wörter|reservierten Wort]], [[Grundlegende syntaktische Elemente (Delphi)#Directiven|Directive]] oder [[Schlüsselwörter|C++-Schlüsselwort]] entspricht.
** Einen qualifizierten Bezeichner {{Code|identifier1.identifier2}} auswählen. Hier qualifiziert {{Code|identifier1}} {{Code|identifier2}}. Sie können z. B. {{Code|TCollection.Clear}} auswählen.
** Im '''Quelltext-Editor''' auf eine beliebe Stelle zeigen.
* In einem Formular im '''[[Formular-Designer|Formular-Designer]]''' markieren Sie die Komponente.
* Im Fenster '''[[Fenster: Meldungen|Meldungen]]''' markieren Sie eine Meldung.
* In IDE-Fenstern, wie der '''[[Projekte-Fenster|Projektverwaltung]]''' oder der '''[[Modellansicht|Modellansicht]]''', klicken Sie in das Fenster.

==DocWiki enthält die aktuellen Informationen==

Die {{Product}}-Hilfe wird aus einem Wiki erzeugt: '''[[Hilfe zur Hilfe: DocWiki|DocWiki]]'''. Die Hilfe mit den neuesten Informationen finden Sie stets im DocWiki. Alle Benutzer von {{Product}} sind eingeladen, sich am DocWiki zu beteiligen. Sie können ein eigenes Benutzerkonto erstellen, indem Sie auf einer beliebigen Seite im DocWiki auf '''Anmelden/Benutzerkonto anlegen''' klicken.

Das DocWiki ist in drei einzelne DocWikis unterteilt:

* Themenbezogene Seiten: {{f|radstudio|[http://docwiki.embarcadero.com/RADStudio/en/Main_Page}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/topics/en/Main_Page}} http://docwiki.embarcadero.com/RADStudio/de/Hauptseite}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/topics/de/Hauptseite}}]
* Bibliotheksreferenz: {{f|radstudio|[http://docwiki.embarcadero.com/Libraries/en/Main_Page}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/libraries/en/Main_Page}} http://docwiki.embarcadero.com/Libraries/de/Hauptseite}}{{f|appmethod|http://docwiki.appmethod.com/appmethod/libraries/de/Hauptseite}}]
* Code- und Produktbeispiele: {{f|radstudio|[http://docwiki.embarcadero.com/CodeExamples/en/Main_Page}}{{f|appmethod|docwiki.appmethod.com/appmethod/codeexamples/en/Main_Page}} http://docwiki.embarcadero.com/CodeExamples/en/Main_Page}}{{f|appmethod|docwiki.appmethod.com/appmethod/codeexamples/en/Main_Page}}]

In der Offline-CHM-Hilfe wird auf jeder Seite ein Link, '''Aktuelle Wiki-Seite''' angezeigt: Klicken Sie auf diesen Link, um auf die aktuelle Docwiki-Version der angezeigten Seite zuzugreifen.

===Die Offline-CHM-Hilfe aktualisieren===

Gelegentlich<nowiki>*</nowiki> wird eine neuere Version der Offline-CHM-Hilfe als separater Download bereitgestellt. Um die neuere Version anzuwenden, folgenden Sie den unten genannten Schritten:
<section begin="steps" />

# Schließen Sie {{Product}}.
# Laden Sie die [http://docwiki.embarcadero.com/docs/products/rad_studio/{{RadstudioVersion}}/{{RadstudioVersion}}-CHM-en.zip Zip-Datei] mit den CHM-Dateien herunter.
# Extrahieren Sie die ZIP-Datei.
# Navigieren Sie zum Speicherort der CHM-Dateien (standardmäßig {{Path|{{InstallPath}}\Help\Doc\de}}).
# Überschreiben Sie die vorhandenen CHM-Dateien mit denen aus der ZIP-Datei (Sie können vorher eine Sicherung der alten CHM-Dateien erstellen).
# Öffnen Sie {{Product}}.
# Starten Sie die Hilfe.

<section end="steps" />
<nowiki>*</nowiki>Sie finden das Datum, an dem die CHM-Dateien aktualisiert wurden, [https://docwiki.embarcadero.com/docs/products/rad_studio/index.php hier] oder in der Readme-Datei, di in der [http://docwiki.embarcadero.com/docs/products/rad_studio/{{RadstudioVersion}}/{{RadstudioVersion}}-CHM-en.zip Zip-Datei] enthalten ist.

==Siehe auch==

* [[Hilfe für Ihre Komponenten bereitstellen|Hilfe für Ihre Komponenten bereitstellen]]
* [[Einführung in RAD Studio|Einführung in {{Product}}]]
* [[Hilfe zur Hilfe: DocWiki|Hilfe zur Hilfe: DocWiki]]

[[Category:Einführung]]
[[Category:XE8]]
[[Category:AMMigrate]]

[[en:Help on Help - CHM]]
[[fr:Utilisation de l'aide - CHM]]
[[ja:ヘルプの使用方法 - CHM]]

FireMonkey for Linux

2025-08-22T19:21:14Z

Nicolas.rios: /* Erzeugen und Bereitstellen Ihres ersten Projekts */

==Was ist FMX for Linux?==

FireMonkey for Linux, auch als FMXLinux bezeichnet, ist eine Zusatzkomponente, die Kunden von Delphi und RAD Studio Enterprise und Architect Edition über eine exklusive OEM-Vereinbarung mit [http://www.fmxlinux.com/ FMXLinux] zur Verfügung steht. FMXLinux ermöglicht die Erstellung von GUI-Anwendungen für Linux und erweitert somit das plattformübergreifende FireMonkey-Framework von RAD Studio (Delphi Edition).

Ab 10.3.1 ist der FireMonkey for Linux (FMX)-Client für Delphi und RAD Studio Enterprise-Kunden mit einer aktuellen Update Subskription über den GetIt-Package-Manager von RAD Studio in der IDE verfügbar.

===Schlüsselfunktionen:===

* FireMonkey for Linux ermöglicht die Erstellung von GUI-Anwendungen für Linux und erweitert somit das plattformübergreifende FireMonkey-Framework von Delphi.
* FMXLinux erweitert die Delphi-Unterstützung von Serveranwendungen auf FMX-Client-Anwendungen für gängige Linux-Distributionen.
* Enthält mehrere gebrauchsfertige Benutzeroberflächenstile.
* Viele FMX-Komponenten, wie Tabellen, Widgets usw., arbeiten nahtlos auf Linux-Clients.
* Nutzen Sie die innovativen Funktionen von RAD Studio, wie LiveBindings und mehr, in Ihren Linux-Client-Anwendungen.
* Nutzen Sie die WebKitGTK-Unterstützung, um eine FMXLinux-Anwendung im Browser als HTML5-Webanwendung auszuführen.

===Zugriff auf FMX for Linux===

Um FMXLinux herunterzuladen und zu installieren, öffnen Sie Delphi, wählen {{Menu|Tools > GetIt-Package-Manager}} aus, und suchen nach '''fmxlinux'''. Am Ende des Vorgangs fordert Sie der GetIt-Package-Manager zum Neustart der IDE auf.

[[File:FMXLinux01.png]]

==Voraussetzungen für FireMonkey-GUI-Anwendungen==

===Installieren der Linux-Plattformunterstützung===

Vor der Installation von FMXLinux müssen Sie die Linux-Plattformunterstützung für Delphi installieren. Wählen Sie {{Menu|Tools > Plattformen verwalten}}, um zu überprüfen, ob '''Delphi Linux 64 Bit''' installiert ist.

[[File:FMXLinux02.png]]

===Installieren und Ausführen von PAServer===

Nach der Installation der Linux-Plattformunterstützung müssen Sie den [[PAServer: Die Platform Assistant Server-Anwendung|Platform Assistant]] auf Linux installieren, um Linux-Anwendungen zu erzeugen und bereitzustellen. PAServer ermöglicht Ihnen, den [[Bereitstellungs-Manager|Bereitstellungs-Manager]] zu verwenden, das Linux-SDK zu importieren und Remote-Debugging auf einem Linux-System durchzuführen. Nach der Installation von PAServer für Linux müssen Sie zunächst [[Ausführen des Platform Assistant unter Linux|PAServer ausführen]], bevor Sie mit dem Erzeugen von FMXLinux-GUI-Anwendungen beginnen können.

===Installieren von Abhängigkeiten auf dem Linux-Server===

Um die grafischen Funktionen in Ihrer Serveranwendung zu verwenden, müssen Sie bestimmte Abhängigkeiten installieren. Es ist nicht erforderlich, das gesamte X11-System auf Ihrem Server zu installieren.

Geben Sie Folgendes in das Terminal ein, um Abhängigkeiten auf Ubuntu/Debian zu installieren:

sudo apt install libgl1-mesa-glx libglu1-mesa libgtk-3-common libgstreamer1.0 libgstreamer-plugins-base1.0

==Erste Schritte==

===FMXLinux-Konfiguration===

Bei der Installation von FMXLinux über GetIt registriert das System das unten gezeigte DLL-Experten-Menü ("Linux-Plattform hinzufügen") und fügt dem Bibliothekspfad auch den Bibliotheksordner für das Katalog-Repository für die Linux-Plattform hinzu. Sie können dies unter {{Menu|Tools > Optionen > Sprache > Delphi-Optionen > Bibliothek}} überprüfen und oben aus dem Kombinationsfeld '''Plattformen auswählen''' die Option '''Linux 64 Bit''' auswählen:

[[File:FMXLinuxLibrary.png]]

Klicken Sie auf die Ellipse [[File:Ellipsis ide.png]], um die Liste der Pfade zu erweitern und sie anzupassen.

===Erzeugen und Bereitstellen Ihres ersten Projekts===

Wählen Sie nach der Installation der oben aufgeführten Voraussetzungen und von FMXLinux über den GetIt-Package-Manager {{Menu|Datei > Projekt öffnen}}, um ein vorhandenes FireMonkey-Projekt zu öffnen, oder {{Menu|Datei > Neu > Geräteübergreifende Anwendung}}, um ein neues FireMonkey-Projekt zu erstellen.

Klicken Sie als Nächstes in der Projektgruppe mit der rechten Maustaste auf das Projekt und klicken Sie dann auf '''Linux-Plattform hinzufügen''', um die Linux-Plattform hinzuzufügen.

[[File:FMXLinux03.png]]

Nach dem Hinzufügen der Linux-Plattform zu Ihrem Projekt können Sie zu "Linux 64 Bit" wechseln und Ihre FMX-GUI-Anwendungen für Linux bereitstellen. Dazu muss auf Ihrem Linux-Zielcomputer [[Ausführen des Platform Assistant unter Linux|PAServer ausgeführt]] werden. Klicken Sie auf '''Ausführen''', um Ihre Linux-GUI-Anwendung bereitzustellen.

[[Datei:FMX Linux image 04.png]]

{{Attention|Beim Erzeugen einer FMXLinux-Anwendung kann die Fehlermeldung '''System.Devices wird auf dieser Plattform nicht unterstützt''' angezeigt werden.

[[File:Error message.png]]

Der Grund dafür ist, dass Ihre Bibliothekspfade nicht richtig konfiguriert sind. Anstatt das Build mit der richtigen DCU-Datei zu erzeugen, sucht der Compiler nach der Originalversion der Quellcodedatei, die nicht kompatibel ist (FMXLinux patcht diese Datei).}}

==Weitere Funktionen==

===Webbereitstellung auf Ubuntu Server===

Sie können mit dem GTK-Broadway-Backend eine FMXLinux-Anwendung als HTML5-Webanwendung im Browser ausführen:

# Installieren Sie die erforderlichen Bibliotheken: <code>sudo apt install xorg libgl1-mesa-dev libosmesa-dev libgtk-3-bin</code>
# Starten Sie den Broadway-Server: broadwayd
# Führen Sie die Anwendung in der IDE aus.
# Laden Sie im Browser  :8080.

==Unterstützte Linux-Distributionen==

Delphi Linux unterstützt RedHat Enterprise- und Ubuntu-Distributionen. Weitere Informationen finden Sie in der [[Unterstützte Zielplattformen|Liste der unterstützten Zielplattformen]].

==Weitere Ressourcen==

Es gibt zahlreiche Videos mit hilfreichen Informationen zum Erstellen von FMXLinux-Anwendungen:

* [https://youtu.be/3mw20kUCXho FMXLinux app in action (EN)]
* [https://youtu.be/rhu1Qs8Y470 Adding FMX Linux to your project (EN)]
* [https://youtu.be/Mvu2NxxqxGw FMX UI controls on Linux (EN)]
* [https://youtu.be/67xzTHTXlrc Running an FMXLinux app as an HTML5 web application in the browser (EN)]
* [https://youtu.be/p7smPdUfy2w CodeRage webinar replay (EN)]

==Siehe auch==

* [[PAServer: Die Platform Assistant Server-Anwendung|PAServer: Die Platform Assistant Server-Anwendung]]
* [[Bereitstellungs-Manager|Bereitstellungs-Manager]]
* [[Ausführen des Platform Assistant unter Linux|Ausführen des Platform Assistant unter Linux]]
* [http://www.fmxlinux.com/ FMXLinux]
* [[FireMonkey|FireMonkey]]
* [https://community.idera.com/developer-tools/b/blog/posts/webinar-introduction-to-fmxlinux---delphi-s-firemonkey-for-linux-solution Webinar: Introduction to FmxLinux - Delphi's FireMonkey for Linux Solution (EN)]

[[en:FireMonkey for Linux]]
[[fr:FireMonkey pour Linux]]
[[ja:FireMonkey for Linux]]

Datei:FMX Linux image 04.png

2025-08-22T19:20:04Z

Nicolas.rios:

FMX Linux image 04

Hauptseite

2025-06-26T17:39:32Z

Nicolas.rios:

{{DISPLAYTITLE:Hilfe für {{Product}} {{MarketingVersion}}}}
__NOTOC__

<div class="floatleft" style="width: 49%">
==[[Überblick über RAD Studio|Überblick]]==
* [[Überblick über RAD Studio|Funktionsübersicht]]
* [[Neuerungen|Neuerungen]]
* [[11 Alexandria - Release 1]]
* [[11 Alexandria – Release 2]]
* [[Release-Hinweise|Release-Hinweise]]
* [[rad_en: Community Edition|Community Edition]]

==[[Installation|Installation]]==
* [[Installationshinweise|Installationshinweise]]
* [[Plat en:Main Page#{{Product}} {{MarketingVersion}}|Hotfixes und Workarounds]]
==[[Einführung in RAD Studio|Einführung]]==
* [[Tutorials|Tutorials]] | [[Tutorial: Verwenden der IDE|Ihre erste Anwendung erstellen]]
* [[Hilfreiche Ressourcen für neue Benutzer#Code- und Anwendungsbeispiele|Code- und Anwendungsbeispiele]]
* [[Hilfreiche Ressourcen für neue Benutzer#Grundlagen|Lesen]]
* [[Hilfreiche Ressourcen für neue Benutzer#Video-Demos|Videos]]
* [[Hilfreiche Ressourcen für neue Benutzer#CodeRage-Seminare|Seminare]]
==Projektentwicklung==
* [[Hauptanwendungstypen|Hauptanwendungstypen]]
* [[Arbeitsschritte bei der Projektentwicklung|Arbeitsschritte bei der Projektentwicklung]]
==Referenz==
* [[Unterstützte Zielplattformen|Zielplattformen]]
* [[Frameworks und Bibliotheken|Frameworks und Bibliotheken]]
* [[Programmiersprachen|Programmiersprachen]]
* [[IDE-Referenz und Hilfsprogramme|IDE-Referenz und Hilfsprogramme]]
* [[Index|Index]]
</div>

<div class="floatright" style="width: 49%">

{{f|winguide|

==[[Windows-Entwicklerhandbuch - Index|Windows-Entwicklung]]==
* [[VCL|VCL-Formularanwendung für Windows]]
* [[Entwickeln von Metropolis-UI-Anwendungen|Metropolis-UI-Anwendungen für VCL und {{FM}} (Windows 8-Stil)]]
* [[Komponentenentwicklung - Index|Komponentenentwicklung]]

}}

==[[Geräteübergreifende Anwendungen - Index|Geräteübergreifende Entwicklung]]==
* [[Geräteübergreifende Anwendungen entwickeln|Geräteübergreifende Anwendungen entwickeln]]
* [[Schritte bei der Entwicklung von geräteübergreifenden Anwendungen|Schritte bei der Entwicklung von geräteübergreifenden Anwendungen]]
* [[Datenbankanwendungen entwickeln|Datenbankanwendungen entwickeln]]
* [[Entwickeln von RAD Server-, Cloud- und REST-Anwendungen|Entwickeln von RAD Server-, Cloud- und REST-Anwendungen]] {{f|datasnap|
* [[DataSnap-Anwendungen entwickeln|DataSnap-Anwendungen entwickeln]] }}
==Mobile Entwicklung==
* [[Mobile Android-Anwendungsentwicklung|Mobile Android-Anwendungsentwicklung]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)|Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)]]

{{f|radstudio|

==[[Internetanwendungen entwickeln - Index|Webentwicklung]]==
* [[Web Broker verwenden - Index|Verwenden von Web Broker]]
* [[DataSnap-Anwendungen entwickeln|Verwenden von DataSnap]]
* [[RAD Server (EMS)|Verwenden von RAD Server]]
==[[UML-Modellierung|UML-Modellierung]]==
* [[Einführende Modellierungskonzepte|Einführende Modellierungskonzepte]]
* [[Anleitungen für die Modellierung|Anleitungen für die Modellierung]]
* [[Modellierungsreferenz - Index|Modellierungsreferenz]]

}}

</div>

{{DEFAULTSORT:Hilfe fur RAD Studio 11 11.0 Alexandria}}
[[Category:Delphi]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:Main Page]]
[[fr:Accueil]]
[[ja:メインページ]]

Vorlage:MarketingVersion

2025-06-26T17:35:15Z

Nicolas.rios:

{{f|radstudio| {{#switch: {{RadstudioVersion|{{{1|{{RadstudioVersion}}}}}}}| Seattle = 10 Seattle| Berlin = 10.1 Berlin| Tokyo = 10.2 Tokyo| Rio = 10.3 Rio| Denali = 10.4 Sydney| Alexandria = 11 Alexandria| {{Version|{{RadstudioVersion|{{{1|{{RadstudioVersion}}}}}}}}}}}}}<noinclude>

[[Category:Datenvorlagen]]
[[Category:Durch Hauptversionsänderungen betroffene Vorlagen]]

Ausrichtung von Anwendungen

2025-05-05T19:41:10Z

Nicolas.rios: RS-127787

{{Parent|Anwendungsoptionen}}

{{Menu|Projekt > Optionen > [[Anwendungsoptionen|Anwendung]] > Ausrichtung}}
__TOC__

Legt die Ausrichtung für Ihre geräteübergreifende Anwendung auf mobilen Plattformen fest.

[[File:Orientation.png|830px|link=]]

===Ausrichtung auf iOS-Geräten===

{| border="1" frame="hsides" rules="rows"
|-
! Feld
! Beschreibung
|- valign="top"
| Benutzerdefinierte Ausrichtung aktivieren
| Aktivieren Sie dieses Kontrollkästchen, um die Ausrichtungen zu beschränken oder festzulegen, die Ihre iOS-App unterstützt. Um beispielsweise Ihre iOS-App immer im Hochformat anzuzeigen, aktivieren Sie die Kontrollkästchen '''Benutzerdefinierte Ausrichtung aktivieren''' und '''Hochformat'''.

iOS-Geräte unterstützen die Drehung des Formulars in den folgenden Richtungen:
* '''iPad:''' Drehung in alle Richtungen
* '''iPhone und iPod Touch:''' Drehung in alle Richtungen mit Ausnahme von auf dem Kopf stehend (umgedreht)

Wenn '''Benutzerdefinierte Ausrichtung aktivieren''' nicht ausgewählt ist, dann verwendet die App die Standarddrehungen entsprechend dem iOS-Gerät.
{| border="2" cellpadding="2"
|-
| Hochformat
| iOS-App wird vertikal (im Hochformat) angezeigt.
|-
|
Umgedreht
| iOS-App wird vertikal, aber auf dem Kopf stehend, angezeigt. Die Start-Schaltfläche des Gerätes befindet sich oben anstatt unten.
|- valign="top"
| Startseite Querformat rechts
| iOS-App wird horizontal (im Querformat) angezeigt. Die Start-Schaltfläche des Gerätes befindet sich rechts.
|- valign="top"
| Startseite Querformat links
| iOS-App wird horizontal (im Querformat) angezeigt. Die Start-Schaltfläche des Gerätes befindet sich links.
|}
|}

===Ausrichtung auf Android-Geräten===

{| border="1" frame="hsides" rules="rows"
|-
! Feld
! Beschreibung
|- valign="top"
| Benutzerdefinierte Ausrichtung aktivieren
|
Aktivieren Sie dieses Kontrollkästchen, um die Ausrichtungen zu beschränken oder festzulegen, die Ihre Android-App unterstützt. Um beispielsweise Ihre Android-App immer im Hochformat anzuzeigen, aktivieren Sie die Kontrollkästchen '''Benutzerdefinierte Ausrichtung aktivieren''' und '''Hochformat'''.

Android-Geräte unterstützen die Drehung des Formulars in alle Richtungen.
{| border="2" cellpadding="2"
|-
| Hochformat
| Android-App wird vertikal (im Hochformat) angezeigt.
|-
| Umgedreht
| Android-App wird vertikal, aber auf dem Kopf stehend, angezeigt. Die Start-Schaltfläche des Gerätes befindet sich oben anstatt unten.
|- valign="top"
| Startseite Querformat rechts
| Android-App wird horizontal (im Querformat) angezeigt. Die Start-Schaltfläche des Gerätes befindet sich rechts.
|- valign="top"
| Startseite Querformat links
| Android-App wird horizontal (im Querformat) angezeigt. Die Start-Schaltfläche des Gerätes befindet sich links.
|}
|}

====Hinweise zur Ausrichtung für Android====

* Wenn '''Benutzerdefinierte Ausrichtung aktivieren''' nicht ausgewählt ist oder wenn es ausgewählt ist und alle vier Ausrichtungen ebenfalls ausgewählt sind, dann verwendet die App die Standarddrehungen entsprechend dem Android-Gerät.
* Wenn Sie '''Startseite Querformat links''' und '''Startseite Querformat rechts''' aktivieren, verwendet die Android-App nur eine davon, normalerweise '''Startseite Querformat rechts'''.
* Wenn Sie '''Hochformat''' und '''Umgedreht''' wählen, verwendet die Android-App nur '''Hochformat'''.

==Siehe auch==

* [[Erscheinungsbild der Anwendung|Erscheinungsbild der Anwendung]]
* [https://developer.apple.com/documentation/bundleresources/information-property-list/uisupportedinterfaceorientations UISupportedInterfaceOrientations]
* [https://developer.apple.com/documentation/bundleresources/information-property-list/uirequiresfullscreen UIRequiresFullScreen]

[[Category:IDE-Referenz]]
[[Category:XE6]]
[[Category:AMMigrate]]

[[en:Application Orientation]]
[[fr:Orientation de l'application]]
[[ja:［アプリケーション｜向き］]]

Sichern von Indy-Netzwerkverbindungen

2025-02-10T18:41:35Z

Nicolas.rios: RS-126681

{{Parent|Sichern der Netzwerkverbindungen von geräteübergreifenden Apps}}

In diesem Thema wird gezeigt, wie Sie Ihren [[Indy|Indy]]-Netzwerkverbindungen die Unterstützung für TLS/SSL-Sicherheit hinzufügen.

==Voraussetzungen==

Laden Sie das neueste [[OpenSSL|OpenSSL]]-Archive für Ihre Entwicklungsplattform von [http://indy.fulgan.com/SSL/ http://indy.fulgan.com/SSL/] herunter, um TLS/SSL mit Indy auf Ihrem Entwicklungscomputer zu verwenden:

* 32-Bit-Windows: {{Path|openssl-{{Placeholder|version}}-i386-win32.zip}}.
* 64-Bit-Windows: {{Path|openssl-{{Placeholder|version}}-x64_86-win64.zip}}.

Extrahieren Sie den Inhalt des heruntergeladenen Archivs, und suchen Sie die folgenden Bibliotheksdateien:

* {{Path|libeay32.dll}}
* {{Path|ssleay32.dll}}

Kopieren Sie diese Dateien in den Ordner, in dem {{Product}} die ausführbare Datei Ihrer Anwendung erstellt. Zum Beispiel in {{Path|{{Placeholder|Projektordner}}/Win32/Debug}} für 32-Bit-Windows.

Bevor Sie Ihre Anwendung auf einem Remote-Computer ausführen oder Ihre Anwendung an andere Benutzer verteilen können, müssen Sie für '''Windows''' die Bereitstellungskonfiguration Ihrer Anwendung ändern, um diese Bibliotheksdateien in den Pfad der ausführbaren Datei Ihrer Anwendung aufzunehmen:

# Wählen Sie {{Menu|Projekt > Bereitstellung}}.
# Öffnen Sie das Kombinationsfeld oben im '''[[Bereitstellungs-Manager|Bereitstellungs-Manager]]''', und wählen Sie unter '''Alle Konfigurationen''' die Zielplattform (32-Bit-Windows oder 64-Bit-Windows) aus.
# Klicken Sie auf [[File:DMgrAddFiles.png|Dateien hinzufügen]].
# Wählen Sie die erforderlichen, zuvor heruntergeladenen Bibliotheksdateien aus, und klicken Sie auf '''OK'''.

Für '''macOS''' muss Ihre Anwendung keine Voraussetzungen für die TLS/SSL-Unterstützung erfüllen. Die erforderliche [[OpenSSL|OpenSSL]]-Bibliothek ist standardmäßig in diesen Betriebssystemen verfügbar.

Für '''iOS''' finden Sie unter [[Erstellen von iOS-Apps#OpenSSL-Unterstützung|Erstellen von iOS-Apps, OpenSSL-Unterstützung]] Informationen zum Konfigurieren Ihrer Anwendung für die Unterstützung der TLS/SSL-Verschlüsselung.

Unter '''Android'''-Versionen höher als 6 müssen Sie die OpenSSL-Bibliotheken einbeziehen, da Android nicht mehr [https://www.openssl.org/ OpenSSL], sondern [https://boringssl.googlesource.com/boringssl/ BoringSSL] verwendet.

{{Note| {{Product}} Sydney unterstützt nur die Android-Versionen höher als 6.}}

Für '''weitere Plattformen''' siehe [[OpenSSL|OpenSSL-Bibliotheken]].

==Implementieren der TLS/SSL-Unterstützung in Ihrem Indy-Client==

Von [http://www.indyproject.org/docsite/html/frames.html?frmname=topic&frmfile=TIdTCPConnection.html TIdTCPConnection] abgeleitete Klassen, wie [http://www.indyproject.org/docsite/html/frames.html?frmname=topic&frmfile=TIdHTTP.html TIdHTTP], stellen die Eigenschaft [http://www.indyproject.org/docsite/html/frames.html?frmname=topic&frmfile=TIdTCPConnection_IOHandler.html IOHandler] bereit.

Zur Sicherung einer Indy-Netzwerkverbindung ziehen Sie eine [http://www.indyproject.org/docsite/html/frames.html?frmname=topic&frmfile=TIdSSLIOHandlerSocketOpenSSL.html TIdSSLIOHandlerSocketOpenSSL]-Komponente in den '''[[Formular-Designer|Formular-Designer]]''' und doppelklicken im '''[[Objektinspektor|Objektinspektor]]''' auf die Eigenschaft {{Code|IOHandler}} der Indy-Client-Komponente, damit Ihre neue {{Code|TIdSSLIOHandlerSocketOpenSSL}}-Komponente als Eingabe-/Ausgabe-Behandlungsroutine ausgewählt wird.

Alternativ können Sie die Netzwerkverbindungen des Indy-Clients auch über den Code sichern:
<l s="delphi" />

'''{{Delphi}}:'''<source lang="delphi">
Client.IOHandler := TIdSSLIOHandlerSocketOpenSSL.Create;</source><l e="delphi" /><l s="cpp" />

'''C++:'''<source lang="cpp">
Client->IOHandler = new TIdSSLIOHandlerSocketOpenSSL();</source><l e="cpp" />

Sie können jetzt mit Ihrem Client sichere Anforderungen an einen Server, der die TLS/SSL-Verschlüsselung unterstützt, über das HTTPS-Protokoll senden. Um beispielsweise "<nowiki>http://www.example.com</nowiki>" mit der TLS/SSL-Verschlüsselung abzurufen, erhalten Sie mit Ihrem Client "http'''s'''://www.example.com".

==Siehe auch==

* [[Indy|Indy]]
* [https://www.indyproject.org/documentation/ Dokumentation der Indy-Referenz]

[[Category:XE7]]
[[Category:AMMigrate]]

[[en:Securing Indy Network Connections]]
[[fr:Sécurisation des connexions réseau Indy]]
[[ja:Indy ネットワーク接続のセキュリティ保護]]

Benutzerdefinierte Titelleiste für VCL-Formulare

2025-01-09T16:38:34Z

Nicolas.rios: RS-126082

==Übersicht==

Mit der Eigenschaft [[lib_de:Vcl.Forms.TForm.CustomTitleBar|TForm.CustomTitleBar]] und dem neuen Steuerelement [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] können Sie die native Titelleiste eines VCL-Formulars ähnlich wie bei Windows-Explorer, Google Chrome oder anderen Anwendungen anpassen. Sie können VCL-Steuerelemente auf der Titelleiste platzieren und benutzerdefiniertes Zeichnen in der Titelleiste ausführen sowie das standardmäßige Zeichnen von Elementen wie das Fenstersymbol und die Beschriftung steuern.

[[File:CustomTitleBarVCL.png|border]]

{{Note| Die benutzerdefinierte Titelleiste wird ab Windows 7 unterstützt.}}

Die Unterstützung für die [[lib_de:Vcl.Forms.TForm.CustomTitleBar|benutzerdefinierte Titelleiste]] verwendet die echte native Windows-Titelleiste und erfordert, dass DWM (Desktop Window Manager) aktiviert ist. Wenn Sie Aero in Windows 7 oder in Situationen deaktivieren, in denen der DWM nicht zum Rendern von Fenstern verwendet wird, wird die Anpassung der Titelleiste nicht unterstützt. Dies wird vom Steuerelement korrekt gehandhabt, aber um diese Situation in Ihrem Code zu überprüfen, prüfen Sie den Wert von TForm.CustomTitleBar.Supported. Dieser Wert ist True, wenn Sie die benutzerdefinierte Titelleiste verwenden können.

Um die volle Leistungsfähigkeit der benutzerdefinierten Titelleiste zu nutzen, müssen Sie eine Kombination der Eigenschaft [[lib_de:Vcl.Forms.TForm.CustomTitleBar|TForm.CustomTitleBar]] und einem auf dem Formular platzierten [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] verwenden. TTitleBarPanel wird zum Hosten von VCL-Steuerelementen verwendet, aber es ist auch erforderlich, um erweiterte Funktionen, wie Anpassen das Zeichnens, zu unterstützen, selbst wenn sich in der Titelleiste keine benutzerdefinierten Steuerelemente befinden. Im Wesentlichen stellt die Eigenschaft [[lib_de:Vcl.Forms.TForm.CustomTitleBar|TForm.CustomTitleBar]] die Einstellungen für die Titelleiste des Formulars dar und [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] ist ein VCL-Steuerelement, mit dem erweiterte Funktionen in der Titelleiste selbst repräsentiert werden und darauf zugegriffen wird.

{{Attention| Nur die '''Plattform'''-VCL-Stile funktionieren in der Titelleiste.}}

==Grundlegende Anpassung==

Die Klasse [[lib_de:Vcl.Forms.TForm Properties|VCL TForm]] hat eine neue Eigenschaft, [[lib_de:Vcl.Forms.TForm.CustomTitleBar|CustomTitleBar]]. Damit können grundlegende Eigenschaften, wie die Anzeige des Titels oder Symbols geändert werden sowie die erweiterten Funktionen, darunter die Platzierung von Steuerelementen, gesteuert werden.

Setzen Sie TForm.CustomTitleBar.Enabled auf True, um die Anpassung der Titelleiste zu aktivieren. Beachten Sie, dass oben in Ihrem VCL-Formular im Designer jetzt ein schattierter blauer Bereich angezeigt wird. Dieser Bereich im Formular wird für die Titelleiste verwendet.

==Position der VCL-Steuerelemente==

Die Titelleiste wird mit der [https://docs.microsoft.com/en-us/windows/win32/api/dwmapi/nf-dwmapi-dwmextendframeintoclientarea DwmExtendFrameIntoClientArea-Funktion] implementiert. Das bedeutet, dass es keinen Nicht-Client-Bereich im Formular gibt, und die Titelleiste sowohl im Client- als auch im Nicht-Client-Bereich gerendert wird. (Der Client-Bereich ist der Bereich, in dem Sie normalerweise VCL-Steuerelemente platzieren, und der Nicht-Client-Bereich ist der Bereich, der normalerweise von der Systemtitelleiste, dem vom System bereitgestellten Hauptmenü, das von einem TMainMenu gekapselt wird, den Bildlaufleisten und dem Größenänderungsrahmen verwendet wird. Weitere Informationen finden Sie unter [[lib_de:Vcl.Controls.TControl.ClientRect|ClientRect]], [[lib_de:Vcl.Controls.TControl.ClientWidth|ClientWidth]] und [[lib_de:Vcl.Controls.TControl.ClientHeight|ClientHeight]].)

Alle dem Formular untergeordneten Steuerelemente mit einer Align-Eigenschaft, wie z. B. alTop, werden korrekt an den Bereich der Titelleiste angepasst. Jedes Steuerelement, das über die Eigenschaften Left und Top platziert wird, d. h. absolut positioniert ist, bleibt jedoch an der Stelle, an der es sich befindet, und kann daher die Titelleiste überlappen, sodass seine Position angepasst werden muss, wenn die benutzerdefinierte Titelleiste aktiviert ist.

Wir empfehlen, Steuerelemente im Formular auf einem am Client ausgerichteten TPanel zu platzieren. Beachten Sie, dass Sie möglicherweise auch die Eigenschaft Height des Formulars vergrößern sollten, um den Platz zu berücksichtigen, der zuvor von der Titelleiste verwendet wurde.

==Einstellungen und teilweise benutzerdefinierte Farbgebung==

Die folgenden Einstellungen steuern das Verhalten der Titelleiste sowie häufige Szenarien für die Farbgebung (wie etwa den Titel der Titelleiste ohne Farbe), mit denen Sie diese Szenarien berücksichtigen können, ohne eine vollständige benutzerdefinierte Farbgebung zu implementieren.

* '''[[lib_de:Vcl.Forms.TTitleBar.CaptionAlignment|CaptionAlignment]]:''' Damit geben Sie an, wo der Titel gezeichnet werden soll. Windows 10 zeichnet standardmäßig links. Sie können den Titel zentriert, wie in Windows 8, oder rechtsbündig zeichnen.
* '''[[lib_de:Vcl.Forms.TTitleBar.Control|Control]]:''' Legen Sie diese Eigenschaft auf ein TTitleBarPanel fest, das auf dem Formular platziert ist. Siehe den folgenden Abschnitt über benutzerdefinierte Steuerelemente in einer Titelleiste.
* '''[[lib_de:Vcl.Forms.TTitleBar.Enabled|Enabled]]:''' Aktiviert oder deaktiviert die Verwendung der benutzerdefinierten Titelleiste.
* '''[[lib_de:Vcl.Forms.TTitleBar.Height|Height]]:''' Höhe der Titelleiste in Pixel. Um die Höhe der Titelleiste zu ändern, deaktivieren Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]'''. Dadurch wird die Titelleiste auf die Standardhöhe des Systems beschränkt. Sie können die Eigenschaft Height auf einen beliebigen Wert festlegen.
* '''[[lib_de:Vcl.Forms.TTitleBar.ShowCaption|ShowCaption]]:''' Steuert, ob der Titel gezeichnet wird.
* '''[[lib_de:Vcl.Forms.TTitleBar.ShowIcon|ShowIcon]]:''' Steuert, ob das Symbol des Formulars an der linken Ecke der Titelleiste gezeichnet wird.
* '''[[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]''': Bei True hat die Höhe der Titelleiste immer den Wert, der auch von anderen Fenstern auf dem aktuellen Bildschirm verwendet wird. Um die Höhe der Titelleiste anzupassen, deaktivieren Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]''' und geben dann einen Wert für die Eigenschaft Height ein.
* '''[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]:''' Steuert, ob für den aktiven oder inaktiven Status des Titels der Titelleiste und der Schaltflächen die Systemfarben oder benutzerdefinierte Farben verwendet werden. Das ist nützlich, wenn Sie die Titelleiste mit anderen Hinter- und Vordergrundfarben als denjenigen des Systems ohne vollständige benutzerdefinierte Farbgebung darstellen möchten.

: Bei True erhalten der Hintergrund, der Titel und die Systemschaltflächen, wie andere Anwendungen, die Standardfarben des Systems. Bei False werden die Farben verwendet, die Sie in den Farbeigenschaften (siehe unten) angeben.
: Damit benutzerdefinierte Farben verwendet werden, müssen Sie ein [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] auf dem Formular platzieren und die Eigenschaft CustomTitleBar.Control darauf festlegen, genau so, als ob Sie Steuerelemente in der Titelleiste zu platzieren wollten, auch wenn der Titelleistenbereich leer ist und keine Steuerelemente enthält.

* Mit '''[[lib_de:Vcl.Forms.TTitleBar.BackgroundColor|BackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ForegroundColor|ForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|InactiveBackgroundColor]]''' und '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|InactiveForegroundColor]]''' werden die Farben für die Titelleiste festgelegt. Legen Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]''' auf True fest, um diese Werte zu ignorieren und die aktuellen Systemfarben zu verwenden.
* '''[[lib_de:Vcl.Forms.TTitleBar.ButtonBackgroundColor|ButtonBackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonForegroundColor|ButtonForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonHoverBackgroundColor|ButtonHoverBackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonHoverForegroundColor|ButtonHoverForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|ButtonInactiveBackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|ButtonInactiveForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonPressedBackgroundColor|ButtonPressedBackgroundColor]]''' und '''[[lib_de:Vcl.Forms.TTitleBar.ButtonPressedForegroundColor|ButtonPressedForegroundColor]]''' geben die Farben an, die für Systemschaltflächen verwendet werden sollen, wenn es sich um benutzerdefinierte Schaltflächen handelt oder wenn die Titelleiste benutzerdefiniert gezeichnet wird. Legen Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]''' auf True fest, um dieser Wert zu ignorieren und die aktuellen Systemfarben zu verwenden.

==Vollständige benutzerdefinierte Farbgebung==

Sie können vollständig anpassen, wie die Titelleise gerendert wird, indem Sie die Titelleiste mit Farbe füllen und darauf zeichnen. Dazu müssen Sie ein [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] auf dem Formular platzieren und die Eigenschaft CustomTitleBar.Control darauf festlegen, genau so, als ob Sie Steuerelemente in der Titelleiste platzieren wollten, auch wenn der Titelleistenbereich leer ist und keine Steuerelemente enthält. Sie können dann eine Ereignisbehandlungsroutine für das Ereignis [[lib_de:Vcl.ExtCtrls.TCustomTitleBarPanel.OnPaint|TTitleBarPanel.OnPaint]] erstellen.

Das Ereignis [[lib_de:Vcl.ExtCtrls.TCustomTitleBarPanel.OnPaint|TTitleBarPanel.OnPaint]] wird als allerletzter Schritt bei der Farbgebung aufgerufen. Die Farbe wird über alles gelegt, was bereits in der Titelleiste mit Farbe versehen wurde, z. B. Beschriftungen oder Systemschaltflächen. Sie können zudem mit den Rect-Eigenschaften das Zeichnen anpassen. Mit den Eigenschaften [[lib_de:Vcl.Forms.TTitleBar.IconRect|IconRect]], [[lib_de:Vcl.Forms.TTitleBar.FrameRect|FrameRect]], [[lib_de:Vcl.Forms.TTitleBar.ClientRect|ClientRect]] und [[lib_de:Vcl.Forms.TTitleBar.CaptionButtonsRect|CaptionButtonsRect]] können Sie ermitteln, wo sich Systemschaltflächen, Titel usw. befinden.

Die Farbe ist eine 32-Bit-Oberfläche. Sie hat dieselben Anforderungen wie die Farbgebung auf Glas in Windows 7.

==Titelschaltflächen==

Sie können der Titelleiste Titelschaltflächen hinzufügen. Dies wird auch in der
IDE verwendet, um die Schaltflächen "Hilfe" und "Desktop" links neben den Schaltflächen "Minimieren"/"Maximieren"/"Schließen" hinzuzufügen, die in der Regel in der Titelleiste angezeigt werden.

Platzieren Sie dazu ein [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] auf dem Formular und legen Sie es auf die Eigenschaft CustomTitleBar.Control des Formulars fest, wie oben beschrieben. Anschließend können Sie benutzerdefinierte Schaltflächen über die Eigenschaft CustomButtons von TTitleBarPanel hinzufügen. Diese Eigenschaft ist eine Sammlung von TCaptionButtonItem. Schaltflächen werden automatisch in der Reihenfolge von rechts nach links angeordnet, beginnend links von der Schaltfläche "Minimieren". Die 0. Schaltfläche in der Sammlung ist die äußerst rechte und die letzte Schaltfläche die äußerst linke. In Windows 7 befindet sich ein kleiner Zwischenraum
zwischen der Schaltfläche "Minimieren" und der ersten benutzerdefinierten Schaltfläche.

Die Komponente TCaptionButtonItem repräsentiert eine Schaltfläche in der Titelleiste. Sie verfügt über die folgenden Eigenschaften:

* '''ButtonType''': ermöglicht die Verwendung einer Systemschaltfläche, wie "Schließen", "Minimieren" oder "Wiederherstellen", das Hinzufügen eines Zwischenraums oder einer vollständig benutzerdefinierten Schaltfläche. In der Regel verwenden Sie die benutzerdefinierte Schaltfläche.
* '''Enabled''': wenn deaktiviert, wird die Schaltfläche gezeichnet und reagiert nicht auf Mausbewegungen oder Klicks.
* ''' Hint''': ermöglicht das Festlegen eines Kurzhinweises, der angezeigt werden soll, wenn die Maus über die Schaltfläche geführt wird.
* '''Visible''': steuert, ob die Schaltfläche in der Titelleiste angezeigt wird.
* '''Width''': legt die Breite des Steuerelements fest.
* '''OnClick''': eine Ereignisbehandlungsroutine für das Klicken auf die Schaltfläche.
* '''OnPaint''': eine Ereignisbehandlungsroutine zum Zeichnen auf der Schaltfläche, wie ein Schaltflächensymbol. Schaltflächen sind nicht mit einer Bilderliste verbunden.

==Unterstützung für Windows 7 und 10==

Die benutzerdefinierte Titelleiste unterstützt Windows 7 und Windows 10 vollständig, einschließlich der Titelschaltflächen:

[[File:TTitleBar.png]]

Die RAD Studio-Titelleiste unter Windows 7.

{{Note|
Die Plattformen Windows Vista oder früher werden nicht unterstützt.

Die benutzerdefinierte Titelleiste wird unter Windows 8 unterstützt, es können aber optische Unterschiede im Vergleich zu anderen Anwendungen auftreten, etwa wie Systemschaltflächen mit Farbe gefüllt werden, wenn die Farben angepasst werden (sie werden wie Windows 10-Schaltflächen gerendert).}}

==Benutzerdefinierte Steuerelemente==

Mit dem Steuerelement [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] werden Steuerelemente im Titelleistenbereich auf dem VCL-Formular platziert. Es dient als Container, der beim Entwurf Unterstützung für die Steuerelemente bereitstellt. Außerdem stellt es eine Beziehung zwischen dem Formular und dem benutzerdefinierten Titelleistenbereich her.

In der Titelleiste platzierte Steuerelemente müssen das Zeichnen auf eine 32-Bit-Oberfläche unterstützen, wie auf Glas unter Windows 7. Als allgemeine Richtlinie gilt: Wenn ein Steuerelement auf Glas unter Windows 7 korrekt gerendert wird, wird es unter Windows 7 und 10 vermutlich korrekt in der Titelleiste angezeigt. Es kommt häufig vor, dass ein Steuerelement platziert wird und dann festgestellt wird, dass es nicht richtig gerendert wird, selbst im Designer. Möglicherweise müssen Sie Eigenschaften wie DoubleBuffered für normale VCL-Steuerelemente verwenden.

So platzieren Sie Steuerelemente in der Titelleiste:

* Suchen Sie in der Palette das Steuerelement [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] und platzieren Sie es auf dem Formular. Es wird oben auf dem Formular angezeigt.
* Legen Sie die Eigenschaft CustomTitleBar.Control des Formulars auf den Titelleistenbereich fest. Der Titelleistenbereich hat eine blaue Hintergrundfarbe und rechts werden Systemschaltflächen angezeigt.
* Ändern Sie optional die Eigenschaft Height der Titelleiste, damit sie mit der Eigenschaft CustomTitleBar.Height übereinstimmt. Nur Steuerelemente, die sich innerhalb der Höhe der Titelleiste befinden, werden in der Titelleiste selbst gerendert.
* Suchen Sie in der Palette ein Steuerelement, z. B. TEdit, und platzieren Sie es auf [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] mit diesen Einstellungen:
** Legen Sie im Objektinspektor die Eigenschaftt DoubleBuffered des neuen Steuerelements auf True fest.
** Da es sich bei [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] um ein normales VCL-Steuerelement handelt, können Sie Align, Anchors und andere Positionierungseigenschaften für darauf befindliche Steuerelemente festlegen. Damit das TEdit-Steuerelement rechts neben den Systemschaltflächen ausgerichtet wird, wie etwa für ein Sucheingabefeld, ziehen Sie es an die gewünschte Position und ändern Sie die Eigenschaft Anchors von akLeft in akRight.

:
:: [[File:VCL control.png]]

:
:* Fügen Sie dem Formular das Ereignis OnShow hinzu oder verwenden Sie OnResize, wenn Sie Steuerelemente manuell anstatt über Anker in der Titelleiste platzieren möchten. (Wir empfehlen die Verwendung der Ausrichtung und von Ankern, da die Positionierung über [[lib_de:Vcl.Controls.TControl.OnResize|OnResize]] eine visuelle Verzögerung in Bezug auf die Fenstergröße erzeugen kann). Sie können sich auf die Eigenschaften [[lib_de:Vcl.Forms.TTitleBar.IconRect|IconRect]], [[lib_de:Vcl.Forms.TTitleBar.FrameRect|FrameRect]], [[lib_de:Vcl.Forms.TTitleBar.ClientRect|ClientRect]] und [[lib_de:Vcl.Forms.TTitleBar.CaptionButtonsRect|CaptionButtonsRect]] von CustomTitleBar beziehen, um Ihre Steuerelemente im Verhältnis zu bekannten Titelleistenelementen zu positionieren. Hier legen Sie die Eigenschaft Left des Eingabesteuerelements auf CaptionButtonsRect.Left minus der Breite für einen schmalen Rand (nur aus optischen Gründen) fest, indem Sie der Ereignisbehandlungsroutine die folgende Zeile hinzufügen:

:
::<source lang="delphi"> Edit1.Left := CustomTitleBar.CaptionButtonsRect.Left - Edit1.Width - 8; </source>

:
:: [[File:TForm.png]]

==Siehe auch==

* [[lib_de:Vcl.Forms.TForm.CustomTitleBar|CustomTitleBar]]
* [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]]
* [[lib_de:Vcl.Forms.TTitleBar.CaptionAlignment|CaptionAlignment]]
* [[lib_de:Vcl.Forms.TTitleBar.Control|Control]]
* [[lib_de:Vcl.Forms.TTitleBar.Enabled|Enabled]]
* [[lib_de:Vcl.Forms.TTitleBar.Height|Height]]
* [[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]
* [[lib_de:Vcl.Forms.TTitleBar.ShowCaption|ShowCaption]]
* [[lib_de:Vcl.Forms.TTitleBar.ShowIcon|ShowIcon]]
* [[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]
* [[lib_de:Vcl.Forms.TTitleBar.BackgroundColor|BackgroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ForegroundColor|ForegroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|InactiveBackgroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|InactiveForegroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonBackgroundColor|ButtonBackgroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonForegroundColor|ButtonForegroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonHoverBackgroundColor|ButtonHoverBackgroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonHoverForegroundColor|ButtonHoverForegroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|ButtonInactiveBackgroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|ButtonInactiveForegroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonPressedBackgroundColor|ButtonPressedBackgroundColor]]
* [[lib_de:Vcl.Forms.TTitleBar.ButtonPressedForegroundColor|ButtonPressedForegroundColor]]
* [[lib_de:Vcl.ExtCtrls.TCustomTitleBarPanel.OnPaint|TTitleBarPanel.OnPaint]]
* [[lib_de:Vcl.Forms.TTitleBar.IconRect|IconRect]]
* [[lib_de:Vcl.Forms.TTitleBar.FrameRect|FrameRect]]
* [[lib_de:Vcl.Forms.TTitleBar.ClientRect|ClientRect]]
* [[lib_de:Vcl.Forms.TTitleBar.CaptionButtonsRect|CaptionButtonsRect]]

[[Category:Sydney]]
[[Category:Mit Delphi für Windows arbeiten]]
[[Category:Delphi]]

Neuerungen in den letzten Releases

2024-10-08T15:58:33Z

Nicolas.rios: removing broken link

{{Parent|Neuerungen}}

Anhand der folgenden Liste können Sie die Seiten [[Neuerungen|Neuerungen]] von früheren Versionen von {{Product}} anzeigen:

*[http://docwiki.embarcadero.com/RADStudio/Alexandria/en/What%27s_New {{Product|Alexandria}} {{Version|Alexandria}}]
**[https://docwiki.embarcadero.com/RADStudio/Alexandria/en/11_Alexandria_-_Release_1 {{Product|Alexandria}} {{Version|Alexandria Release 1}}]
**[https://docwiki.embarcadero.com/RADStudio/Alexandria/en/What's_New_in_11.1.5 {{Product|Alexandria}} {{Version|Alexandria Release 1.5}}]
**[https://docwiki.embarcadero.com/RADStudio/Alexandria/en/11_Alexandria_-_Release_2 {{Product|Alexandria}} {{Version|Alexandria Release 2}}]
**[https://docwiki.embarcadero.com/RADStudio/Alexandria/en/11_Alexandria_-_Release_3 {{Product|Alexandria}} {{Version|Alexandria Release 3}}]
*[http://docwiki.embarcadero.com/RADStudio/Sydney/en/What%27s_New {{Product|Sydney}} {{Version|Sydney}}]
** [https://docwiki.embarcadero.com/RADStudio/Sydney/en/10.4_Sydney_-_Release_1 {{Product|Sydney}} {{Version|Sydney Release 1}}]
** [https://docwiki.embarcadero.com/RADStudio/Sydney/en/10.4_Sydney_-_Release_2 {{Product|Sydney}} {{Version|Sydney Release 2}}]
*[http://docwiki.embarcadero.com/RADStudio/Rio/en/What%27s_New {{Product|Rio}} {{Version|Rio}}]
** [https://docwiki.embarcadero.com/RADStudio/Rio/en/10.3_Rio_-_Release_1 {{Product|Rio}} {{Version|Rio Release 1}}]
** [https://docwiki.embarcadero.com/RADStudio/Rio/en/10.3_Rio_-_Release_2 {{Product|Rio}} {{Version|Rio Release 2}}]
** [https://docwiki.embarcadero.com/RADStudio/Rio/en/10.3_Rio_-_Release_3 {{Product|Rio}} {{Version|Rio Release 3}}]
*[https://docwiki.embarcadero.com/RADStudio/Tokyo/en/What%27s_New {{Product|Tokyo}} {{Version|Tokyo}}]
** [https://docwiki.embarcadero.com/RADStudio/Tokyo/en/10.2_Tokyo_-_Release_1 {{Product|Tokyo}} {{Version|Tokyo Release 1}}]
** [https://docwiki.embarcadero.com/RADStudio/Tokyo/en/10.2_Tokyo_-_Release_2 {{Product|Tokyo}} {{Version|Tokyo Release 2}}]
** [https://docwiki.embarcadero.com/RADStudio/Tokyo/en/10.2_Tokyo_-_Release_3 {{Product|Tokyo}} {{Version|Tokyo Release 3}}]
*[[Neuerungen in Berlin|RAD Studio Berlin]]
** [https://docwiki.embarcadero.com/RADStudio/Berlin/en/Subscription_Update_1 {{Product|Berlin}} {{Version|Berlin Release 1}}]
** [https://docwiki.embarcadero.com/RADStudio/Berlin/en/Subscription_Update_2_-_Anniversary_Edition {{Product|Berlin}} {{Version|Berlin Release 2}}]
*[[Neuerungen in Seattle|RAD Studio Seattle]]
** [https://docwiki.embarcadero.com/RADStudio/Seattle/en/Subscription_Update_1 {{Product|Seattle}} {{Version|Seattle Release 1}}]
* [https://docwiki.embarcadero.com/RADStudio/Berlin/en/What%27s_New_in_XE8 {{Product|XE8}} {{Version|XE8}}]
* [https://docwiki.embarcadero.com/RADStudio/Seattle/en/What%27s_New_in_XE7 {{Product|XE7}} {{Version|XE7}}]
* [http://docwiki.embarcadero.com/RADStudio/XE/en/What's_New {{Product|XE}} {{Version|XE}}]
* [http://docwiki.embarcadero.com/RADStudio/2010/en/What's_New {{Product|2010}} {{Version|2010}}]
* [http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/devcommon/whatsnewtiburon_xml.html {{Product|2009}} {{Version|2009}}]
* {{Product|2007}} {{Version|2007}}
** [http://docs.embarcadero.com/products/rad_studio/radstudio2007/RS2007_helpupdates/HUpdate4/EN/html/devcommon/whatsnewspacely_xml.html {{Delphi}}]
** [http://docs.embarcadero.com/products/rad_studio/radstudio2007/RS2007_helpupdates/HUpdate4/EN/html/devcommon/whatsnewcogswell_xml.html {{CBuilder}}]

{{Attention| Online-Dokumentation für Versionen vor Seattle ist aktuell nicht verfügbar. Sie können in der mit dem Produkt installierten Hilfedatei nachschlagen.}}

==Siehe auch==

* [[Compiler-Versionen|Compiler-Versionen]]
* [[Vordefinierte Makros|Vordefinierte Makros]]

[[en:What Was New in Past Releases]]
[[fr:Nouveautés des releases précédentes]]
[[ja:以前のリリースでの新機能]]

Erzeugen von statischen Packages

2024-10-08T13:48:45Z

Nicolas.rios: replacing link

{{Parent|Packages compilieren}}

Zum Erzeugen einer [[Statische Package-Bibliotheksdatei|statischen C++-Package-Bibliothek]] (.lib) ist ein Satz von [[C++-Objektdatei (*.obj, *.o)|C++-Objektdateien]] erforderlich, die nicht mit den zum Erzeugen der [[Geteilte Package-Bibliotheksdatei|dynamischen Bibliothek]] (.bpl) verwendeten C++-Objektdateien identisch sind.

Wenn Sie einen "Erzeugen"-Befehl ausführen, erstellt der C++-Compiler zwei Gruppen von C++-Objektdateien wie folgt:

* Die C++-Objektdateien für die dynamische Bibliothek (.dll oder .bpl) werden mit:
** <code>BCC32 -D_RTLDLL;USEPACKAGES</code> oder:
** <code>DCC32 -JPHNE</code> (C++-Objektdatei, [[C++-Header-Datei|C++-Header-Datei]] im Namespace erzeugen, alles exportieren) erzeugt.
* Die C++-Objektdateien für die statische Bibliothek (.lib) werden mit:
** <code>BCC32 -U_RTLDLL;USEPACKAGES</code> oder:
** <code>DCC32 -JPHN</code> (C++-Objektdatei, C++-Header-Datei im Namespace erzeugen) erzeugt
* Für beide Typen erstellt der [[TLIB.EXE: Der Bibliotheksmanager|TLIB-Bibliotheksmanager]] im Verzeichnis {{Path|\bpilib}} die eigentliche Bibliothek.

Die C++-Objektdateien für die dynamische Bibliothek (.bpl) werden in das Projektverzeichnis ausgegeben.

Die C++-Objektdateien für die statische Bibliothek (.lib) werden in ein Unterverzeichnis ausgegeben, das im Projektverzeichnis, normalerweise im Verzeichnis {{Path|\Debug\Win32\staticobjs}}, erstellt wird.

== Siehe auch ==
* [[Statische Package-Bibliotheksdatei]]
* [[TLIB.EXE: Der Bibliotheksmanager]]
* [https://blogs.embarcadero.com/create-and-use-static-library-lib-and-dynamic-dlls-in-c-builder/ EDN-Artikel: {{CBuilder}} Basics: Tutorial for Creating and Using a Static Library in {{CBuilder}}]

[[Category:Windows-Entwicklerhandbuch]]
[[Category:C++]]
[[Category:{{Delphi}}]]

[[en:Building Static Packages]]
[[fr:Construction de packages statiques]]
[[ja:静的パッケージのビルド]]

Multithread-Anwendungen erstellen

2024-10-08T13:35:26Z

Nicolas.rios: removing broken link

{{Parent|So erstellen Sie Multithread-Anwendungen}}

Die Erstellung einer Multithread-VCL-Formularanwendung mit einem Thread-Objekt in {{Variables|Product}} umfasst die folgenden grundlegenden Schritte:

'''Allgemeine Anleitung: So erstellen Sie eine Multithread-Anwendung'''

# Ein VCL-Formular mit einem [[Thread-Objekt definieren|definierten Thread-Objekt]] erstellen.
# [[Threads initialisieren|Den Thread initialisieren]] (optional).
# [[Die Thread-Funktion schreiben|Die Thread-Funktion schreiben]].
# [[Speicherbereinigungscode schreiben|Den Speicherbereinigungscode verfassen]] (optional).

==Themen==

* [[Thread-Objekt definieren|Thread-Objekt definieren]]
* [[Threads initialisieren|Threads initialisieren]]
* [[Die Thread-Funktion schreiben (Anleitung)|Die Thread-Funktion schreiben (Anleitung)]]
* [[Speicherbereinigungscode schreiben|Speicherbereinigungscode schreiben]]

==Siehe auch==

*[[Überblick zu VCL|Überblick zu VCL]]

[[Category:Mit Delphi für Windows arbeiten]]
[[Category:Delphi]]

[[en:Building a Multithreaded Application]]
[[fr:Construction d'une application multithread]]
[[ja:マルチスレッドアプリケーションを構築する]]

64-Bit-Windows-Anwendungsentwicklung

2024-10-04T14:29:33Z

Nicolas.rios: /* Siehe auch */

{{Parent|Geräteübergreifende Anwendungstypen, die erstellt werden können}}

{{Delphi}} und {{CBuilder}} unterstützen die Entwicklung von '''64-Bit-Windows'''-Anwendungen auf einem Win64- oder einem nativen Win32-Entwicklungssystem.
{{f|vcl| 

==FMX, VCL und RTL unterstützen die 64-Bit-Windows-Anwendungsentwicklung==

Die drei Bibliotheken in {{Variables|Product}} unterstützen Win32 und Win64 wie folgt:

* Die {{FM}}-Bibliothek (FMX) unterstützt alle [[Unterstützte Zielplattformen|unterstützten Zielplattformen]].
* Die VCL und die RTL wurden so geändert, dass sie mit 64-Bit-Anwendungen genauso wie mit 32-Bit-Anwendungen arbeiten. Wenn Sie nur die VCL und RTL verwenden, können Sie denselben Quellcode auf Win64- und Win32-Plattformen ausführen.

| 

==FMX und RTL unterstützen die 64-Bit-Windows-Anwendungsentwicklung==

Die zwei Bibliotheken in {{Variables|Product}} unterstützen Win32 und Win64 wie folgt:

* Die {{FM}}-Bibliothek (FMX) unterstützt alle [[Unterstützte Zielplattformen|unterstützten Zielplattformen]].
* Die RTL wurden so geändert, dass sie mit 64-Bit-Anwendungen genauso wie mit 32-Bit-Anwendungen arbeitet. Wenn Sie nur die RTL verwenden, können Sie denselben Quellcode auf Win64- und Win32-Plattformen ausführen.

}}

==Für 32-Bit-Windows und 64-Bit-Windows sind eigene ausführbare Dateien erforderlich==

Für visuelle Komponenten müssen Sie zwei separate Anwendungen compilieren und jede für eine andere Zielplattform konfigurieren – eine Anwendung für Win32 und eine für Win64. Sie erhalten dann eine EXE für Win32 und eine weitere EXE für Win64, jede ist so konfiguriert, dass im [[Projekte-Fenster|Projekte-Fenster]] die jeweils passende '''Zielplattform''' zugeordnet wird. Komponenten, Packages und Bibliotheken, die Sie während des Entwurfs verwenden, müssen als Win32-Versionen und als 64-Bit-Versionen vorliegen.

==Konfigurieren einer 64-Bit-Windows-Anwendung in der IDE==

Für die [[Aktivieren und Konfigurieren der Zielplattform|Zielplattform 64-Bit-Windows]] müssen Sie in der '''[[Projekte-Fenster#Kontextmenü für Zielplattformen|Projektverwaltung]]''' dem Knoten '''Zielplattformen''' die Plattform '''64-Bit-Windows''' hinzufügen (oder aktivieren, falls sie bereits hinzugefügt ist):

[[Image:ActiveWindows64Platform.png]]

Wenn Sie einen Entwicklungs-PC mit 32-Bit-Windows verwenden, können Sie Anwendungen für die 64-Bit-Windows-Plattform mithilfe eines Remote-64-Bit-Windows-Systems ausführen, debuggen und bereitstellen: [[Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC|Erstellen Sie in der IDE ein Verbindungsprofil]], in dem die Verbindung zu dem 64-Bit-Windows-Ziel definiert ist, und [[Aktivieren und Konfigurieren der Zielplattform#Konfigurieren einer Zielplattform|weisen Sie dieses Verbindungsprofil]] im '''[[Projekte-Fenster|Projekte-Fenster]]''' der 64-Bit-Windows-Zielplattform zu.

Für einen Entwicklungs-PC mit 64-Bit-Windows ist die Verwendung eines Verbindungsprofils optional und nicht erforderlich.

===64-Bit-Windows-Anwendungen verwenden die übliche Windows-API===

Wenn Sie mit der Windows-API für die 32-Bit-Windows-Anwendungsentwicklung gearbeitet haben, sollten Sie mit vielen der Windows-API-Funktionen vertraut sein, die für die 64-Bit-Windows-Anwendungsentwicklung verfügbar sind.

==Für das Ausführen, Debuggen und Bereitstellen ist Win64 erforderlich==

Die Win64-Anwendungsentwicklung in {{Variables|Product}} ist per Definition eine plattformübergreifende Entwicklung, weil die IDE eine Win32-Anwendung ist. Das bedeutet, dass Sie bei der Ausführung einer Anwendung für die '''64-Bit-Windows'''-Zielplattform im Grunde die [[Bereitstellung von geräteübergreifenden Anwendungen|Anwendung auf der Win64-Plattform bereitstellen]]. Daher muss zur Laufzeit Ihr Entwicklungssystem entweder 64-Bit-Windows sein oder mit einem Win64-System verbunden sein.

Es gibt – abhängig davon, ob auf Ihrem Entwicklungs-PC 64-Bit- oder 32-Bit-Windows ausgeführt wird – zwei Szenarien zum Ausführen, Debuggen und Bereitstellen einer 64-Bit-Windows-Anwendung.

===Verwenden eines 64-Bit-Windows-Entwicklungssystems===

Wenn Ihr Entwicklungs-PC ein 64-Bit-Computer mit 64-Bit-Windows ist, können Sie Anwendungen genauso ausführen, debuggen und bereitstellen wie bei einer 32-Bit-Windows-Anwendung ohne den '''Platform Assistant''' und ohne ein Verbindungsprofil. Die Verwendung des '''Platform Assistant''' und eines Verbindungsprofils ist für 64-Bit-Windows-Entwicklungssysteme optional, ermöglicht aber die Verwendung des '''[[Bereitstellungs-Manager|Bereitstellungs-Managers]]''' für die Weitergabe Ihrer Anwendung.

===Verwenden eines 32-Bit-Windows-Entwicklungssystems===

Zum Ausführen, Debuggen oder Bereitstellen einer 64-Bit-Windows-Anwendung mit der IDE auf einem '''32-Bit-Windows-Entwicklungssystem''' ist Folgendes erforderlich:

* [[Installieren des Platform Assistant unter Windows|Installieren]] Sie den "Platform Assistant" und [[Ausführen des Platform Assistant unter Windows|führen]] Sie ihn auf dem 64-Bit-Windows-Zielsystem aus.
* [[Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC|Erstellen Sie ein Verbindungsprofil]] auf dem Win32-Entwicklungssystem, das die Verbindung zu PAServer auf dem 64-Bit-Windows-Zielsystem beschreibt.
*[[Aktivieren und Konfigurieren der Zielplattform#Konfigurieren einer Zielplattform|Weisen Sie dieses Verbindungsprofil der 64-Bit-Windows-Zielplattform]] im '''[[Projekte-Fenster|Projekte-Fenster]]''' zu.

Weitere Einzelheiten zur Verwendung des '''Platform Assistant''' und von Verbindungsprofilen finden Sie unter [[Schritte bei der Entwicklung von geräteübergreifenden Anwendungen|Schritte bei der Entwicklung von geräteübergreifenden Anwendungen]].

Sie können eine Verbindung zu einem 64-Bit-Windows-PC entweder mit einem Standard-Ethernet-LAN oder einer '''Remote-Desktop-Verbindung''' herstellen.

{{Note| Wenn die Windows-Firewall auf dem Win64-Ziel aktiviert ist, erhalten Sie möglicherweise bei der ersten Verbindung von PAServer mit dem Win64-Ziel eine Meldung der Windows-Firewall. Klicken Sie auf '''Zugriff zulassen''' (und belassen Sie "Private Netzwerke" unter "Kommunikation von paserver.exe unter diesen Netzwerken zulassen" aktiviert).}}

===Debuggen einer 64-Bit-Windows-Anwendung===

Im Allgemeinen ist das Debuggen einer 64-Bit-Windows-Anwendung in {{Variables|Product}} dem Debuggen einer 32-Bit-Windows-Anwendung sehr ähnlich. Es gibt nur wenige Unterschiede. Z. B. sind die CPU-Fenster, wie die [[FPU|FPU-Ansicht]], unterschiedlich.

* Beim Debuggen einer C++-Anwendung für 64-Bit-Windows sind einige Debugger-Funktionen nicht verfügbar. Weitere Informationen finden Sie in den Debugger-Hinweisen unter '''[[Debuggen von C++Builder-Anwendungen für 64-Bit-Windows|Debuggen von C++-Builder-Anwendungen für 64-Bit-Windows]]'''.

* Bei einem 64-Bit-Windows-Entwicklungssystem können Sie die 64-Bit-Windows-Anwendungen auf dem Entwicklungssystem [[Start|ausführen und debuggen]] und müssen über keine Verbindung zu einem separaten Zielsystem verfügen.
* Auf einem 32-Bit-Windows-Entwicklungssystem muss {{Variables|Product}} die 64-Bit-Windows-Anwendung '''bereitstellen''', damit sie gedebuggt werden kann. Das heißt, Sie müssen zur Laufzeit über eine Live-Verbindung zu einem 64-Bit-Windows-System verfügen.

Weitere Informationen finden Sie unter [[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen]].

===Bereitstellen einer 64-Bit-Windows-Anwendung===

* Wenn Sie den [[PAServer: Die Platform Assistant Server-Anwendung|Platform Assistant]] und ein [[Verbindungsprofil-Manager|Verbindungsprofil]] verwenden, können Sie 64-Bit-Windows-Anwendungen mit dem [[Bereitstellungs-Manager|Bereitstellungs-Manager]] bereitstellen.
* Wenn Sie den [[Bereitstellungs-Manager|Bereitstellungs-Manager]] auf einem 64-Bit-Windows-Entwicklungssystem verwenden möchten, müssen Sie ein Verbindungsprofil erstellen, das das Zielsystem für die Bereitstellung beschreibt.

Weitere Informationen finden Sie unter [[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen]].

===Benutzerdefinierter Port für den Win64-Debugger===

Die IDE und der Win64-Debugger kommunizieren über ein Socket. Wenn dieses verwendet wird, wird beim Starten des Debuggens eine Fehlermeldung angezeigt.

Wenn WSL2 (Windows Subsystem für Linux) installiert ist, schlägt der Win64-Debugger fehl. Die zugehörige Fehlermeldung lautet: ''Prozess kann nicht erzeugt werden'' oder ''Der Port wird verwendet''.
Um dieses oder ähnliche Probleme zu beheben, definieren Sie die Umgebungsvariable <code>DBK_DEBUG_PORT <port-number></code> zum Überschreiben der Standard-Portnummer.

Weitere Informationen finden Sie unter [[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen]].

==Überlegungen für 64-Bit-Anwendungen==

===Für 64-Bit-Windows-Komponenten, -Packages und -Bibliotheken sind 32-Bit-Entwurfszeitversionen erforderlich===

Wenn Sie 64-Bit-Windows-Komponenten, -Packages oder -Bibliotheken erstellen, müssen Sie über deren 32-Bit-Windows-Entwurfszeitversionen verfügen, damit Sie diese Komponenten, Packages und Bibliotheken während der Anwendungsentwicklung in der IDE verwenden können. Dies ist erforderlich, weil die IDE ein 32-Bit-Windows-Programm ist.

Wenn Sie beispielsweise den Experten [[Neue Komponente|Neue Komponente]] verwenden, müssen Sie zunächst eine 32-Bit-Windows-Version Ihrer Komponente erstellen. Später compilieren Sie Ihre Komponente erneut als eine Win64-Komponente, indem Sie die '''Zielplattform''' auf 64-Bit-Windows festlegen (im [[Projekte-Fenster|Projekte-Fenster]]). {{Product}} speichert die Ausgabedateien (wie .bpl und .dcp) in plattformspezifischen Verzeichnissen in Ihrem Projektausgabeverzeichnis.

===Erzeugen und Importieren von 64-Bit-Typbibliotheken===

In einer 64-Bit-Windows-Anwendung (wie z. B. einige 64-Bit-Anwendungen von MS Office) kann eine 32-Bit-Windows-Typbibliothek verwendet werden.

Wenn die aktuelle Zielplattform 64-Bit-Windows ist, übergibt die IDE jetzt "-E64" an '''[[GenTLB.exe|GenTLB.exe]]'''. Das Ergebnis ist eine Typbibliothek, deren Feld SYSKIND '''SYS_WIN64''' enthält (im Vergleich zu SYSKIND=SYS_WIN32 für eine 32-Bit-Windows-Typbibliothek).

Wenn Sie eine 64-Bit-Windows-Typbibliothek importieren, die von einer anderen nur in den 64-Bit-Windows-Schlüsseln der Registrierung registrierten Typbibliothek abhängt, müssen Sie die 64-Bit-Windows-Version von '''[[TLIBIMP.EXE|TLIBIMP.EXE]]''' aus dem folgenden Verzeichnis verwenden:

: {{Path|{{InstallPath}}\bin64\tlibimp.exe}}

Informationen für {{CBuilder}} finden Sie unter [[Migrieren von C++-Code von import nach TLIBIMP.EXE|Migrieren von C++-Code von #import nach TLIBIMP.EXE]].

===Verfügbarkeit von Komponenten zur Entwurfs- und Laufzeit===

Die IDE stellt anhand der beiden folgenden Methoden fest, ob eine Komponente für die jeweilige Plattform verfügbar ist. (Hier bedeutet "verfügbar", dass die Komponente in der Palette angezeigt und von der IDE überprüft wird. Die IDE führt beim Compilieren lediglich eine Prüfung auf Vorhandensein der Komponenten-Unit durch.)

Die beiden hier beschriebenen Methoden beziehen sich auf Daten, die im Win32-Laufzeit-Package (oder Entwurfszeit- und Laufzeit-Package) eingebettet sind, das die Komponenten implementiert. Die IDE kann keine Packages in die IDE laden, die nicht für die Win32-Plattform erzeugt wurden, daher muss die IDE die benötigten Informationen aus dem Win32-Package verwenden.

* Das Build-System von {{Product}} bettet automatisch eine RC_DATA-Ressource ('''PLATFORMTARGETS''') in die binäre Win32-Package-Datei ein. Dabei handelt es sich um die Bitmaske der pidXXX-Konstanten aus der Unit System.Classes.pas und diese gibt die Zielplattformen des Package-Projekts an. Die IDE liest diese Ressource beim Laden des Package und legt beispielsweise anhand der Ressourcendaten fest, ob die Komponente/Komponenten in der Palette deaktiviert wird/werden, wenn eine nicht unterstützte Plattform aktiv ist.

: Wenn ein Komponenten-Package für mehrere Plattformen eingesetzt werden soll, schließt dies eine "Vereinbarung" zwischen dem Komponentenentwickler und der IDE ein. Wenn ein Komponenten-Package-Projekt für mehrere Plattformen eingesetzt werden soll und der Entwickler das Win32-Laufzeit-Package (und alle zugehörigen compilierbaren und linkbaren Dateien) an Kunden weitergibt, wird davon ausgegangen, dass der Entwickler auch alle erforderlichen compilierbaren, linkbaren und Laufzeitbestandteile für die anderen Zielplattformen weitergibt.

* Einzelne Komponenten können mit dem Klassenattribut '''ComponentPlatformsAttribute''' die Daten in PLATFORMTARGETS anhand einer Bitmaske derselben Konstanten aus der Unit Classes überschreiben. Zum Beispiel:

<source lang="delphi">
type
[ComponentPlatformsAttribute(pidWin32 or pidWin64)] // Only supported on Win32 and Win64
TMyComponent = class(TComponent)
private
...
end;
</source>

:Die Verwendung des Attributs '''ComponentPlatformsAttribute''' unterliegt auch der oben beschriebenen Vereinbarung.

===Windows-Programmierung===

* Windows-API-Aufrufe müssen 64-Bit-Versionen sein.
** Try-Blöcke werden in 64-Bit-Windows-Programmen unterstützt.
** Sie können 32-Bit- und 64-Bit-Windows-Code nicht in demselben Prozess verwenden.
* Für DLLs, Komponenten, Bibliotheken und Packages ist es erforderlich, dass Sie separate 32-Bit-Windows-Versionen (Entwurfszeit) und 64-Bit-Windows-Versionen (Laufzeit) compilieren oder installieren, wenn Sie den [[Formular-Designer|Formular-Designer]] verwenden möchten.
* 64-Bit-Windows ist für Betriebssystem- und Shell-Erweiterungen erforderlich.
* Die Größe von LRESULT, WPARAM und LPARAM wird auf 64 Bit erweitert, daher müssen Botschaftsbehandlungsroutinen bezüglich ungeeigneter Typumwandlungen überprüft werden.

==Themen zu 64-Bit-Windows==

*'''Vorbereiten der Entwicklungsumgebung (nur wenn das Entwicklungssystem Win32 ist): '''
**
*** [[Installieren des Platform Assistant unter Windows|Installieren des Platform Assistant unter Windows]]
*** [[Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC|Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC]]
*** [[Ausführen des Platform Assistant unter Windows|Ausführen des Platform Assistant unter Windows]]
*'''Erstellen und Ausführen von Win64-Anwendungen:'''
** [[64-Bit-Windows-Anwendung Hello World (Delphi und C++)|64-Bit-Windows-Anwendung "Hello World" ({{Delphi}} und C++)]]
** [[64-Bit-Windows-Datentypen im Vergleich zu 32-Bit-Windows-Datentypen|64-Bit-Windows-Datentypen im Vergleich zu 32-Bit-Windows-Datentypen]]
** [[Konvertieren von 32-Bit-Delphi-Anwendungen in 64-Bit-Windows|Konvertieren von 32-Bit-Delphi-Anwendungen in 64-Bit-Windows]]
**[[C++Builder-Anwendungsentwicklung für 64-Bit-Windows|C++Builder-Anwendungsentwicklung für 64-Bit-Windows]]
*** [[Unterschiede von C++Builder für 64-Bit-Windows|Unterschiede von C++Builder für 64-Bit-Windows]]
*** [[Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows|Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows]]
*** [[Striktere C++-Compiler (Durch Clang erweiterte C++-Compiler)|Striktere C++-Compiler (Durch Clang erweiterte C++-Compiler)]]
*** [[Debuggen von C++Builder-Anwendungen für 64-Bit-Windows|Debuggen von C++Builder-Anwendungen für 64-Bit-Windows]]

==Siehe auch==

*[[Unterschiede zwischen Windows und macOS|Unterschiede zwischen Windows und macOS]]
* [[Geräteübergreifende Anwendungen entwickeln|Geräteübergreifende Anwendungen entwickeln]]
* [[Compilieren und Erzeugen von geräteübergreifenden Anwendungen|Compilieren und Erzeugen von geräteübergreifenden Anwendungen]]
* [[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen]]
* [[DCC64.EXE: Der Delphi-64-Bit-Befehlszeilen-Compiler|DCC64.EXE: Der Delphi-64-Bit-Befehlszeilen-Compiler]]
* [http://windows.microsoft.com/en-US/windows-vista/32-bit-and-64-bit-Windows-frequently-asked-questions Differences between Win32 and Win64 - FAQ (EN)]
* [http://msdn.microsoft.com/cc300794.aspx Matt Pietriek's Getting Started with 64-Bit (EN)]
* [http://msdn.microsoft.com/7kcdt6fy.aspx MSDN x64 Software Conventions]
* [http://msdn.microsoft.com/tawsa7cb.aspx Low level info on prolog / eplilog]
* [http://msdn.microsoft.com/1eyas8tf.aspx MSDN Exception Handling (x64)]
* [http://msdn.microsoft.com/ff545910.aspx Info about x64 not supporting FPU (EN)]
* [http://msdn.microsoft.com/x4d2c09s.aspx Detailed information about the MSVC x64 command prompts]
* Detaillierte Informationen über PE-Dateiformate von Matt Pietriek
** [http://msdn.microsoft.com/bb985992.aspx http://msdn.microsoft.com/bb985992.aspx (EN)]
** [http://msdn.microsoft.com/cc301808.aspx http://msdn.microsoft.com/cc301808.aspx (EN)]
* Kleine C-Laufzeitbibliothek:
** [http://msdn.microsoft.com/bb985746.aspx http://msdn.microsoft.com/bb985746.aspx (EN)]
** [http://www.codeproject.com/KB/library/tlibc.aspx?fid=332286 http://www.codeproject.com/KB/library/tlibc.aspx?fid=332286 (EN)]
* [http://msdn.microsoft.com/bb985996.aspx Microsoft PE Section names (EN)]
* [http://msdn.microsoft.com/aa366769 C-Compiler Packing Issues (EN)]
* [http://msdn.microsoft.com/aa290049.aspx Windows Data Alignment on IPF, x86, and x64 (from 2006, fairly technical and long) (EN)]

[[Category:Delphi]]
[[Category:64Bit]]
[[Category:XE2]]
[[Category:Geräteübergreifend]]
[[Category:AMMigrate]]

[[en:64-bit Windows Application Development]]
[[fr:Développement d'applications Windows 64 bits]]
[[ja:64 ビット Windows アプリケーション開発]]

Ausführen von Anweisungen (FireDAC)

2024-08-20T23:39:34Z

Nicolas.rios: RS-124097

{{Parent|Arbeiten mit Anweisungen (FireDAC)}} __TOC__

==Verwenden von TFDConnection==

[[lib_de:FireDAC.Comp.Client.TFDConnection|TFDConnection]] stellt [[lib_de:FireDAC.Comp.Client.TFDCustomConnection.ExecSQL|ExecSQL]]-Methoden bereit. Dabei handelt es sich um einfach zu verwendende überladene Methoden, die in folgenden Fällen hilfreich sind:

* Es werden keine Ergebnismengen zurückgegeben.
* Ein SQL-Anweisung wird nur einmal ausgeführt, daher muss sie nicht im vorbereiteten Status gespeichert werden.
* Eine erweiterte Parameterkonfiguration ist nicht erforderlich.
* Eine SQL-Anwendungskonfiguration zur Entwurfszeit ist nicht erforderlich.

Verwenden Sie beispielsweise die folgende Syntax, um DDL-Anweisungen auszuführen:

<source lang="delphi">
FDConnection1.ExecSQL('drop table testtab');
FDConnection1.ExecSQL('create table testtab (id integer, name varchar(10))');
FDConnection1.ExecSQL('insert into testtab values (1, ''FireDAC'')');
</source>

Verwenden Sie die folgende überladene Methode, um eine parametrisierte Abfrage auszuführen:

<source lang="delphi">
FDConnection1.ExecSQL('insert into testtab values (:id, :name)', [1, 'FireDAC']);
</source>

TFDConnection stellt auch [[lib_de:FireDAC.Comp.Client.TFDCustomConnection.ExecSQLScalar|ExecSQLScalar]]-Methoden bereit, die sich von '''ExecSQL'''-Methoden unterscheiden, da sie einen einzelnen Ergebnismengenwert zurückgeben:

<source lang="delphi">
sName := FDConnection1.ExecSQLScalar('select name from testtab where id = :id', [1]);
</source>

==Verwenden von TFDQuery==

Im Allgemeinen wird [[lib_de:FireDAC.Comp.Client.TFDQuery|TFDQuery]] zur Entwurfszeit und/oder zur Laufzeit konfiguriert.

===Konfigurieren von TFDQuery zur Entwurfszeit===

Legen Sie eine TFDQuery-Komponente auf einem Formular ab, um sie zur Entwurfszeit zu konfigurieren. [[lib_de:FireDAC.Comp.Client.TFDRdbmsDataSet.Connection|TFDQuery.Connection]] wird automatisch so festgelegt, dass auf eine TADConnection-Komponente in diesem Formular gezeigt wird, falls eine vorhanden ist. Doppelklicken Sie dann auf TFDQuery, um den Abfrage-Editor von FireDAC aufzurufen:

[[File:AD QueryDlg.png]]

Hier können Sie den SQL-Text und optional Parameter- und Makrowerte angeben und Optionen festlegen.

Drücken Sie die Schaltfläche '''Ausführen''', um den Editor zu schließen. Wenn eine Anweisung eine Ergebnismenge zurückgibt, wird diese im Bereich '''RecordSet''' angezeigt, und die Struktur der Ergebnismenge wird im Bereich '''Struktur''' angezeigt. Wenn das DBMS Meldungen oder Warnungen für eine Anweisung zurückgibt, werden diese im Bereich '''Meldungen''' angezeigt. Mit der Schaltfläche '''Nächstes RecordSet''' können Sie durch alle von einer Anweisung zurückgegebenen Ergebnismengen blättern.

Wenn Sie DML-Anweisungen, wie '''UPDATE'''/'''INSERT'''/'''DELETE''', testen, müssen Sie das Kontrollkästchen '''Automatisch zurücksetzen''' aktivieren, damit die von einer Anweisung durchgeführten Aktionen automatisch zurückgesetzt werden.

Drücken Sie OK, um die Änderungen in TFDQuery zu speichern.

===Verwenden von Parametern===

Die Verwendung von parametrisierten Abfragen ist eins der bewährtesten Verfahren bei der Entwicklung von SQL-Datenbankanwendung. Die Hauptvorteile sind:

* Sie können eine einzelne SQL-Anweisung zusammenstellen und sie mehrmals mit verschiedenen Parameterwerten einsetzen. Das DBMS erstellt den Ausführungsplan für die Anweisung nur einmal. Dadurch wird die Auslastung des DBMS-Moduls reduziert.
* Beim nächsten Ausführen der Anweisung werden nur die Parameterwerte an das DBMS-Modul übertragen. Dadurch wird die Auslastung des Netzwerks reduziert.
* Sie brauchen sich nicht um korrekte SQL-Konstantenformate zu kümmern, z. B. darum, wie in Microsoft Access-SQL eine Datumskonstante richtig angegeben wird.

Verwenden Sie die Syntax ''':<Name>''', um einen Parametermarker im SQL-Text zu setzen. Weisen Sie dann die entsprechenden Werte mit der Params-Sammlung zu. Zum Beispiel:

<source lang="delphi">
FDQuery1.SQL.Text := 'select * from tab where code = :Code';
FDQuery1.ParamByName('code').AsString := '123';
FDQuery1.Open;
</source>

Vor Ausführung der Abfrage müssen alle Parameter ('''Name''', '''DataType''' und '''ParamType''') ausgefüllt werden. Auch '''Position''' sollte festgelegt werden.

Wenn Sie die Eigenschaft SQL zuweisen und '''ResourceOptions.ParamCreate''' '''True''' ist, wird die Params-Sammlung automatisch gefüllt.

{{Note| Nur '''TFDParam.Name''' und '''TFDParam.Position''' sind festgelegt. '''DataType''', '''ParamType''' und andere Eigenschaften müssen in Ihrer Anwendung festgelegt werden. Die Parameter in der Params-Sammlung erscheinen in derselben Reihenfolge wie in der SQL-Anweisung. }}

Sie können die Params-Sammlung auch im Code füllen. Dazu müssen Sie die automatische Parametererstellung durch Setzen von '''ResourceOptions.ParamCreate''' auf '''False''' deaktivieren. Zum Beispiel:

<source lang="delphi">
FDQuery1.ResourceOptions.ParamCreate := False;
FDQuery1.SQL.Text := 'select * from tab where code = :Code';
with FDQuery1.Params do begin
Clear;
with Add do begin
Name := 'CODE';
DataType := ftString;
Size := 10;
ParamType := ptInput;
end;
end;
</source>

Die Parameter können an die SQL-Anweisung entweder per Name oder per Position gebunden werden. Mit der Eigenschaft Params.BindMode können Sie dies steuern:

* '''pbByName'''. Die Parameter in der Params-Sammlung werden durch die Eigenschaft '''Name''' an die entsprechenden Parametermarker gebunden. Wenn die SQL-Anweisung Parametermarker mit gleichen Namen hat, erscheint nur eine Instanz in Params.
* '''pbByNumber'''. Die Parameter in der Params-Sammlung werden durch die Eigenschaft '''Position''' an die entsprechenden Marker im SQL-Anweisungstext gebunden. Wenn die SQL-Anweisung Parametermarker mit gleichen Namen hat, erscheint jedes Vorkommen in Params. Wenn '''Position''' für Parameter nicht festgelegt ist, wird es automatisch bei der Anweisungsvorbereitung mithilfe der Parameterindizes zugewiesen. Die Position beginnt bei 1.

Der Datentyp wird entweder explizit oder implizit durch Zuweisen eines Parameterwertes zur Eigenschaft '''Value''' oder '''AsXxxx''' festgelegt. Andernfalls wird [[lib_de:FireDAC.Stan.Option.TFDFormatOptions.DefaultParamDataType|FormatOptions.DefaultParamDataType]] verwendet.

Wenn '''ParamType''' nicht angegeben ist, wird [[lib_de:FireDAC.Stan.Option.TFDResourceOptions.DefaultParamType|ResourceOptions.DefaultParamType]] verwendet. Standardmäßig sind alle Parameter nur Eingabeparameter. Zur Verwendung von Ausgabeparametern muss ParamType explizit angegeben werden.

Die Eingabeparameterwerte müssen vor Ausführung der Abfrage festgelegt werden. Verwenden Sie dazu eine der folgenden Alternativen:

* Weisen Sie Parameterwerte explizit zu:

<source lang="delphi">
FDQuery1.ParamByName('code').AsString := 'DA1001';
FDQuery1.Open;
</source>

* Verwenden Sie eine der überladenen '''ExecSQL'''- oder '''Open'''-Methoden:

<source lang="delphi">
FDQuery1.Open('', ['DA1001']);
</source>

Um den Parameterwert auf '''Null''' zu setzen, geben Sie den Parameterdatentyp an und rufen dann die Methode '''Clear''' auf:

<source lang="delphi">
with FDQuery1.ParamByName('name') do begin
DataType := ftString;
Clear;
end;
FDQuery1.ExecSQL;
</source>

Auf die Werte der Ausgabeparameter können Sie nach Ausführung der Abfrage zugreifen. Bei einigen SQL-Anweisungen und DBMSs müssen Sie eventuell zuerst alle Ergebnismengen verarbeiten, erst dann können die Werte der Ausgabeparameter abgerufen werden. Mit der Methode [[lib_de:FireDAC.Comp.Client.TFDAdaptedDataSet.GetResults|TFDAdaptedDataSet.GetResults]] können Sie die Übergabe der Ausgabeparameterwerte anfordern. Lesen Sie auch den Artikel [[Einheitliche Unterstützung für RETURNING (FireDAC)|Einheitliche Unterstützung für RETURNING]] über Ausgabeparameter in der RETURNING-Klausel von Firebird und Oracle.

===Vorbereiten der Abfrage===

Bevor eine Abfrage ausgeführt wird, muss sie vorbereitet werden. Dazu führt FireDAC automatisch die folgenden Aktionen durch:

* Versetzen der Verbindung in den [[Herstellen von Verbindungen (FireDAC)|aktiven]] oder [[Offline-Modus von Verbindungen (FireDAC)|Online]]-Status.
* Überprüfen, ob alle Parameter korrekt festgelegt sind.
* [[Vorverarbeiten von Anweisungstext (FireDAC)|Vorverarbeiten des Anweisungstextes]].
* Optional Anwenden von [[lib_de:FireDAC.Stan.Option.TFDFetchOptions.RecsSkip|RecsSkip]] und [[lib_de:FireDAC.Stan.Option.TFDFetchOptions.RecsMax|RecsMax]] für den Anweisungstext.
* Optional Starten einer Transaktion für Firebird/InterBase-DBMSs, wenn keine aktive Verbindung vorhanden ist.
* Übertragen des endgültigen Anweisungstextes an die DBMS-API. Der endgültige Text wird aus der Eigenschaft [[lib_de:FireDAC.Comp.Client.TFDCustomQuery.Text|TFDQuery.Text]] abgerufen.

Während der Vorbereitung der Anweisung muss die Verbindung aktiv sein, und die Abfrage belegt die Serverressourcen. Verwenden Sie die Methoden '''Unprepare''' oder '''Disconnect''', um die Vorbereitung der Abfrage aufzuheben und alle Ressourcen freizugeben.

Wenn eine Anweisung nur einmal ausgeführt werden muss, setzen Sie [[lib_de:FireDAC.Stan.Option.TFDResourceOptions.DirectExecute|ResourceOptions.DirectExecute]] auf '''True'''. Bei einigen DBMSs (SQL Server, SQL Anywhere) wird dadurch die Ausführung beschleunigt, weil die zeitintensive Vorbereitung der SQL-Anweisung vermieden wird.

===Ausführen der Abfrage===

Mit den '''ExecSQL'''-Methoden führen Sie eine Abfrage aus, die keine Ergebnismenge zurückgibt. Wenn eine Abfrage eine Ergebnismenge zurückgibt, wird die Exception '''[FireDAC][Phys][MSAcc]-310. Anweisung, die Ergebnismengen zurückgibt, kann nicht ausgeführt werden''' ausgelöst.

Mit den '''Open'''-Methoden führen Sie eine Abfrage aus, die eine Ergebnismenge zurückgibt, und öffnen diese Ergebnismenge. Wenn eine Abfrage keine Ergebnismengen zurückgibt, wird die Exception '''[FireDAC][Phys][MSAcc]-308. Anweisung, die keine Ergebnismengen zurückgibt, kann nicht geöffnet/definiert werden''' ausgelöst.

Mit der Methode '''OpenOrExecute''' führen Sie eine Ad-hoc-Abfrage aus.

{{Note| Die Abfrage kann [[Asynchrone Ausführung (FireDAC)|asynchron ausgeführt werden]]. Wenn es sich bei der Abfrage um einen Anweisungsstapel handelt, finden Sie unter '''[[Anweisungsstapel (FireDAC)|Anweisungsstapel]]''' Einzelheiten.}}

===Die Exception '''Datentyp des Parameters wurde geändert'''===

Wenn der Parametertyp nach dem ersten Aufruf von Prepare/ExecSQL/Open geändert wird, löst FireDAC beim folgenden Aufruf eine Exception aus:

<source lang="delphi">
[FireDAC][Phys][IB]-338. Parameter [Xxxx] data type is changed.
Query must be reprepared.
</source>

FireDAC speichert beim ersten Aufruf von Prepare/ExecSQL/Open den Datentyp der Parameter. Der Datentyp kann entweder explizit durch Setzen der Eigenschaft '''TFDParam.DataType''' oder implizit durch Zuweisen eines Wertes mit der Eigenschaft '''TFDParam.AsXxxx''' oder '''TFDParam.Value''' angegeben werden. Wenn die Anwendung den Parameterdatentyp vor dem nächsten Aufruf von ExecSQL/Open ändert, wird beim erneuten Aufrufen von ExecSQL/Open die Exception "Datentyp des Parameters [xxxxx] wurde geändert" ausgelöst.

Die Eigenschaft '''TFDParam.Value''' ändert den Parameterdatentyp beim nächsten Aufruf nicht. Sie wandelt den Typ des zugewiesenen Wertes in den aktuellen Datentyp um. Um die obige Exception zu vermeiden, verwenden Sie:

* Den '''TFDParam.Value'''-Eigenschaftswert.
* Die Eigenschaft '''TFDParam.AsXxxx''', wenn '''Xxxx''' beim ersten Aufruf verwendet wurde.

===Abrufen von DBMS-Rückmeldungen===

Mit der Eigenschaft [[lib_de:FireDAC.Comp.Client.TFDRdbmsDataSet.RowsAffected|TFDQuery.RowsAffected]] rufen Sie die Anzahl der von der Anweisung verarbeiteten Zeilen ab (z. B. die Anzahl der durch die Anweisung DELETE gelöschten Zeilen).

{{Note| Bei MS SQL Server kann '''RowsAffected''' gleich -1 sein, wenn bei einer gespeicherten Prozedur oder einem Tabellen-Trigger SET NOCOUNT ON weggelassen wird. Verwenden Sie dann die Eigenschaft '''TFDQuery.RecordCount''' zum Ermitteln der Anzahl der abgerufenen Zeilen. }}

{{Note| FireDAC stellt keine Meldungen über die Anzahl der verarbeiteten Zeilen bereit. Bei Bedarf müssen solche Meldungen in der Anwendung erstellt werden. }}

Wenn die Anweisung einen Fehler zurückgibt, wird eine Exception ausgelöst. Weitere Einzelheiten finden Sie unter [[Fehlerbehandlung (FireDAC)|Fehlerbehandlung]]. Die Exception kann auf eine der folgenden drei Arten verarbeitet werden:

* Verwenden der Konstruktion "try/except/end". Zum Beispiel:

<source lang="delphi">
try
FDQuery1.ExecSQL;
except
on E: EFDDBEngineException do
; // do something here
end;
</source>

* Festlegen der Ereignisbehandlungsroutine [[lib_de:FireDAC.Comp.Client.TFDAdaptedDataSet.OnError|TFDQuery.OnError]].
* Festlegen der Ereignisbehandlungsroutine [[lib_de:FireDAC.Comp.Client.TFDCustomConnection.OnError|TFDConnection.OnError]]. Zum Beispiel:

<source lang="delphi">
procedure TForm1.FDConnection1Error(ASender: TObject; const AInitiator: IFDStanObject;
var AException: Exception);
begin
if (AException is EFDDBEngineException) and (EFDDBEngineException(AException).Kind = ekRecordLocked) then
AException.Message := 'Please, try the operation later. At moment, the record is busy';
end;

FDConnection1.OnError := FDConnection1Error;
</source>

Bei der Array DML ist die Fehlerbehandlung komplexer.

Die Anweisung gibt je nach DBMS Warnungen, Hinweise und Meldungen zurück. Setzen Sie [[lib_de:FireDAC.Stan.Option.TFDTopResourceOptions.ServerOutput|ResourceOptions.ServerOutput]] auf '''True''', um die Meldungsverarbeitung zu aktivieren. Mit der Eigenschaft [[lib_de:FireDAC.Comp.Client.TFDCustomConnection.Messages|TFDConnection.Messages]] werden die Meldungen verarbeitet. Zum Beispiel:

<source lang="delphi">
var
i: Integer;
begin
FDConnection1.ResourceOptions.ServerOutput := True;
FDQuery1.ExecSQL;
if FDConnection1.Messages <> nil then
for i := 0 to FDConnection1.Messages.ErrorCount - 1 do
Memo1.Lines.Add(FDConnection1.Messages[i].Message);
end;
</source>

Einige DBMSs, wie SQL Server, geben Meldungen als weitere Ergebnismenge zurück. Daher muss die Anwendung zum Verarbeiten von Meldungen mehrere Ergebnismengen verarbeiten. Im Folgenden finden Sie ein komplexeres Beispiel, das den Status und die Meldungen für SQL Server bereitstellt. In diesem Beispiel wird '''TFDMemTable''' verwendet, um Ergebnismengen mit Zeilen zu speichern.

<source lang="delphi">
var
i: Integer;
begin
FDConnection1.ResourceOptions.ServerOutput := True;
FDQuery1.FetchOptions.AutoClose := False;
FDQuery1.Open('select * from Region; print ''Hello''');
FDMemTable1.Data := FDQuery1.Data;
Memo1.Lines.Add(Format('%d rows processed', [FDMemTable1.RecordCount]));
FDQuery1.NextRecordSet;
if FDConnection1.Messages <> nil then
for i := 0 to FDConnection1.Messages.ErrorCount - 1 do
Memo1.Lines.Add(FDConnection1.Messages[i].Message);
end;
</source>

==Abfrageausführung und Transaktionen==

Standardmäßig werden alle SQL-Anweisungsausführungen im Modus "Autocommit" durchgeführt. Das heißt, dass diese implizite Transaktion gestartet wird, wenn direkt vor der Anweisungsausführung keine aktive Transaktion vorhanden ist. Ebenso wird die Transaktion direkt nach der Anweisungsausführung beendet:

* durch '''Commit''' bei erfolgreicher Ausführung.
* durch '''Rollback''' bei einem Fehler.

Bei Firebird und InterBase startet eine implizite Transaktion direkt vor der Abfragevorbereitung. Eine einzelne Anweisungsausführung muss nicht in explizite Transaktionen eingeschlossen sein, verwenden Sie einfach den Modus "Autocommit".

==Erweiterte Optionen==

Die meisten Datenbankanwendungen verfügen für die Verwaltung über Backend-Hilfsprogramme, die SQL-Skripte ausführen müssen. Die Zeilen in diesen Skripten entsprechen in gewisser Weise der DBMS-SQL-Skriptsyntax. Verwenden Sie zum Ausführen von [[Ausführen von SQL-Skripten (FireDAC)|SQL-Skripten]] die Komponente [[lib_de:FireDAC.Comp.Script.TFDScript|TFDScript]].

Manchmal führt eine Datenbankanwendung heterogene Abfragen aus, indem Tabellen aus verschiedenen Datenbanken verwendet werden, oder sie führt SQL-Anweisungen für '''TDataSet'''-Nachkommen anstatt für die Datenbanktabellen aus. Verwenden Sie die [[Local SQL (FireDAC)|Local SQL-Engine]] und die Komponente [[lib_de:FireDAC.Phys.SQLiteVDataSet.TFDLocalSQL|TFDLocalSQL]], um solche Abfragen auszuführen.

==Siehe auch==

*[[Ausführen von gespeicherten Prozeduren (FireDAC)|Ausführen von gespeicherten Prozeduren]]
*[[Durchsuchen von Tabellen (FireDAC)|Durchsuchen von Tabellen]]
*[[Anweisungsstapel (FireDAC)|Anweisungsstapel]]
*[[Asynchrone Ausführung (FireDAC)|Asynchrone Ausführung]]
*[[Local SQL (FireDAC)|Local SQL]]

{{DEFAULTSORT:Ausfuhren von Anweisungen (FireDAC)}}
[[Category:FireDAC]]
[[Category:AMMigrate]]

[[en:Executing Commands (FireDAC)]]
[[fr:Exécution des commandes (FireDAC)]]
[[ja:コマンドの実行（FireDAC）]]

Melden eines Fehlers über das Quality Portal von RAD Studio

2024-08-08T23:58:22Z

Nicolas.rios: RS-123874 qp link

{{Parent|Einführung in RAD Studio}}

Wenn Sie bei {{Product}} ein Problem feststellen, können Sie einen Fehlerbericht über unser '''Quality Portal''' unter '''[https://qp.embarcadero.com/ qp.embarcadero.com (EN)]''' einreichen.

Die Quality Portal-Website verwendet das Fehlerverfolgungssystem JIRA, das wir auch intern nutzen. Bitte verwenden Sie das Quality Portal anstatt des alten '''[[Quality Central|Quality Central]]''', auch als QC bezeichnet, das allmählich abgeschafft wird. Beide Websites sind mit unserem internen JIRA-System verbunden.}}

Weitere Informationen über die Verwendung des Quality Portal finden Sie in folgendem Artikel im Embarcadero Developer Network: [http://dn.embarcadero.com/article/44137 http://dn.embarcadero.com/article/44137 (EN)].

==Hotfixes und Workarounds==

Vor dem Melden eines Fehlers über das '''Quality Portal''' sollten Sie einen Blick auf die [[Plat de:Hauptseite|Platformstatus]]-Seite werfen. Auf dieser Seite finden Sie die verfügbare Hotfixes sowie eine Referenzliste aller Plattformen, die von einer bestimmten {{Product}}-Version unterstützt werden.

==Siehe auch==

{{f|qc|

* [[Quality Central|Quality Central]] }}
* [[Interne Fehler beheben (C++)|Interne Fehler beheben (C++)]]

{{DEFAULTSORT:Melden eines Fehlers uber das Quality Portal von RAD Studio}}
[[Category:Delphi]]
[[Category:C++]]
[[Category:Einführung]]
[[Category:AMMigrate]]

[[en:How to File a Bug Using the RAD Studio Quality Portal]]
[[fr:Comment entrer un bogue dans Studio Quality Portal]]
[[ja:RAD Studio 品質ポータルを使用したバグの連絡方法]]

Interne Fehler beheben (C++)

2024-08-08T23:52:07Z

Nicolas.rios: RS-123874 qp link

{{Parent|So verwenden Sie den Debugger}}

==Interne Compiler-Fehler==

Es gibt drei Arten von Fehlern, die der C++-Compiler erzeugt und die als interne Compiler-Fehler eingestuft werden:

*[[F1001 Interner Verarbeitungsfehler im Code-Generator (C++)|F1001 Interner Verarbeitungsfehler im Code-Generator:]]
*:<code>F1001 [C++ Schwerer Fehler] <Dateiname>(<Zeile>)</code>
*[[F1004 Interner Compiler-Fehler (C++)|F1004 Interner Compiler-Fehler:]]
*:<code>F1004 [C++ Schwerer Fehler] <Dateiname>(<Zeile>): </code>
* Interner Backend-Fehler <code>Fehlercode</code>

Alle drei Fehlerarten resultieren aus Fehlern im Compiler. <Dateiname> und <Zeile> geben die Stelle im Quelltext an, die der Compiler vor dem Fehler analysiert hat. Anhand dieser Informationen können Sie möglicherweise die Ursache des Problems ermitteln. <Fehlercode> ist eine spezifische Information, die Compiler-Entwicklern mitteilt, was der Compiler auszuführen versuchte, als der Fehler auftrat.

==Vorgehen bei internen Compiler-Fehlern==

# Ihr Quelltext muss nicht wirklich fehlerhaft sein.
# Versuchen Sie, ein neues, bereinigtes Build auszuführen.{{f|radstudio|
# Versuchen Sie, ein Befehlszeilen-Build auszuführen.}}
# Analysieren Sie den Quelltext, um das Problem einzugrenzen.
# Senden Sie einen Fehlerbericht.

===So führen Sie ein neues, bereinigtes Build aus:===

# Klicken Sie in der Projektverwaltung mit der rechten Maustaste auf das Projekt, und wählen Sie '''Bereinigen'''.
# Überprüfen Sie die Verzeichnisstruktur, um sicherzustellen, dass dem Projekt keine .obj-, .tds-, .dcu-, .#*-, oder .pch-Dateien zugeordnet sind.
# Wählen Sie im Menü "Projekt" den Befehl '''Erzeugen''' aus.

{{f|radstudio|

===So führen Sie ein Befehlszeilen-Build aus:===

# Sie können die Befehlszeile des Compilers aus der Registerkarte "Ausgabe" des Fensters "Meldungen" kopieren und diesen Befehl an der Eingabeaufforderung verwenden oder ...
# Wählen Sie im Startmenü "Rad Studio-Befehlszeile", und geben Sie dann "msbuild IhrProjekt.cbproj" ein.

}}

===So analysieren Sie den Quelltext:===

{{f|radstudio|Wenn das Problem weder durch ein bereinigtes Build noch durch ein Befehlszeilen-Build behoben wurde, sollten Sie den Quelltext analysieren, um das Problem einzugrenzen.}}
{{f|appmethod|Wenn das Problem nicht durch ein bereinigtes Build behoben wurde, sollten Sie den Quelltext analysieren, um das Problem einzugrenzen.}}

#Verarbeiten Sie die in der Fehlermeldung angegebene Datei vor. Klicken Sie dazu in der Projektverwaltung mit der rechten Maustaste auf die Datei, und wählen Sie "Vorverarbeiten"{{f|radstudio|, oder ersetzen Sie in die Befehlszeile im Befehl zum Compilieren der Datei den Compiler (bcc32.exe) durch den Präprozessor (cpp32.exe)}}. Dadurch wird eine Datei ohne externe Abhängigkeiten für die Compilierung erzeugt, die möglicherweise sehr groß ist.
# Compilieren Sie die vorverarbeitete Datei mit der Option -P. Wenn das ausreicht, um das Problem zu reproduzieren, können Sie direkt mit Schritt 4 fortfahren.
# Wenn die .i-Datei korrekt compiliert wird, sind wahrscheinlich weitere Optionen erforderlich, um das Problem zu reproduzieren. Compilieren Sie die .i-Datei erneut, und fügen Sie nacheinander alle Optionen hinzu, die Sie für das ursprüngliche Befehlszeilen-Build verwendet haben, bis Sie feststellen können, welche Optionen zum Reproduzieren des Problems erforderlich sind.
# Diese Informationen sind ausreichend, um einen Fehlerbericht zu senden. Wenn Sie das Problem nicht weiter eingrenzen möchten, fahren Sie bitte mit der Anleitung zum Senden eines Fehlerberichts fort.
# Sie können alles nach der Zeile, in der der Fehler auftritt, und alle Kommentare löschen.
# Beginnen Sie damit, Funktionsrümpfe und andere Codebereiche auszukommentieren, die höchstwahrscheinlich nichts mit dem Problem zu tun haben.
# Wenn Sie Bereiche identifizieren, die zum Reproduzieren des Problems nicht erforderlich sind, können Sie diese Abschnitte aus der .i-Datei löschen.
# Wenn Sie die für das Problem nötigen Elemente eingegrenzt haben, können Sie einen Fehlerbericht senden und den verwendeten Konstrukttyp analysieren, mit dem eine Lösung gefunden werden sollte.

===So senden Sie einen Fehlerbericht:===

# Melden eines neuen Fehlers über das '''Quality Portal''' unter '''[https://qp.embarcadero.com/ qp.embarcadero.com]'''.
# Wählen Sie {{CBuilder}} als Projekt.
# Wählen Sie Compiler/C++ als Bereich.
# Geben Sie die zum Reproduzieren des Fehlers erforderliche Befehlszeile in die Fehlerschritte ein.
# Hängen Sie die .i-Datei an.
# Klicken Sie auf das Häkchen, um den Bericht zu speichern.

==Siehe auch==

* [[Compiler-Fehler und -Warnungen (C++) - Index|Compiler-Fehler und -Warnungen (C++) - Index]]
* [[Interne Fehler beheben (Delphi)|Interne Fehler beheben (Delphi)]]
* [[Melden eines Fehlers über das Quality Portal von RAD Studio|Melden eines Fehlers über das Quality Portal von RAD Studio]]

[[Category:C++]]
[[Category:AMMigrate]]

[[en:Resolving Internal Errors (C++)]]
[[fr:Résolution des erreurs internes (C++)]]
[[ja:内部エラーを解決する（C++）]]

Speichern und Wiederherstellen

2024-07-12T12:39:13Z

Nicolas.rios:

{{Parent|Ein erster Blick auf die IDE}}

{{Menu|Tools > Optionen > IDE > Speichern und Wiederherstellen}}

==Auto-Wiederherstellen==

Die Funktion "Auto-Wiederherstellen" ermöglicht, dass die IDE alle geöffneten Dateien nach einer bestimmten Zeit speichert. Die gespeicherten Dateien können Sie nach einem unerwarteten Schließen der IDE wiederherstellen.

{| border="1" frame="hsides" rules="rows"
|-
!'''Element'''
!'''Beschreibung'''
|- valign="top"
|
Sicherungsdateien regelmäßig für Auto-Wiederherstellen speichern
|
Aktiviert oder deaktiviert die Funktion "Auto-Wiederherstellen".
|- valign="top"
|
Speicherintervall (Minuten)
|
Zeitspanne in Minuten, in der die IDE alle geöffneten Dateien für die Wiederherstellung speichert.
|}

Wenn '''AutoRecover''' aktiviert ist, speichert {{Product}} die Wiederherstellungsdateien im verborgenen Ordner {{Path|_recovery}} im Ordner Ihres Projekts. Im Falle eines unerwarteten Schließens der IDE stellt {{Product}} mit den gespeicherten Dateien die Informationen beim erneuten Öffnen der IDE wieder her.

Führen Sie nach einem unerwarteten Schließen die folgenden Schritte aus, um Ihre Dateien wiederherzustellen:

#Öffnen Sie die IDE.
#Das Fenster '''Dateiwiederherstellung''' wird mit den wiederherstellbaren Dateien angezeigt.
#Doppelklicken Sie auf die Dateien, die Sie wiederherstellen möchten.
#Klicken Sie auf '''Schließen''', um das Fenster "Dateiwiederherstellung" zu schließen.
#Fahren Sie mit dem Speichern Ihrer Dateien nach Bedarf fort.

Wenn Sie das Fenster '''Dateiwiederherstellung''' ohne Wiederherstellung Ihrer Dateien schließen, werden Sie von der IDE gefragt, ob Sie die verbleibenden wiederhergestellten Dateien verwerfen möchten. Klicken Sie auf '''Nein''', wenn Sie diese Dateien später wiederherstellen möchten.

{{Warning|Wenn Sie auf '''Ja''' klicken, verwirft die IDE die Wiederherstellungsdateien, und Sie können die Dateien danach nicht mehr wiederherstellen.}}

:
::[[File:FileRecoverySydney.png|link=]]

==Auto-Speichern==

Mit der Funktion '''Auto-Speichern''' kann die IDE automatisch Dateien und Projekt-Desktop-Einstellungen speichern.

{| border="1" frame="hsides" rules="rows"
|-
!'''Element'''
!'''Beschreibung'''
|- valign="top"
|
Dateien beim Compilieren oder Ausführen speichern
|
Ermöglicht der IDE alle geänderten Dateien automatisch beim Ausführen, Compilieren oder Erzeugen des Projekts oder beim Beenden des Produkts zu speichern.
|- valign="top"
|
Projekt-Desktop beim Schließen speichern
|
Speichert oder aktualisiert automatisch die Projekt-Desktop-Dateien (Dateierweiterung .dsk), wenn Sie das Projekt schließen oder das Produkt beenden.
In der Datei <code><myproject>.dsk</code> werden die aktuellen Einstellungen für Folgendes erfasst:
*Desktop-Layout
*Haltepunkte
*Überwachte Ausdrücke
*Dateien, die aktuell in der IDE geöffnet sind

Wenn '''Projekt-Desktop automatisch speichern''' deaktiviert ist, werden alle vorhandenen .dsk-Projektdateien beim Öffnen des Projekts gelesen, aber sie werden nie aktualisiert. Deshalb wird derselbe Satz von Dateien mit dem Projekt geöffnet, bis die .dsk-Datei manuell von der Festplatte gelöscht wird.
Wenn Sie das Projekt später erneut öffnen, wird die .dsk-Datei gelesen, und das Desktop-Layout, die Haltepunkte und die überwachten Ausdrücke werden wiederhergestellt. Außerdem werden alle Dateien, die beim Schließen des Projekts geöffnet waren, wieder geöffnet, auch wenn sie vom Projekt nicht verwendet werden.
|- valign="top"
|
Zuletzt geöffnetes Projekt beim Starten von RAD Studio erneut öffnen
|
Wenn Sie {{Product}} schließen, während ein Projekt geöffnet ist, merkt sich die IDE dieses Projekt und öffnet es beim nächsten Start von {{Product}} wieder.
Wenn '''Projekt-Desktop beim Schließen speichern''' aktiviert ist, dann wird das Projekt mit demselben Satz von Dateien, Haltepunkten und überwachten Ausdrücken wieder geöffnet, die es beim Beenden von {{Product}} hatte.
|}

==Siehe auch==

*[[Speichern-Befehle|Speichern-Befehle]]
*[[Default Folders|Standardordner]]
*[[Compilierung und Ausführung|Compilierung und Ausführung]]
*[[Komponenten-Symbolleiste|Komponenten-Symbolleiste]]
*[[Umgebungsvariablen|Umgebungsvariablen]]
*[[Dateizuordnung|Dateizuordnung]]
*[[Desktop und Layout|Desktop und Layout]]
*[[Projekt-Upgrade|Projekt-Upgrade]]
*[[LiveBindings-Optionen|LiveBindings]]
*[[GetIt (Optionen)|GetIt-Package-Manager]]

[[en:Saving and Recovering]]
[[fr:Enregistrement et récupération]]
[[ja:保存とリカバリ]]

ALLOWBIND

2024-06-07T15:27:50Z

Nicolas.rios:

{{Parent|Liste der Delphi-Compiler-Direktiven - Index}}

{| border="1" frame="hsides" rules="rows"
|-
| style="text-align: left; vertical-align: top;" |
'''Typ'''
| style="text-align: left; vertical-align: top;" |
Option
|-
| style="text-align: left; vertical-align: top;" |
'''Syntax'''
| style="text-align: left; vertical-align: top;" |
{$ALLOWBIND ON}, {$ALLOWBIND OFF}
|-
| style="text-align: left; vertical-align: top;" |
'''Vorgabe'''
| style="text-align: left; vertical-align: top;" |
{$ALLOWBIND OFF}
|-
| style="text-align: left; vertical-align: top;" |
'''Bereich'''
| style="text-align: left; vertical-align: top;" |
Global
|}

'''Bemerkungen'''

Legt fest, ob eine DLL gebunden werden kann. Die Option '''{$ALLOWBIND}''' setzt ein Bit im Header der DLL, das für die Datei Bind.exe angibt, dass das Image gebunden werden kann. Deaktivieren Sie die Option '''{$ALLOWBIND}''', um zu verhindern, dass Bind.exe die DLL bindet.

{{Note| Wenn ASLR (Address Space Layout Randomization) für das Image aktiviert ist, hat '''{$ALLOWBIND}''' keine Auswirkungen.}}

[[Category:Delphi]]

[[en:ALLOWBIND]]
[[fr:ALLOWBIND]]

Dynamisch ladbare Bibliotheken schreiben

2024-06-06T18:23:15Z

Nicolas.rios: RS-123009

{{Parent|Bibliotheken und Packages - Index}}
<ideTag id="library"></ideTag>
<ideTag id="stdcall"></ideTag>
<ideTag id="register"></ideTag>
<ideTag id="exports"></ideTag>
<ideTag id="local"></ideTag>
<ideTag id="EBX"></ideTag>
<ideTag id="name"></ideTag>
<ideTag id="resident"></ideTag>
<ideTag id="DllProc"></ideTag>
<ideTag id="IsLibrary"></ideTag>
<ideTag id="HInstance"></ideTag>
<ideTag id="DLL_PROCESS_DETACH"></ideTag>
<ideTag id="FreeLibrary"></ideTag>
<ideTag id="DLL_PROCESS_ATTACH"></ideTag>
<ideTag id="LoadLibrary"></ideTag>
<ideTag id="DLL_THREAD_ATTACH"></ideTag>
<ideTag id="DLL_THREAD_DETACH"></ideTag>
<ideTag id="$OEEDFADE"></ideTag>
<ideTag id="ExceptionInformation"></ideTag>
<ideTag id="GetMem"></ideTag>
<ideTag id="ShareMem"></ideTag>
<ideTag id="BORLANDMM.DLL"></ideTag>
<ideTag id="delayed"></ideTag>

{{Note| Hinsichtlich der Exportmöglichkeiten sind Bibliotheken gegenüber Packages deutlich eingeschränkter.  Bibliotheken können keine Konstanten, Typen und normale Variablen exportieren. Das heißt, dass in einer Bibliothek definierte Klassentypen für ein Programm, das diese Bibliothek verwendet, nicht sichtbar sind.


'''Um andere Elemente als einfache Prozeduren und Funktionen zu exportieren,''' sind '''[[Packages (Delphi)|Packages]]''' die empfohlene Alternative. Bibliotheken sollten nur verwendet werden, wenn eine Interoperabilität mit anderen Programmen erforderlich ist.}}

In den folgenden Abschnitten werden die Elemente beschrieben, die bei der Erstellung einer dynamisch ladbaren Bibliothek zum Einsatz kommen:

* Die exports-Klausel
* Code für die Initialisierung der Bibliothek
* Globale Variablen
* Bibliotheken und Systemvariablen

==Die exports-Klausel==

Die Grundstruktur einer dynamisch ladbaren Bibliothek ist identisch mit der eines Programms. Der einzige Unterschied besteht darin, dass sie nicht mit '''program''', sondern mit dem reservierten Wort '''library''' beginnt.

Andere Bibliotheken und Programme können nur auf die Routinen zugreifen, die eine Bibliothek explizit exportiert. Das folgende Beispiel zeigt eine Bibliothek mit den exportierten Funktionen Min und Max:

library MinMax;
function Min(X, Y: Integer): Integer; stdcall;
begin
if X < Y then Min := X else Min := Y;
end;
function Max(X, Y: Integer): Integer; stdcall;
begin
if X > Y then Max := X else Max := Y;
end;
exports
Min,
Max;
begin
end.

Sie können eine Bibliothek auch Anwendungen zur Verfügung stellen, die in anderen Sprachen geschrieben wurden. Für diesen Zweck ist es am sichersten, wenn Sie in den Deklarationen exportierter Funktionen die Direktive '''stdcall''' angeben. Die standardmäßig verwendete {{Delphi}}-Aufrufkonvention '''register''' wird nicht von allen anderen Sprachen unterstützt.

Bibliotheken können aus mehreren Units bestehen. In diesem Fall enthält die Quelltextdatei der Bibliothek häufig nur eine '''uses'''-Klausel, eine '''exports'''-Klausel und den Initialisierungscode. Zum Beispiel:

library Editors;
uses EdInit, EdInOut, EdFormat, EdPrint;
exports
InitEditors,
DoneEditors name Done,
InsertText name Insert,
DeleteSelection name Delete,
FormatSelection,
PrintSelection name Print,
.
.
.
SetErrorHandler;
begin
InitLibrary;
end.

Die '''exports'''-Klauseln können in den '''interface'''- oder '''implementation'''-Abschnitt einer Unit eingefügt werden. Alle Bibliotheken mit einer solchen Unit in ihrer '''uses'''-Klausel exportieren automatisch die Routinen, die in der '''exports'''-Klausel der Unit aufgelistet sind, ohne dass eine eigene '''exports'''-Klausel benötigt wird.



Eine Routine wird exportiert, wenn sie in einer '''exports'''-Klausel wie der folgenden angegeben wird:

'''exports''' ''Eintritt1'', ..., ''Eintrittn'';

''Eintritt'' steht für den Namen einer Prozedur, Funktion oder Variable, die vor der '''exports'''-Klausel deklariert werden muss. Darauf folgt eine Parameterliste (nur beim Exportieren einer überladenen Routine) und ein optionaler '''name'''-Bezeichner. Der Name der Prozedur oder Funktion kann mit dem Namen einer Unit qualifiziert werden.

(Eintrittspunkte können außerdem die Direktive '''resident''' enthalten, die der Abwärtskompatibilität dient und vom Compiler ignoriert wird.)

Der Bezeichner '''index''' (nur Win32) besteht aus der Direktive '''index''' und einer numerischen Konstante von 1 bis 2.147.483.647 (je niedriger die Konstante, desto effizienter das Programm). Ist kein '''index'''-Bezeichner angegeben, wird der Routine in der Exporttabelle automatisch eine Nummer zugewiesen.

{{Note| Der Bezeichner '''index''' dient lediglich der Abwärtskompatibilität und sollte nach Möglichkeit nicht verwendet werden, da er in anderen Entwicklungstools zu Problemen führen kann.}}

Ein '''name'''-Bezeichner besteht aus der Direktive '''name''' und einer nachfolgenden String-Konstante. Verfügt ein Eintrittspunkt über keinen '''name'''-Bezeichner, wird die Routine unter ihrem ursprünglich deklarierten Namen (in derselben Schreibweise) exportiert. Verwenden Sie die '''name'''-Klausel, wenn Sie eine Routine unter einem anderen Namen exportieren wollen. Zum Beispiel:

exports
DoSomethingABC name 'DoSomething';

Wenn eine überladene Funktion oder Prozedur aus einer dynamisch ladbaren Bibliothek exportiert wird, muss die '''exports'''-Klausel die zugehörige Parameterliste enthalten. Zum Beispiel:

exports
Divide(X, Y: Integer) name 'Divide_Ints',
Divide(X, Y: Real) name 'Divide_Reals';

In Win32 dürfen überladene Routinen keine '''index'''-Bezeichner enthalten.

Die '''exports'''-Klausel kann im Deklarationsteil des Programms oder der Bibliothek bzw. im '''interface'''- oder '''implementation'''-Abschnitt einer Unit an beliebigen Stellen und beliebig oft angegeben werden. Programme enthalten nur selten eine '''exports'''-Klausel.

==Code für die Initialisierung der Bibliothek==

Die Anweisungen im Block einer Bibliothek bilden den Initialisierungscode der Bibliothek. Diese Anweisungen werden nur einmal beim Laden der Bibliothek ausgeführt. Mit diesen Anweisungen werden beispielsweise Fensterklassen registriert und Variablen initialisiert. Außerdem kann der Initialisierungscode einer Bibliothek mithilfe der Variablen DllProc eine Eintrittspunkt-Prozedur installieren. Die Variable DllProc ist einer Exit-Prozedur ähnlich, die im Abschnitt "Exit-Prozeduren" beschrieben wird. Die Eintrittspunkt-Prozedur wird beim Laden oder Entladen der Bibliothek ausgeführt.

Der Initialisierungscode einer Bibliothek kann einen Fehler signalisieren. Zu diesem Zweck wird der Variable ExitCode ein Wert zugewiesen, der ungleich Null ist. ExitCode ist in der Unit System deklariert und hat den Standardwert Null. Dieser Wert gibt an, dass die Initialisierung erfolgreich war. Wenn der Initialisierungscode der Bibliothek der Variable ExitCode einen anderen Wert zuweist, wird die Bibliothek aus dem Speicher entfernt, und die aufrufende Anwendung wird über den Fehler benachrichtigt. Tritt während der Ausführung des Initialisierungscodes eine nicht behandelte Exception auf, wird die aufrufende Anwendung über einen Fehler beim Laden der Bibliothek benachrichtigt.

Hier ein Beispiel für eine Bibliothek mit Initialisierungscode und einer Eintrittspunkt-Prozedur:

library MyDll;
uses
System.SysUtils,
System.IOUtils,
{$IFDEF MSWINDOWS}
Windows,
{$ENDIF}
CrossPlatform.Methods in 'CrossPlatform.Methods.pas';
{$R *.res}

exports
//mac requires _understaore methods in the export or it will not find the entrypoint
{$IFDEF MACOS}
_myMethod
{$ELSE}
MyMethod
{$ENDIF}

{$IFDEF MSWINDOWS}
//unload windows method here
var
SaveDllProc: TDLLProc;

procedure LibExit(Reason: Integer);
begin
if Reason = DLL_PROCESS_DETACH then
begin
//unload code
end;

if Assigned(SaveDllProc) then
SaveDllProc(Reason); // Call the saved entry point procedure
end;
{$ENDIF}

begin

{$IFDEF MSWINDOWS}
SaveDllProc := DllProc; // Save the original DLL procedure
DllProc := @LibExit; // Set our exit procedure
{$ENDIF}

// Any additional library initialization code
end.

DllProc wird immer dann aufgerufen, wenn die Bibliothek das erste Mal in den Speicher geladen wird, wenn ein Thread gestartet oder angehalten wird, oder wenn die Bibliothek aus dem Speicher entfernt wird. Die Initialisierungsteile aller von einer Bibliothek verwendeten Units werden vor dem Initialisierungscode der Bibliothek, die '''finalization'''-Abschnitte nach der Eintrittspunkt-Prozedur der Bibliothek ausgeführt.

==Globale Variablen in einer Bibliothek==

In einer gemeinsamen Bibliothek deklarierte globale Variablen können von {{Delphi}}-Anwendungen nicht importiert werden.

Eine Bibliothek kann von mehreren Anwendungen gleichzeitig genutzt werden. Jede Anwendung verfügt aber in ihrem Verarbeitungsbereich über eine Kopie der Bibliothek mit einem eigenen Satz globaler Variablen. Damit mehrere Bibliotheken (oder mehrere Instanzen einer Bibliothek) den Speicher gemeinsam nutzen können, müssen Speicherzuordnungstabellen verwendet werden. Weitere Informationen zu diesem Thema finden Sie in der Systemdokumentation.

==Bibliotheken und Systemvariablen==

Einige der in der Unit System deklarierten Variablen sind für Programmierer von Bibliotheken von besonderem Interesse. Mit '''IsLibrary''' können Sie feststellen, ob der Code in einer Anwendung oder in einer Bibliothek ausgeführt wird. '''IsLibrary''' ist in einer Anwendung immer '''False''', in einer Bibliothek dagegen immer '''True'''. Während der Lebensdauer einer Bibliothek enthält die Variable HInstance das Instanzen-Handle der Bibliothek. Die Variable CmdLine ist in einer Bibliothek immer '''nil'''.

Die Variable <codeInline>DllProc</codeInline> ermöglicht einer Bibliothek die Überwachung der Betriebssystemaufrufe an ihrem Eintrittspunkt. Diese Möglichkeit wird normalerweise nur von Bibliotheken verwendet, die Multithreading unterstützen. DLLProc wird in Multithread-Anwendungen eingesetzt.  Es empfiehlt sich, alle Abläufe bei der Programmbeendigung nicht über Exit-Prozeduren, sondern über '''finalization'''-Abschnitte zu steuern.

Für die Überwachung von Betriebssystemaufrufen erstellen Sie eine Callback-Prozedur mit einem Integer-Parameter. Beispiel:

procedure DLLHandler(Reason: Integer);

Außerdem müssen Sie der Variable DLLProc die Adresse der Prozedur zuweisen. Beim Aufruf der Prozedur wird ihr einer der folgenden Werte übergeben:

{| border="1" frame="hsides" rules="rows"
| align="left" valign="top" |
DLL_PROCESS_DETACH
| align="left" valign="top" |
Gibt an, dass die Bibliothek als Ergebnis einer Beendigungsprozedur oder eines Aufrufs von FreeLibrary vom Adressraum des aufrufenden Prozesses getrennt wird.
|-
| align="left" valign="top" |
DLL_PROCESS_ATTACH
| align="left" valign="top" |
Gibt an, dass die Bibliothek eine Verbindung mit dem Adressraum des aufrufenden Prozesses herstellt. Dies ergibt sich aus einem Aufruf von LoadLibrary.
|-
| align="left" valign="top" |
DLL_THREAD_ATTACH
| align="left" valign="top" |
Gibt an, dass der aktuelle Prozess einen neuen Thread erstellt.
|-
| align="left" valign="top" |
DLL_THREAD_DETACH
| align="left" valign="top" |
Gibt an, dass ein Thread ohne Probleme beendet wurde.
|}

Sie können die Aktionen im Rumpf der Prozedur davon abhängig machen, welcher Parameter an die Prozedur übergeben wird.

==Exceptions und Laufzeitfehler in Bibliotheken==

Wenn in einer dynamisch ladbaren Bibliothek eine Exception erzeugt, aber nicht behandelt wird, wird sie nach außen an den Aufrufer weitergegeben. Wenn die aufrufende Anwendung oder Bibliothek in {{Delphi}} geschrieben wurde, kann die Exception in einer normalen '''try...except'''-Anweisung behandelt werden.

In Win32 kann die Exception wie eine Betriebssystem-Exception mit dem Code $0EEDFADE behandelt werden, wenn die aufrufende Anwendung oder Bibliothek in einer anderen Programmiersprache entwickelt wurde. Der erste Eintrag im Array ExceptionInformation des Records mit der Betriebssystem-Exception enthält die Exception-Adresse, der zweite Eintrag eine Referenz auf das Exception-Objekt von {{Delphi}}.

Normalerweise sollten Exceptions innerhalb der Bibliothek behandelt werden. {{Delphi}}-Exceptions entsprechen dem Exception-Modell des Betriebssystems.

Wenn in einer Bibliothek die Unit SysUtils nicht verwendet wird, ist die Unterstützung von Exceptions deaktiviert. Tritt in diesem Fall in der Bibliothek ein Laufzeitfehler auf, wird die aufrufende Anwendung beendet. Da die Bibliothek nicht feststellen kann, ob sie von einem {{Delphi}}-Programm aufgerufen wurde, kann sie auch nicht die Exit-Prozeduren der Anwendung aufrufen. Die Anwendung wird einfach beendet und aus dem Speicher entfernt.

==Der Shared Memory Manager ==

Wenn eine DLL in Win32 Routinen exportiert, die lange Strings oder dynamische Arrays als Parameter oder als Funktionsergebnis übergeben (entweder direkt oder in Records bzw. Objekten), müssen die DLL und ihre Client-Anwendungen (oder -DLLs) die Unit '''ShareMem''' verwenden. Dasselbe gilt, wenn eine Anwendung oder DLL mit New oder GetMem Speicherplatz reserviert, der in einem anderen Modul durch einen Aufruf von '''Dispose''' oder '''FreeMem''' wieder freigegeben wird. '''ShareMem''' sollte in der '''uses'''-Klausel der Programme oder Bibliotheken, von denen sie eingebunden wird, immer an erster Stelle stehen.

'''ShareMem''' ist die Interface-Unit für den Speichermanager BORLANDMM.DLL, der es Modulen ermöglicht, dynamisch zugewiesenen Speicherplatz gemeinsam zu nutzen. BORLANDMM.DLL muss mit Anwendungen und DLLs weitergegeben werden, die '''ShareMem''' einbinden. Wenn eine Anwendung oder DLL '''ShareMem''' verwendet, ersetzt BORLANDMM.DLL den Speichermanager dieser Anwendung oder DLL.

==Siehe auch==

* [[Bibliotheken und Packages (Delphi)]]
* [[Packages (Delphi)]]

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

[[en:Writing Dynamically Loaded Libraries]]
[[fr:Ecriture de bibliothèques à chargement dynamique]]
[[ja:動的にロードされるライブラリの作成]]

TProc

2024-05-28T13:59:55Z

Nicolas.rios: RS-121780

{{Parent|Index}}

{{Redirect|lib_de:System.SysUtils.TProc|System.SysUtils.TProc}}

[[Category:Berlin]]

[[en:TProc]]
[[fr:TProc]]
[[ja:TProc]]

Mobile iOS-Anwendungsentwicklung

2024-05-21T13:44:15Z

Nicolas.rios: RS-122759

{{Parent|Geräteübergreifende Anwendungstypen, die erstellt werden können}}
{{DISPLAYTITLE:Mobile iOS-Anwendungsentwicklung}}

{{Product}} enthält Tools für die Entwicklung von Anwendung für die iOS-Zielplattform. Mit [[FireMonkey|FireMonkey]] können Sie eine iOS-Anwendung erstellen und für iOS-Geräte (C++ oder {{Delphi}}) bereitstellen.

Das Verfahren für die Entwicklung von iOS-Apps in {{Product}} ist im Großen und Ganzen identisch mit dem Verfahren für die Entwicklung von Android-Apps in {{Product}}. Ein wichtiger Unterschied besteht darin, dass '''PAServer''' und '''Verbindungsprofile''' für die iOS-Entwicklung erforderlich sind, für die Android-Entwicklung werden sie dagegen nicht benötigt. Sowohl für iOS als auch für Android muss ein SDK für die Zielplattform hinzugefügt werden.

{|
|-
! colspan="2" |'''Vergleich der Entwicklungsanforderungen für iOS und Android'''
|-
! '''iOS-Anforderungen'''
! '''Android-Anforderungen'''
|-
|
'''[[Teilnehmen am Apple-Entwicklerprogramm|Beitreten zum Apple-Entwicklerprogramm]]'''
|
[http://developer.android.com/index.html Die Website für Android-Entwickler ist für jeden zugänglich (EN)]
|-
|
'''[[Erwerben eines iOS-Entwicklerzertifikats|Ein Entwicklerzertifikat erwerben]]'''
|
[[Erstellen einer KeyStore-Datei|KeyStore-Datei erstellen]]
|-
|
'''[[Bereitstellen von iOS-Anwendungen|Ein Bereitstellungsprofil erstellen und installieren]]'''
|
Nicht zutreffend.
|-
|
'''[[Installieren des Platform Assistant auf dem Mac|PAServer auf dem Mac installieren]]'''
|
Nicht zutreffend.
|-
|
'''[[Ausführen des Platform Assistant auf dem Mac|PAServer auf dem Mac ausführen]]'''
|
Nicht zutreffend.
|-
|
'''[[Verbindungsprofil erstellen|Verbindungsprofil erstellen]]'''
|
Nicht zutreffend.
|-
|
'''[[Ausführen von iOS-Anwendungen auf einem iOS-Gerät|Verbindung mit dem iOS-Gerät über eine USB-Verbindung herstellen]]'''
|
[[Installieren des USB-Treibers für Ihr Android-Gerät|Den USB-Treiber für Ihr Android-Gerät installieren]] und Ihr Android-Gerät über eine USB-Verbindung anschließen.
|-
|
'''[[Hinzufügen von SDKs für macOS oder iOS|iOS-SDK (für Geräte oder Simulator) hinzufügen]]'''
|
[[Hinzufügen von Android-SDKs|Ein Android-SDK hinzufügen]]
|-
|
'''Nicht zutreffend.'''
|
Für die Android-Anwendung benötigte [[Verwendet Berechtigungen|Berechtigungen]] überprüfen oder festlegen
|}

==Hardwareanforderungen==

Zusätzlich zu Ihrem Entwicklungs-PC benötigen Sie für die Entwicklung von geräteübergreifenden Anwendungen für iOS Folgendes:

* Einen Mac mit macOS
* Ein iOS-Gerät, das über ein USB-Kabel an den Mac angeschlossen ist

Unter '''[[Plattformvoraussetzungen für FireMonkey|Plattformvoraussetzungen für {{FM}}]]''' finden Sie eine Liste mit den Systemanforderungen für den Entwicklungs-PC sowie für den Mac.

Der Mac und Ihr Entwicklungssystem müssen sich in einem gemeinsamen Netzwerk befinden, z. B. einem LAN (Local Area Network).

==Vorbereiten der Entwicklungsumgebung==

===Arbeiten mit einem Mac und einem PC===

Wenn Sie Anwendungen für iOS entwickeln, müssen Sie zusätzlich zu Ihrer Entwicklungsumgebung einen Mac verwenden, um die iOS-Entwicklungs- und Distributionszertifikate zu installieren, den "Platform Assistant" auszuführen sowie andere erforderliche Aufgaben (siehe die Details unten) durchzuführen.

Ein PC und ein Mac können auf verschiedene Weise für die Zusammenarbeit konfiguriert werden. Unter '''[[Arbeiten mit einem Mac und einem PC|Arbeiten mit einem Mac und einem PC]]''' finden Sie Informationen zur Entscheidung, welche Konfiguration am besten für Sie geeignet ist, und darüber, wie Sie diese Konfiguration für Ihre Entwicklungsumgebung anwenden.

===Konfigurieren des Mac===

Auf dem Mac müssen Sie Folgendes ausführen:

# [[Installieren von Xcode auf einem Mac|Xcode installieren]].
# Die [[Installieren der Xcode-Befehlszeilen-Tools auf einem Mac|Xcode-Befehlszeilentools installieren]], die für die Signierung Ihrer Anwendungen erforderlich sind, damit Sie sie auf einem iOS-Gerät ausführen können.
#: {{Note| Ab Xcode Version 6.1 werden die Xcode-Befehlszeilentools automatisch bei der Xcode-Installation installiert.}}
# Den [[Installieren des Platform Assistant auf dem Mac|Platform Assistant installieren]]. Der '''[[PAServer: Die Platform Assistant Server-Anwendung|Platform Assistant]]''', der mit {{Product}} ausgeliefert wird, ermöglicht der IDE die iOS-SDK-Dateien vom Mac zu übertragen und Ihre Anwendungen auf an den MAC angeschlossenen iOS-Geräten auszuführen.
# Den [[Ausführen des Platform Assistant auf dem Mac|Platform Assistant ausführen]]. Für {{Product}} muss der "Platform Assistant" auf dem Mac ausgeführt werden, damit Anwendungen für die Zielplattformen '''iOS-Gerät - 64 Bit''' ausgeführt, gedebuggt und bereitgestellt werden können.

===Konfigurieren des Entwicklungssystems===

Öffnen Sie auf Ihrem Entwicklungssystem {{Product}}, und führen Sie Folgendes aus:

*'''[[Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC|Erstellen Sie ein Verbindungsprofil]]''' für die '''macOS'''-Plattform. macOS ist eine Zwischenplattform, die die Zielplattform '''iOS-Gerät - 64 Bit''' unterstützt.
** Sie benötigen dieses Verbindungsprofil, damit die IDE eine Verbindung zum '''[[PAServer: Die Platform Assistant Server-Anwendung|Platform Assistant]]''' herstellen kann, der auf dem Mac ausgeführt wird.
* '''[[Hinzufügen von SDKs für macOS oder iOS|Fügen Sie der IDE ein SDK]]''' für die Zielplattform '''iOS-Gerät - 64 Bit''' hinzu. {{Product}} erstellt auf Ihrem Entwicklungssystem einen lokalen Dateizwischenspeicher des iOS-SDK vom Mac, damit Sie Ihre Anwendungen für iOS lokal erzeugen können.

==Entwickeln von Anwendungen==

Wählen Sie zum Erstellen einer neuen geräteübergreifenden Anwendung in {{Product}} entweder {{Menu|Datei > Neu > [[Geräteübergreifende Anwendung|Geräteübergreifende Anwendung]] - {{Delphi}}}} oder {{Menu|Datei > Neu > [[Geräteübergreifende Anwendung|Geräteübergreifende Anwendung]] - {{CBuilderUI}}}}, wählen Sie einen Anwendungstyp aus, und klicken Sie auf '''OK'''. Informationen über die möglichen Anwendungstypen finden Sie unter [[Geräteübergreifende Anwendung#Geräteübergreifende Anwendungstypen, die erstellt werden können|Typen geräteübergreifender Anwendungen, die Sie erstellen können]]. Die Standardzielplattform ist '''[[Mobile Android-Anwendungsentwicklung|Android]]'''. Als Zielplattformen für neue geräteübergreifende Anwendungen stehen aber auch iOS-Plattformen zur Verfügung.

Sie können für die Entwicklung geräteübergreifender Anwendungen sowohl das [[FireMonkey|FireMonkey-Framework]] als auch die [[RTL|RTL-Bibliothek]] verwenden. Siehe '''[[Erstellen von iOS-Apps|Erstellen von iOS-Apps]]'''.

Am besten arbeiten Sie zum Einstieg in die iOS-Anwendungsentwicklung die Mobile-Tutorials: '''[[Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)|Mobile Anwendungsentwicklung (iOS und Android)]]''' durch.

==Vorbereiten der Codesignierung von Anwendungen==

Um [[Ausführen von iOS-Anwendungen auf einem iOS-Gerät|Ihre Anwendungen auf einem iOS-Gerät auszuführen]] oder für andere bereitzustellen, müssen Sie:

# [[Teilnehmen am Apple-Entwicklerprogramm|Dem Apple-Entwicklerprogramm beitreten]]. Wenn Sie Mitglied im Apple-Entwicklerprogramm sind, erhalten Sie von Apple alle notwendigen Zertifikate und Tools, um Anwendungen für iOS-Geräte auszuführen und bereitzustellen.
# [[Erwerben eines iOS-Entwicklerzertifikats|Ein iOS-Entwicklerzertifikat erwerben]], das für die Signierung Ihrer Anwendung erforderlich ist.
# [[Bereitstellen von iOS-Anwendungen|Ihre Anwendung bereitstellen]], damit Sie sie auf Ihren iOS-Geräten ausführen können.

==Ausführen von Anwendungen==

Auf der folgenden Seite sind die erforderlichen Schritte zum Ausführen Ihrer Anwendung auf einem iOS-Gerät beschrieben:

* [[Ausführen von iOS-Anwendungen auf einem iOS-Gerät|Ausführen von iOS-Anwendungen auf einem iOS-Gerät]]

==Bereitstellen der endgültigen iOS-Anwendung==

Bevor Sie Ihre iOS-Anwendungen veröffentlichen, sollten Sie überprüfen, ob alle Einstellungen korrekt konfiguriert sind. Siehe '''[[Vorbereiten von iOS-Anwendungen für die Bereitstellung|Vorbereiten von iOS-Anwendungen für die Bereitstellung]]'''.

Wenn Ihre iOS-Anwendung für die endgültige Weitergabe bereit ist, stehen Ihnen zwei Möglichkeiten für die Bereitstellung zur Verfügung: '''Ad-hoc'''-Distribution oder '''Anwendungs-Store'''-Distribution.

Die Schritte für die Weitergabe Ihrer Anwendungen sind je nach gewählter Bereitstellungsmethode unterschiedlich:

* [[Bereitstellen von iOS-Anwendungen für die Ad-hoc-Weitergabe|Bereitstellen von iOS-Anwendungen für die Ad-hoc-Weitergabe]]
* [[Bereitstellen von iOS-Anwendungen für die Übermittlung an den App Store|Bereitstellen von iOS-Anwendungen für die Übermittlung an den App Store]] und [[Übermittlung der App an den App Store (iOS)|Übermitteln von Apps an den App Store]]

Weitere Informationen über diese Weitergabemethoden finden Sie in der [https://developer.apple.com/programs/ios/distribute.html Apple-Dokumentation (EN)].

==Unterstützung des dunklen Designs für iOS 13==

{{Product}} 10.3.3 unterstützt das dunkle Design für iOS 13.

===Integrierte Unterstützung des dunklen Designs===

Die Unterstützung des dunklen Designs ist standardmäßig im [[FireMonkey|FireMonkey]]-Framework für mit Stilen versehene Steuerelemente und nativ gerenderte Steuerelemente aktiviert.

Für Entwickler, die Komponenten wie [[lib_de:FMX.Edit.TEdit|TEdit]] und [[lib_de:FMX.StdCtrls.TSwitch|TSwitch]] verwenden, die die [[rad_de:Native FireMonkey-iOS-Steuerelemente|native iOS-Darstellung]] zusammen mit im FMX-Stil gerenderten Steuerelementen (mit dem Standardplattformstil) unterstützen, wird die Anwendungs-UI automatisch entsprechend den iOS-Einstellungen des Benutzers gerendert.

Die Unterstützung des dunklen Designs erstreckt sich auf die Systemstatusleiste und unterstützt beide Designs (hell und dunkel).

{{Note|Wenn Sie einen benutzerdefinierten, Bitmap-basierten [[FireMonkey|FireMonkey]]-Stil verwenden und dasselbe Design für alle Steuerelemente der Benutzeroberfläche anwenden möchten, sollten Sie die Eigenschaft ControlType für alle Steuerelemente auf "Styled" setzen. Wenn Sie einen benutzerdefinierten Stil verwenden und die Eigenschaft ControlType für [[lib_de:FMX.Memo.TMemo|TMemo]] oder [[lib_de:FMX.Edit.TEdit|TEdit]] (oder andere [[rad_de:Native FireMonkey-iOS-Steuerelemente|unterstützte Steuerelemente]]) auf "Platform" setzen, werden diese Steuerelemente entsprechend der iOS 13-Einstellung des Benutzers mit einem hellen oder dunklen Design gerendert.

Wenn Sie "ControlType<nowiki>=</nowiki>Platform" für [[lib_de:FMX.Edit.TEdit|TEdit]] und [[lib_de:FMX.Memo.TMemo|TMemo]] verwenden, können Sie jedes Steuerelement mit einem transparenten Hintergrund und ohne Rand rendern, anstatt das helle oder dunkle Design zu verwenden, indem Sie in der Eigenschaft StyleLookUp "TEdit<nowiki>=</nowiki>TransparentEdit" und "TMemo<nowiki>=</nowiki>TransparentMemo" festlegen. Diese Einstellung wird nur für [[lib_de:FMX.Edit.TEdit|TEdit]] und [[lib_de:FMX.Memo.TMemo|TMemo]] unterstützt.}}

===Nur helles Design===

Entwickler können die Anwendungs-UI nur auf das helle Design festlegen, indem Sie in {{Menu|Anwendung > Versionsinformationen}} einen neuen Schlüssel hinzufügen.

Wenn ein Entwickler den Schlüssel in den Versionsinformationen nicht festlegt, wird Endbenutzern abhängig von den iOS-Einstellungen auf dem Gerät des Benutzers entweder das dunkle oder das helle Design angezeigt. Dies gilt nur für mit dem iOS 13-SDK erstellte Anwendungen.

==Arbeiten mit dem iOS-Storyboard==

Für neue FireMonkey-Projekte, die in einem neuen Verzeichnis erstellt werden, sind keine zusätzlichen Schritte für die Verwendung der integrierten IDE-Unterstützung für das Storyboard erforderlich.

Bei einem vorhandenen FMX-Projekt für die iOS-Plattform aus einer früheren {{Product}}-Version müssen Sie die Datei info.plist.TemplateiOS.xml in Ihrem Projektverzeichnis löschen.

Es gibt in 10.4 zwei Möglichkeiten, die Unterstützung für den Startbildschirm des Storyboards für iOS anzupassen, die davon abhängen, ob Sie ein eigenes compiliertes Storyboard verwenden oder mit einem neuen mit den in 10.4 vorgesehenen Funktionen beginnen.

Option 1: Der Benutzer verwendet sein eigenes compiliertes Storyboard und den Asset-Katalog (*.storyboardc und Assets.car). Führen Sie die folgenden Schritte aus, um diese mit 10.4 zu verwenden:

* Deaktivieren Sie die Bereitstellung von *.launchscreen unter "Projekt | Bereitstellung".
* Wenn der Name des Storyboards nicht LaunchScreen.storyboard lautet, müssen Sie in der Datei info.plist.TemplateiOS.xml den Eintrag "<%StoryboardInfoPListKey%>" durch den Eintrag "UILaunchStoryboardName Schlüssel/Wert" ersetzen.
* Öffnen Sie "Projekt | Bereitstellung", und fügen Sie die compilierten Storyboard- und Asset-Katalogdateien hinzu.

Option 2: Der Benutzer ändert das Standard-Storyboard und den Asset-Katalog, die von der IDE bereitgestellt werden. Befolgen Sie die folgenden Schritte, wenn Sie diese Option verwenden:

* Bearbeiten Sie die LaunchScreen.storyboard- und Assets-Dateien in LaunchScreen.TemplateiOS nach Bedarf.
* Öffnen Sie "Projekt | Bereitstellung" und fügen Sie gegebenenfalls die zusätzlichen Bilder für den Startbildschirm hinzu, die bereitgestellt werden sollen.

Die Templates info.plist.TemplateiOS.xml und LaunchScreen.TemplateiOS befinden sich in den folgenden Verzeichnissen:

a. <bds>\ObjRepos\<locale>\iOS
b. %APPDATA%\Embarcadero\BDS\21.0
c. the location where the project is located.

Die IDE sucht nach diesen Templates in der folgenden Reihenfolge: Projektverzeichnis, %APPDATA%-Verzeichnis und ObjRepos-Verzeichnis.

{{Product}} unterstützt die [[Anwendungsoptionen#Symbole für iOS-Apps|Symbolgrößen]], die Apple für iOS verlangt.

===Storyboard für den iOS-Startbildschirm===

Der iOS-Startbildschirm wird sofort beim Start Ihrer App angezeigt und schnell durch den ersten Bildschirm der App ersetzt. Dadurch entsteht der Eindruck einer schnellen App.

Wenn Sie in RAD Studio den Projektstartbildschirm so ändern, dass derselbe Dateiname verwendet wird, wird bei der Projektbereitstellung nur eine Datei bereitgestellt.

Eine mögliche Lösung besteht darin, die Datei unter einem anderen Dateinamen zu kopieren, dann {{Menu|Projekt > Optionen > Anwendungen > Symbole}} zu öffnen, den Bildpfad umzuleiten und zu speichern.

{{Note|Wenn Sie Änderungen am Storyboard für den Startbildschirm vornehmen, müssen Sie entweder das Projekt umbenennen oder das Gerät neu starten.}}

==Bekannte Probleme==

* Wenn Sie auf Probleme mit dem neuen Feature "Apple Transport Security" für iOS 9 stoßen, finden Sie weitere Informationen zum Lösen des Problems unter [[Plat en:Main Page#Beschränkung für das HTTP-Protokoll|Beschränkung für das HTTP-Protokoll]].

==iOS-Themen==

*'''Vorbereiten der Entwicklungsumgebung (iOS):'''
**[[Arbeiten mit einem Mac und einem PC|Arbeiten mit einem Mac und einem PC]]
*** [[Gemeinsame Nutzung von Dateien auf dem PC und dem Mac|Gemeinsame Nutzung von Dateien auf dem PC und dem Mac]]
** [[Installieren von Xcode auf einem Mac|Installieren von Xcode auf einem Mac]]
** [[Installieren der Xcode-Befehlszeilen-Tools auf einem Mac|Installieren der Xcode-Befehlszeilen-Tools auf einem Mac]]
** [[Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC|Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC]]
** [[Installieren des Platform Assistant auf dem Mac|Installieren des Platform Assistant auf dem Mac]]
** [[Ausführen des Platform Assistant auf dem Mac|Ausführen des Platform Assistant auf dem Mac]]
** [[Hinzufügen von SDKs für macOS oder iOS|Hinzufügen eines macOS- oder iOS-SDK]]
*'''Entwickeln von iOS-Apps: {{f|cmd|'''
** '''[[Migrieren von Delphi-Code zu mobilen Anwendungen vom Desktop aus|Migrieren von {{Delphi}}-Code von Desktop- zu mobilen Anwendungen]]'''
** '''[[Migrieren von C++-Code zu mobilen Anwendungen vom Desktop aus|Migrieren von C++-Code zu mobilen Anwendungen vom Desktop aus]] }}'''
** '''[[Erstellen von iOS-Apps|Erstellen von iOS-Apps]]'''
** [[Einstellungen für Standards in RAD Studio|Einstellungen für Standards in {{Product}}]]
** [[Verwenden von Stilen für iOS: Stile für Mehrfachauflösung sowie schwarze und transparente Stile|Verwenden von iOS-Stilen: Stile für Mehrfachauflösung sowie schwarze und transparente Stile]]
** [[Native FireMonkey-iOS-Steuerelemente|Verwenden von nativen FireMonkey-iOS-Steuerelementen]]
** [[Verwenden des iOS-In-App-Kaufdienstes|Verwenden des iOS-In-App-Kaufdienstes]]
** [[Verwenden des iAd-Dienstes|Verwenden des iAd-Dienstes]]
** [[Codefragmente für die mobile Entwicklung|Codefragmente für die mobile Entwicklung]]
** '''[[Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)|Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)]]'''
*'''Vorbereiten der Signierung von iOS-Apps:'''
** [[Teilnehmen am Apple-Entwicklerprogramm|Beitreten zum Apple-Entwicklerprogramm]]
** [[Erwerben eines iOS-Entwicklerzertifikats|Erwerben eines iOS-Entwicklerzertifikats]]
** [[Bereitstellen von iOS-Anwendungen|Bereitstellen von iOS-Anwendungen]]
*'''Ausführen von iOS-Apps:'''
** [[Ausführen von iOS-Anwendungen auf einem iOS-Gerät|Ausführen von iOS-Anwendungen auf einem iOS-Gerät]]
*'''Bereitstellen von iOS-Apps:'''
** [[Konfigurieren eines Anwendungseintrags in iTunes Connect für das Hochladen|Konfigurieren eines Anwendungseintrags in iTunes Connect für das Hochladen]]
** [[Vorbereiten von iOS-Anwendungen für die Bereitstellung|Vorbereiten von iOS-Anwendungen für die Bereitstellung]]
** [[Bereitstellen von iOS-Anwendungen für die Ad-hoc-Weitergabe|Bereitstellen von iOS-Anwendungen für die Ad-hoc-Weitergabe]]
** [[Bereitstellen von iOS-Anwendungen für die Übermittlung an den App Store|Bereitstellen von iOS-Anwendungen für die Übermittlung an den App Store]]
** [[Übermittlung der App an den App Store (iOS)|Übermittlung der App an den App Store (iOS)]]
*'''Fehlerbehandlung bei iOS-Apps:'''
** [[Fehlerbehebung: In der Projektverwaltung werden keine iOS-Geräteziele angezeigt|Fehlerbehebung: In der Projektverwaltung werden keine iOS-Geräteziele angezeigt]]
** [[Fehlerbehebung: Kann nicht auf dem iOS-Gerät bereitgestellt werden|Fehlerbehebung: Bereitstellung auf dem iOS-Gerät nicht möglich]]
** [[Fehlerbehebung: Verbindung zum Mac kann nicht hergestellt werden|Fehlerbehebung: Verbindung zum Mac kann nicht hergestellt werden]]
*'''[[Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)|Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)]]'''
**'''Konfigurieren der Entwicklungsumgebung für das iOS-Gerät:'''
*** [[Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac (iOS)|Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac (iOS)]]
*** [[Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Windows-PC (iOS)|Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Windows-PC (iOS)]]
**'''Verwenden von grundlegenden iOS-Oberflächenelementen:'''
*** [[Mobile-Tutorial: Erstellen einer Anwendung für mobile Plattformen (iOS und Android)|Mobile-Tutorial: Erstellen einer Anwendung für mobile Plattformen (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Schaltflächen-Komponenten mit unterschiedlichen Stilen (iOS und Android)|Mobile-Tutorial: Verwenden von Schaltflächen-Komponenten mit unterschiedlichen Stilen (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Kalender-Komponenten zur Datumsauswahl (iOS und Android)|Mobile-Tutorial: Verwenden von Kalender-Komponenten zur Datumsauswahl (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Kombinationsfeld-Komponenten zur Auswahl von Einträgen (iOS und Android)|Mobile-Tutorial: Verwenden von Kombinationsfeld-Komponenten zur Auswahl von Einträgen (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Webbrowser-Komponenten (iOS und Android)|Mobile-Tutorial: Verwenden von Webbrowser-Komponenten (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Registerkarten-Komponenten zur Anzeige von Seiten (iOS und Android)|Mobile-Tutorial: Verwenden von Registerkarten-Komponenten zur Anzeige von Seiten (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Listenfeld-Komponenten zur Anzeige von Tabellenansichten (iOS und Android)|Mobile-Tutorial: Verwenden von Listenfeld-Komponenten zur Anzeige von Tabellenansichten (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Layouts zur Ausrichtung unterschiedlicher Formulargrößen (iOS und Android)|Mobile-Tutorial: Verwenden von Layouts zur Ausrichtung unterschiedlicher Formulargrößen (iOS und Android)]]
**'''Verwenden von Gerätefunktionen:'''
*** [[Mobile-Tutorial: Aufnehmen und Teilen von Bildern und Teilen von Texten (iOS und Android)|Mobile-Tutorial: Aufnehmen und Teilen von Bildern und Teilen von Text (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Positionssensoren (iOS und Android)|Mobile-Tutorial: Verwenden von Positionssensoren (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von Mitteilungen (iOS und Android)|Mobile-Tutorial: Verwenden von Mitteilungen (iOS und Android)]]
**'''Verwenden von BaaS (Backend as a Service ):'''
*** [[Mobile-Tutorial: Verwenden von Remote-Mitteilungen (iOS und Android)|Mobile-Tutorial: Verwenden von Remote-Mitteilungen (iOS und Android)]]
*** [[Mobile-Tutorial: Verwenden von BaaS für Backend-Speicher (iOS und Android)|Mobile-Tutorial: Verwenden von BaaS für Backend-Speicher (iOS und Android)]]
**'''Zugreifen auf Datenbanken:'''
*** [[Mobile-Tutorial: Verwenden von InterBase ToGo mit FireDac (iOS und Android)|Mobile-Tutorial: Verwenden von InterBase ToGo mit FireDAC (iOS und Android)]]
*** <f s="radstudio" t="span" />[[Mobile-Tutorial: Verwenden von dbExpress und SQLite (iOS und Android)|Mobile-Tutorial: Verwenden von SQLite und dbExpress (iOS und Android)]]<f e="radstudio" t="span" /><f s="appmethod" t="span" />[[Mobile-Tutorial: Verwenden von FireDAC und SQLite (iOS und Android)|Mobile-Tutorial: Verwenden von FireDAC und SQLite (iOS und Android)]]<f e="appmethod" t="span" /> {{f|vcl|
*** [[Mobile-Tutorial: Herstellen einer Verbindung zu Unternehmensdatenbanken von mobilen Client-Anwendungen aus (iOS und Android)|Mobile-Tutorial: Herstellen einer Verbindung zu Unternehmensdatenbanken von mobilen Client-Anwendungen aus (iOS und Android)]] }}

==Siehe auch==

* [[Plattformvoraussetzungen für FireMonkey|Plattformvoraussetzungen für {{FM}}]]
* [[Regeln für die Benennung von geräteübergreifenden Projekten und Dateien|Regeln für die Benennung von geräteübergreifenden Projekten und Dateien]]
* [[Experten zum Erstellen von geräteübergreifenden FireMonkey-Anwendungen und -Komponenten|Experten zum Erstellen von geräteübergreifenden {{FM}}-Anwendungen und -Komponenten]]
* [[Vorlagen für geräteübergreifende Anwendungen|Vorlagen für geräteübergreifende Anwendungen]]{{f|cmd|
*'''{{Delphi}}-iOS-Compiler:'''
** [[DCCIOSARM64.EXE: Der Delphi-Compiler für 64-Bit-iOS-Geräte|DCCIOSARM64: Der {{Delphi}}-Compiler für 64-Bit-iOS-Geräte]]
* [[BCCIOSARM64.EXE: Der C++-Compiler für 64-Bit-iOS-Geräte|BCCIOSARM64: Der C++-Compiler für 64-Bit-iOS-Geräte]]}}
* [[Automatic Reference Counting in C++|Automatische Referenzzählung in C++]]
* [[Unterschiede zwischen Windows und macOS|Unterschiede zwischen Windows und macOS]]
* [[Mobile Android-Anwendungsentwicklung|Mobile Android-Anwendungsentwicklung]]
* [[MacOS-Anwendungsentwicklung|macOS-Anwendungsentwicklung]]
* [[PAServer: Die Platform Assistant Server-Anwendung|PAServer: Die Platform Assistant Server-Anwendung]] {{f|radstudio|
* [http://cc.embarcadero.com/item/29490 EDN: iOS User Interface Design with {{Delphi}} XE4 (EN)] }}

[[Category:Geräteübergreifend]]
[[Category:FMX]]
[[Category:IOS]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:IOS Mobile Application Development]]
[[fr:Développement d'applications mobiles iOS]]
[[ja:IOS モバイルアプリケーション開発]]

Drucken aus FireMonkey-Anwendungen

2024-05-13T19:39:44Z

Nicolas.rios: RS-117502

{{Parent|FireMonkey-Anwendungshandbuch}}

Sie können auf '''Windows''' oder '''macOS''' aus einer {{FM}}-Anwendung drucken.

=={{FM}}-API zum Drucken==

Das Objekt [[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] kapselt die Funktionalität für den Zugriff auf einen Drucker und das Drucken auf einem Drucker, der an einem Computer für Windows oder macOS angeschlossen ist. Mit dem Objekt [[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] können Sie alle Druckoperationen einer Anwendung verwalten. Durch Aufruf der globalen Funktion [[lib_de:FMX.Printer.Printer|FMX.Printer.Printer]] können Sie eine Instanz von [[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] abrufen.

[[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] enthält eine Liste der [[lib_de:FMX.Printer.TPrinterDevice|TPrinterDevice]]-Objekte, die jeweils einen Drucker repräsentieren. Jeder Drucker enthält eine eigene Liste mit Druckauflösungen DPI (Dots Per Inch, Punkte pro Zoll). In der Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.DPICount|DPICount]] ist die Anzahl der Auflösungen enthalten, die von dem Drucker unterstützt werden. Die indizierte Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.DPI|DPI]] kann zum Ermitteln der tatsächlichen Auflösungen durchlaufen werden. [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] ist ein nullbasierter Index für die indizierte Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.DPI|DPI]], die die Druckauflösung auf dem Drucker darstellt.

==Aktivieren der Druckfunktion in {{FM}}-Anwendungen==

In den folgenden Schritten wird gezeigt, wie das Drucken aus einer {{FM}}-Anwendung durchgeführt wird.
<ol>
<li>
Beziehen Sie [[lib_de:FMX.Printer|FMX.Printer]] in das Formular ein, in dem der Druckauftrag verwendet werden soll.

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
uses FMX.Printer;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
#include "FMX.Printer.hpp"
</source>
<l e="cpp"/>
</li>
<li>
Verwenden Sie immer die [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche des Druckers]] oder die Zeichenfläche einer grafischen Komponente (z.B. die Zeichenfläche eines Bildes) anstelle der Zeichenfläche des Formulars. Beginnen Sie den Druckvorgang immer mit [[lib_de:FMX.Graphics.TCanvas.BeginScene|BeginScene]] und beenden Sie den Druckauftrag mit [[lib_de:FMX.Graphics.TCanvas.EndScene|EndScene]], wenn Sie die [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche des Druckers]] nicht verwenden.
</li>
<li>
Setzen Sie zuerst zur vollständigen Kontrolle über die Druckqualität (Auflösung der und Portabilität der [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche]]) [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] durch Zuweisen eines Wertes oder durch Aufruf der Methode [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] (empfohlenes Vorgehen).

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.ActivePrinter.SelectDPI(1200, 1200); { one way }
Printer.ActivePrinter.ActiveDPIIndex := 1; { another way }

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

'''C++:
<source lang="cpp">
Printer->ActivePrinter->SelectDPI(1200, 1200); /* one way */
Printer->ActivePrinter->ActiveDPIIndex = 1; /* another way */
</source>
<l e="cpp"/>
</li>
<li>
Starten Sie den eigentlichen Druckauftrag mit [[lib_de:FMX.Printer.TPrinter.BeginDoc|BeginDoc]].

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.BeginDoc;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Printer->BeginDoc();
</source>
<l e="cpp"/>
</li>
<li>
Beenden Sie den eigentlichen Druckauftrag mit [[lib_de:FMX.Printer.TPrinter.EndDoc|EndDoc]].

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.EndDoc;
</source>

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

'''C++:
<source lang="cpp">
Printer->EndDoc();
</source>
<l e="cpp"/>
</li>
<li>
Ändern Sie während eines Druckauftrags nie die Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]].
</li>
</ol>

==DPI- und Treiberunterstützung==

Die Treiberunterstützung für Drucker ist auf verschiedenen Plattformen (Windows, macOS) unterschiedlich. Deshalb sollten Sie sich nicht darauf verlassen, dass die Anzahl oder die Reihenfolge der unterstützten Auflösungen im Array [[lib_de:FMX.Printer.TPrinterDevice.DPI|DPI]] unter Windows und macOS identisch sind. Unter macOS gibt es beispielsweise für den HP-Laserdrucker 3 unterstützte Auflösungen, für Windows hingegen 7. Bei Anwendungen mit Druckfunktionen für Windows und macOS müssen Sie zusätzlichen Code hinzufügen (hauptsächlich zur Angabe der DPI), damit die Druckausgabe auf beiden Plattformen annähernd gleich ist.

Als '''bestes Verfahren''' hat sich erwiesen, die DPI immer durch Setzen der Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] oder durch Aufruf der Methode [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] vor dem Drucken, wie oben erwähnt, festzulegen.

[[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] wird für einen gegebenen Drucker '''nicht''' auf die Standard-DPI gesetzt. Ein [[lib_de:FMX.Printer.TPrinterDevice|TPrinterDevice]]-Objekt unterstützt keine Standard-DPI, insbesondere weil die Standard-DPI von einigen macOS-Druckertreibern nicht angegeben wird. Deshalb wird beim Start der Anwendung [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] für alle [[lib_de:FMX.Printer.TPrinterDevice|TPrinterDevice]]-Objekte auf -1 gesetzt. Der Wert -1 bedeutet, dass entweder die letzte Druck-DPI oder die Standard-DPI verwendet wird. Die Standard-DPI ist nur nach dem Start der Anwendung verfügbar, wenn Sie [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] nicht in einen anderen Indexwert geändert und [[lib_de:FMX.Printer.TPrinter.BeginDoc|BeginDoc]] nicht aufgerufen haben.

Andererseits können Sie [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] auf -1 setzen, und die letzte DPI des zuvor festgelegten Druckers wird von der Anwendung verwendet. Denken Sie immer daran, einen Wert für [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] zu setzen, bevor Sie [[lib_de:FMX.Printer.TPrinter.BeginDoc|BeginDoc]] aufrufen, wenn Sie dieselbe Größe der [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche]] für Windows und macOS verwenden möchten.

Mit der Methode [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] kann durch ein [[lib_de:FMX.Printer.TPrinter|TPrinter]]-Objekt sehr einfach die Ihrem Drucker ähnlichste Auflösung auf Basis der an [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] übergebenen Parameter ausgewählt werden. Es ist einfacher festzulegen; anstatt die Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] direkt zu setzen, können Sie beispielsweise den Wert zur Laufzeit ändern:

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.ActivePrinter.SelectDPI(600, 600);
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Printer->ActivePrinter->SelectDPI(600, 600);
</source>
<l e="cpp"/>

In Anbetracht der Tatsache, dass unter Windows die Anzahl der vom Treiber angegebenen Druckerauflösungen von denen, die der macOS-Druckertreiber liefert, abweicht, könnte der Index nicht verfügbar sein.

Zusammengefasst stellt die Verwendung von [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] zum Setzen der Druck-DPI die '''weitaus praktischere Methode''' dar.

==Druckerzeichenfläche==

Es gibt einige Unterschiede bei der Verwendung einer '''Druckerzeichenfläche''' im Vergleich zu einer '''Bildschirm- oder Fenster-(Formular-)Zeichenfläche''':
<ol>
<li>
* Für Druckerzeichenflächen müssen Sie die Farb- und Fülleinstellungen mit [[lib_de:FMX.Graphics.TCanvas.Fill|Canvas.Fill]] festlegen:

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Canvas.Fill.Color := claXXX;
Canvas.Fill.Kind := TBrushKind.Solid;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Canvas->Fill->Color = claXXX;
Canvas->Fill->Kind = TBrushKind.Solid;
</source>
<l e="cpp"/>
</li>
<li>

* Für Bildschirm- oder Fensterzeichenflächen müssen Sie die Farb- und Fülleinstellungen mit [[lib_de:FMX.Graphics.TCanvas.Stroke|Canvas.Stroke]] festlegen.

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Canvas.Stroke.Color := claXXX;
Canvas.Stroke.Kind := TBrushKind.Solid;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Canvas->Stroke->Color = claXXX;
Canvas->Stroke->Kind = TBrushKind.Solid;
</source>
<l e="cpp"/>
</li>
</ol>

Beachten Sie, dass:
* Sie beim Drucken von Text, dessen Farbe Sie ändern möchten, [[lib_de:FMX.Graphics.TCanvas.Fill|Canvas.Fill]] verwenden müssen.
* Sie beim Drucken anderer Elemente – außer Text – [[lib_de:FMX.Graphics.TCanvas.Stroke|Canvas.Stroke]] verwenden müssen.

Der Parameter <code>Opacity</code> übernimmt bei allen Routinen, die diesen Parameter unterstützen (wie [[lib_de:FMX.Graphics.TCanvas.FillRect|FMX.Graphics.TCanvas.FillRect]]) Gleitkommawerte im Bereich von <code>0..1</code> (0 ist transparent und 1 ist undurchsichtig). Verwenden Sie keine Werte außerhalb dieses Bereichs.

==Beispiel für programmgesteuertes Drucken==

Im folgenden Beispiel wird ein Bild und eine Schaltfläche verwendet. Bei jedem Klicken auf die Schaltfläche wird das Bild auf dem Drucker ausgegeben.

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
var
SrcRect, DestRect: TRectF;
begin
{ Set the default DPI for the printer. The SelectDPI routine defaults
to the closest available resolution as reported by the driver. }
Printer.ActivePrinter.SelectDPI(1200, 1200);
{ Start printing. }
Printer.BeginDoc;

if Printer.Canvas.BeginScene then
try
{ Set canvas filling style. }
Printer.Canvas.Fill.Color := claBlack;
Printer.Canvas.Fill.Kind := TBrushKind.Solid;

{ Set the Source and Destination TRects. }
SrcRect := Image1.LocalRect;
DestRect := TRectF.Create(0, 0, Printer.PageWidth, Printer.PageHeight);

{ Print the picture on all the surfaces of the page and all opaque. }
Printer.Canvas.DrawBitmap(Image1.Bitmap, SrcRect, DestRect, 1);
finally
Printer.Canvas.EndScene;
end;

{ Finish printing job. }
Printer.EndDoc;
end;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++''':
<source lang="cpp">
TRectF SrcRect, DestRect;
TPrinter *Printer = Printer;

/* Set the default DPI for the printer. The SelectDPI routine defaults
to the closest available resolution as reported by the driver. */
Printer->ActivePrinter->SelectDPI(1200, 1200);

/* Start printing. */
Printer->BeginDoc();

if (Printer->Canvas->BeginScene()) {
try
{
/* Set canvas filling style. */
Printer->Canvas->Fill->Color = claBlack;
Printer->Canvas->Fill->Kind = TBrushKind(1);

/* Set the Source and Destination TRects. */
SrcRect = Image1->LocalRect;
DestRect = TRectF(0, 0, Printer->PageWidth, Printer->PageHeight);

/* Print the picture on all the surface of the page and all opaque. */
Printer->Canvas->DrawBitmap(Image1->Bitmap, SrcRect, DestRect, 1);
}
__finally
{
Printer->Canvas->EndScene();
}
}

/* Finish the printing job. */
Printer->EndDoc();
</source>
<l e="cpp"/>

Weitere Informationen bezüglich der Druck-API finden Sie in der API-Dokumentation in der [[lib_de:FMX.Printer|Unit FMX.Printer]].

==Siehe auch==

* [[lib_de:FMX.Printer|FMX.Printer (Unit)]]

==Codebeispiele==

<l s="delphi"/>
* [[samp_en:FMXPrinting_({{Delphi}})|Drucken aus {{FM}} ({{Delphi}})]]
<l e="delphi"/>
<l s="cpp"/>
* [[samp_en:FMXPrinting_(C++)|Drucken aus {{FM}} (C++)]]
<l e="cpp"/>

[[Category:XE2]]
[[Category:FMX]]
[[Category:AMMigrate]]

[[en:Printing from a FireMonkey Application]]
[[fr:Impression depuis une application FireMonkey]]
[[ja:FireMonkey アプリケーションからの印刷]]

Pragma package

2024-05-09T13:55:31Z

Nicolas.rios: {{Note|

{{DISPLAYTITLE:#pragma package}}
{{Parent|Pragma-Direktiven (Übersicht) - Index}}
==Syntax (siehe [[Pseudogrammatik]])==
#pragma package(smart_init)
#pragma package(smart_init, weak)

==Beschreibung==
===#pragma package(smart_init)===

Die Anweisung <code>#pragma package(smart_init)</code> stellt sicher, dass gepackte Units in der Reihenfolge initialisiert werden, die durch ihre Abhängigkeiten (standardmäßig in der Package-Quelldatei enthalten) festgelegt ist. Normalerweise setzen Sie <code>#pragma package</code> für CPP-Dateien ein, die als Packages erzeugt werden.

:{{Note| Verwenden Sie <code>#pragma package(smart_init)</code> nicht in Header-Dateien. Dies könnte zum Compiler-Fehler [[E2177 Redeklaration des pragma-Package mit verschiedenen Parametern (C++)|E2177 Redeklaration von #pragma package mit verschiedenen Argumenten (C++)]] führen.}}

Dieses Pragma wirkt sich auf die Reihenfolge der Initialisierung dieser Compilierungs-Unit aus. Units werden in folgender Reihenfolge initialisiert:

# Nach ihren "uses"-Abhängigkeiten, d. h., wenn UnitA von UnitB abhängt, muss UnitB vor UnitA initialisiert werden.
# Nach der Link-Reihenfolge.
# Nach der Priorität innerhalb der Unit.

Reguläre OBJ-Dateien (solche, die nicht als Units erzeugt werden) werden zuerst nach der Priorität und dann nach der Link-Reihenfolge initialisiert. Wenn Sie die Reihenfolge der Objektdateien ändern, werden die Konstruktoren der globalen Objekte in der entsprechenden Reihenfolge aufgerufen.

Die folgenden Beispiele zeigen die Unterschiede der Initialisierung bei Units und regulären Objektdateien.

====Beispiel====
Sie haben beispielsweise drei Quelldateien A, B und C, die mit <code>#pragma package(smart_init)</code> initialisiert wurden und über Funktionen mit den Prioritätswerten 10, 20 und 30 (definiert durch den Prioritätsparameter von <code>#pragma startup</code>) verfügen. Die Funktionen sind entsprechend ihrer Prioritätswerte und der zugehörigen Quelldatei als a10, a20, a30, b10, b20 usw. benannt.

Hier sind die drei Programme A, B und C:
<source lang=cpp>
// A.cpp
#include <stdio.h>

#ifdef USE_PACKAGE_INIT
#pragma package(smart_init)
#endif

void A10() {
printf("%s() ", __FUNCTION__);
}
#pragma startup A10 10

void A20() {
printf("%s() ", __FUNCTION__);
}
#pragma startup A20 20

void A30() {
printf("%s() ", __FUNCTION__);
}
#pragma startup A30 30
</source>

<source lang=cpp>
// B.cpp
#include <stdio.h>

#ifdef USE_PACKAGE_INIT
#pragma package(smart_init)
#endif

void B10() {
printf("%s() ", __FUNCTION__);
}
#pragma startup B10 10

void B20() {
printf("%s() ", __FUNCTION__);
}
#pragma startup B20 20

void B30() {
printf("%s() ", __FUNCTION__);
}
#pragma startup B30 30
</source>

<source lang=cpp>
// C.cpp
#include <stdio.h>

#ifdef USE_PACKAGE_INIT
#pragma package(smart_init)
#endif

void C10() {
printf("%s() ", __FUNCTION__);
}
#pragma startup C10 10

void C20() {
printf("%s() ", __FUNCTION__);
}
#pragma startup C20 20

void C30() {
printf("%s() ", __FUNCTION__);
}
#pragma startup C30 30
</source>

Wenn Sie die Quelldateien so, wie sie geschrieben sind, und mit definierter Anweisung '''USE_PACKAGE_INIT''' erzeugen, erhalten Sie die folgende Ausgabe:
A10() A20() A30() B10() B20() B30() C10() C20() C30()
Das heißt, dass die Priorität ignoriert wird und für jede Unit die gesamte Initialisierung auf einmal durchgeführt wird.

Sie erhalten ein vollständig anderes Ergebnis, wenn Sie die Quelldateien ohne '''USE_PACKAGE_INIT''' erzeugen. In diesem Fall wird bei Ausführung des Programms Folgendes ausgegeben:
A10() B10() C10() A20() B20() C20() A30() B30() C30()
Das heißt, dass die anfängliche Priorität verwendet wird.

Da es sich bei allen dreien um Units handelt, und wenn A B und C verwendet, und die Link-Reihenfolge A, B dann C ist, ergibt sich die Initialisierungsreihenfolge: <code> B10() B20() B30() C10() C20() C30() A10() A20() A30() </code>

Bei Objektdateien anstelle von Units ergibt sich die folgende Reihenfolge: <code> A10() B10() C10() A20() B20() C20() A30() B30() C30() </code>

Für CPP-Dateien, die <code>#pragma package(smart_init)</code> verwenden, ist es auch erforderlich, dass alle <code>#pragma link</code>-Referenzen zu anderen Objektdateien von einer CPP-Datei aus, die <code>#pragma package(smart_init) </code> deklariert, durch eine Unit aufgelöst werden. <code>#pragma link</code>-Referenzen auf Nicht-Objektdateien können auch durch Bibliotheken usw. aufgelöst werden.

===#pragma package(smart_init, weak)===
Die Direktive <code>#pragma package(smart_init, weak)</code> beeinflusst die Art, wie eine Objektdatei in [[Bibliotheksdatei für den Package-Import|.bpi]]- und [[Geteilte Package-Bibliotheksdatei|.bpl]]-Dateien eines Packages gespeichert wird. Wenn <code>#pragma package(smart_init, weak)</code> in einer Unit-Datei enthalten ist, lässt der Compiler, wenn möglich, die Unit aus BPLs weg. Der Compiler legt eine lokale Kopie der Unit (ohne Package) an, wenn die Unit für eine andere Anwendung oder ein anderes Package erforderlich ist. Eine solche Unit bezeichnet man als "schwach gepackt".

<code>#pragma package(smart_init, weak)</code> wird verwendet, um Konflikte zwischen Packages auszuschließen, die von derselben externen Bibliothek abhängen könnten.

Unit-Dateien mit der Direktive <code>#pragma package(smart_init, weak)</code> dürfen keine globalen Variablen enthalten.

Weitere Informationen hierzu finden Sie unter [[Schwach Packen |Schwaches Packen]].

==Siehe auch==
* [[Präprozessor-Direktiven - Index|Präprozessor-Direktiven]]
* [[Schwach Packen |Schwaches Packen]]
* [[Verwendung des schwachen Packens]]
* [[E2177 Redeklaration des pragma-Package mit verschiedenen Parametern (C++)|E2177 Redeklaration von #pragma package mit verschiedenen Argumenten (C++)]]
[[Category:C++-Referenz]]
[[Category:C++]]

[[en:Pragma package]]
[[fr:Pragma package]]
[[ja:Pragma package]]

Spezielle Compiler-Direktiven für Packages

2024-05-09T13:37:40Z

Nicolas.rios: {{Note|

{{Parent|Packages compilieren}}
Die folgende Tabelle enthält spezielle Compiler-Direktiven für Packages, die in den Quelltext eingefügt werden können.

''' Spezielle Compiler-Direktiven für Packages: '''

<l s='cpp'/>
{| border="1" frame="hsides" rules="rows"
! '''C++-Direktive'''
! '''Beschreibung'''
|-
| align="left" valign="top" |
[[pragma package|#pragma package(smart_init)]]
| align="left" valign="top" |
Diese Direktive stellt sicher, dass die gepackten Units in der Reihenfolge initialisiert werden, die durch ihre Abhängigkeiten festgelegt ist. (Sie wird standardmäßig in die Quelldatei eines Package eingebunden.)
|-
| align="left" valign="top" |
[[pragma package|#pragma package(smart_init, weak)]]
| align="left" valign="top" |
Mit dieser Direktive wird eine Unit schwach eingebunden. Siehe (Direktive in die Quelltextdatei der Unit einfügen.)
|}
<l e='cpp'/>

<l s='delphi'/>
{| border="1" frame="hsides" rules="rows"
! '''{{Delphi}}-Direktive'''
! '''Beschreibung'''
|-
| align="left" valign="top" |
[[Implizites Erstellen (Delphi)|{$IMPLICITBUILD OFF}]]
| align="left" valign="top" |
Verhindert, dass ein Package in Zukunft implizit neu compiliert wird. Diese Direktive wird in [[Delphi-Package-Quelldatei (*.dpk)|.dpk-Dateien]] verwendet, wenn Packages mit Low-Level-Funktionen compiliert werden, die sich nur selten ändern, oder wenn der Quelltext des Package nicht weitergegeben wird.
|-
| align="left" valign="top" |
[[Importierte Daten|{$G} oder {$IMPORTEDDATA OFF}]]
| align="left" valign="top" |
Deaktiviert die Erstellung von Referenzen auf importierte Daten. Diese Direktive führt zu schnelleren Speicherzugriffen, verhindert aber, dass die Unit, in der sie verwendet wird, Variablen in anderen Packages referenzieren kann.
|-
| align="left" valign="top" |
[[Schwach Packen|{$WEAKPACKAGEUNIT ON}]]
| align="left" valign="top" |
Die Unit wird schwach eingebunden. Einzelheiten finden Sie unter [[Verwendung des schwachen Packens]].
|-
| align="left" valign="top" |
[[DENYPACKAGEUNIT-Direktive (Delphi)|{$DENYPACKAGEUNIT ON}]]
| align="left" valign="top" |
Verhindert, dass die Unit in ein Package eingebunden wird.
|-
| align="left" valign="top" |
[[DESIGNONLY-Direktive (Delphi)|{$DESIGNONLY ON}]]
| align="left" valign="top" |
Das Package wird für die Installation in der IDE compiliert. (Nur in .dpk-Dateien.)
|-
| align="left" valign="top" |
[[RUNONLY-Direktive (Delphi)|{$RUNONLY ON}]]
| align="left" valign="top" |
Das Package wird nur als Laufzeit-Package compiliert. (Nur in .dpk-Dateien.)
|}

{{Notes|
*Wenn Sie die Compiler-Direktive {'''$DENYPACKAGEUNIT ON'''} im Quelltext verwenden, wird die Unit nicht in das Package aufgenommen.
*Die Angabe von {'''$G-'''} oder {'''$IMPORTEDDATA OFF'''} kann bewirken, dass das Package nicht zusammen mit anderen Packages in derselben Anwendung verwendet werden kann. Packages, die mit der Direktive {'''$DESIGNONLY ON'''} compiliert wurden, enthalten zusätzlichen Quelltext, der von der IDE benötigt wird. Derartige Packages sollten in normalen Anwendungen nicht verwendet werden.
*Bei Bedarf können auch andere Compiler-Direktiven in den Quelltext eines Package aufgenommen werden. Unter [[Liste der Delphi-Compiler-Direktiven - Index|Compiler-Direktiven]] finden Sie Informationen, die hier nicht erläutert werden.}}
<l e='delphi'/>

Weitere Direktiven, die in allen Bibliotheken einsetzbar sind, werden unter [[Packages und DLLs erstellen|Packages und DLLs erstellen]] beschrieben.

==Siehe auch==

* [[Verwendung des schwachen Packens]]
*[[Packages und Komponenten: Übersicht]]
*[[Packages compilieren]]
*[[Packages erstellen und bearbeiten]]

{{DEFAULTSORT:Spezielle Compiler-Direktiven fur Packages}}
[[Category:Windows-Entwicklerhandbuch]]
[[Category:{{Delphi}}]]
[[Category:C++]]

[[en:Package-specific Compiler Directives]]
[[fr:Directives de compilation spécifiques aux packages]]
[[ja:パッケージ固有のコンパイラ指令]]

Hauptseite

2024-04-30T16:43:27Z

Nicolas.rios: RS-108677 added links to Web section

{{DISPLAYTITLE:Hilfe für {{Product}} 11 {{MarketingVersion}}}}
__NOTOC__

<div class="floatleft" style="width: 49%">
==[[Überblick über RAD Studio|Überblick]]==
* [[Überblick über RAD Studio|Funktionsübersicht]]
* [[Neuerungen|Neuerungen]]
* [[11 Alexandria - Release 1]]
* [[11 Alexandria – Release 2]]
* [[Release-Hinweise|Release-Hinweise]]
* [[rad_en: Community Edition|Community Edition]]

==[[Installation|Installation]]==
* [[Installationshinweise|Installationshinweise]]
* [[Plat en:Main Page#{{Product}} {{MarketingVersion}}|Hotfixes und Workarounds]]
==[[Einführung in RAD Studio|Einführung]]==
* [[Tutorials|Tutorials]] | [[Tutorial: Verwenden der IDE|Ihre erste Anwendung erstellen]]
* [[Hilfreiche Ressourcen für neue Benutzer#Code- und Anwendungsbeispiele|Code- und Anwendungsbeispiele]]
* [[Hilfreiche Ressourcen für neue Benutzer#Grundlagen|Lesen]]
* [[Hilfreiche Ressourcen für neue Benutzer#Video-Demos|Videos]]
* [[Hilfreiche Ressourcen für neue Benutzer#CodeRage-Seminare|Seminare]]
==Projektentwicklung==
* [[Hauptanwendungstypen|Hauptanwendungstypen]]
* [[Arbeitsschritte bei der Projektentwicklung|Arbeitsschritte bei der Projektentwicklung]]
==Referenz==
* [[Unterstützte Zielplattformen|Zielplattformen]]
* [[Frameworks und Bibliotheken|Frameworks und Bibliotheken]]
* [[Programmiersprachen|Programmiersprachen]]
* [[IDE-Referenz und Hilfsprogramme|IDE-Referenz und Hilfsprogramme]]
* [[Index|Index]]
</div>

<div class="floatright" style="width: 49%">

{{f|winguide|

==[[Windows-Entwicklerhandbuch - Index|Windows-Entwicklung]]==
* [[VCL|VCL-Formularanwendung für Windows]]
* [[Entwickeln von Metropolis-UI-Anwendungen|Metropolis-UI-Anwendungen für VCL und {{FM}} (Windows 8-Stil)]]
* [[Komponentenentwicklung - Index|Komponentenentwicklung]]

}}

==[[Geräteübergreifende Anwendungen - Index|Geräteübergreifende Entwicklung]]==
* [[Geräteübergreifende Anwendungen entwickeln|Geräteübergreifende Anwendungen entwickeln]]
* [[Schritte bei der Entwicklung von geräteübergreifenden Anwendungen|Schritte bei der Entwicklung von geräteübergreifenden Anwendungen]]
* [[Datenbankanwendungen entwickeln|Datenbankanwendungen entwickeln]]
* [[Entwickeln von RAD Server-, Cloud- und REST-Anwendungen|Entwickeln von RAD Server-, Cloud- und REST-Anwendungen]] {{f|datasnap|
* [[DataSnap-Anwendungen entwickeln|DataSnap-Anwendungen entwickeln]] }}
==Mobile Entwicklung==
* [[Mobile Android-Anwendungsentwicklung|Mobile Android-Anwendungsentwicklung]]
* [[Mobile iOS-Anwendungsentwicklung|Mobile iOS-Anwendungsentwicklung]]
* [[Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)|Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)]]

{{f|radstudio|

==[[Internetanwendungen entwickeln - Index|Webentwicklung]]==
* [[Web Broker verwenden - Index|Verwenden von Web Broker]]
* [[DataSnap-Anwendungen entwickeln|Verwenden von DataSnap]]
* [[RAD Server (EMS)|Verwenden von RAD Server]]
==[[UML-Modellierung|UML-Modellierung]]==
* [[Einführende Modellierungskonzepte|Einführende Modellierungskonzepte]]
* [[Anleitungen für die Modellierung|Anleitungen für die Modellierung]]
* [[Modellierungsreferenz - Index|Modellierungsreferenz]]

}}

</div>

{{DEFAULTSORT:Hilfe fur RAD Studio 11 11.0 Alexandria}}
[[Category:Delphi]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:Main Page]]
[[fr:Accueil]]
[[ja:メインページ]]

11 Alexandria – Release 1

2024-04-25T21:04:16Z

Nicolas.rios: /* Siehe auch */

{{Parent|Hauptseite}}
{{Parent|Neuerungen in den letzten Releases}}
Aktualisiertes Release von {{Product}} 11.1 {{Version}} verfügbar (15. März 2022).

{{Note|

* Informationen zum Inhalt von Version '''[[Neuerungen|11 Alexandria]]'''
* Informationen zum Inhalt von Version '''[[What's New in 11.1.5|11 Alexandria – Release 1.5]]'''
* Informationen zum Inhalt von Version '''[[11 Alexandria – Release 2|11 Alexandria – Release 2]]'''
* Informationen zum Inhalt von Version '''[[11 Alexandria - Release 3|11 Alexandria – Release 3]]'''

}}

RAD Studio 11 Alexandria – Release 1 (alias 11.1) ist für die Installation verfügbar. RAD 11.1 baut auf dem Funktionsumfang von RAD Studio 11 auf, wobei im gesamten Produkt Funktionen erweitert und neue hinzugefügt wurden. Delphi 11, C++Builder 11 und RAD Studio 11 stehen für jeden aktiven Update Subscription-Kunden zum Herunterladen zur Verfügung.

Der Fokus von RAD Studio 11.1 wurde überwiegend auf Qualitätsverbesserungen gelegt. Zu den wichtigsten Bereichen mit Qualitätsverbesserungen zählen:

* IDE
* Remotedesktop
* Delphi- und C++-Compiler
* C++-Toolkette
* Delphi-LSP
* C++-LSP
* Delphi-RTL
* VCL
* FireMonkey
* Daten
* Internet

=Wichtige Verbesserungen in 11.1 nach Produktbereich=

==Erweiterungen für die IDE==

===Allgemeine IDE-Verbesserungen===

* Der Vorgang "Mit der Arbeit beginnen" nach Abschluss der Installation startet die IDE neu, sodass die erste Ausführung mit Benutzerrechten und nicht mit erhöhten Rechten erfolgt.
* "Laufzeit-Themes aktivieren" ist jetzt für die Basiskonfiguration eines Projekts aktiviert.
* ProjectRoot in einer dproj/cbproj-Datei sollte jetzt immer konsistent sortiert werden.
* Im IDE-Dialogfeld "Warten" der ToolsAPI-Schnittstelle wurden einige Parameter umbenannt, um deren Funktionalität besser widerzuspiegeln.
* Der Menüeintrag "Neues Editierfenster" ist jetzt deaktiviert, wenn eine Ansicht das Klonen nicht unterstützt. Dazu zählt die Willkommensseite, die nicht dupliziert oder in ein anderes Fenster gezogen werden kann.
* Die Seite "Optionen > Speichern und Desktop" wurde in zwei neue Seiten aufgeteilt:
** Speichern und Wiederherstellen (enthält Optionen für die automatische Wiederherstellung und Speicherung)
** Desktop und Layout (enthält die restlichen Optionen)
* In der Ansicht "Meldungen" im Dialogfeld "Optionen" können Sie jetzt die Farben für Fehler, Warnungen und Hinweise ändern. Sie können verschiedene Farben für jedes IDE-Theme festlegen, d. h., unterschiedliche Farben für hell und dunkel oder andere Themes.

[[File:Build log.png|600px |link=]]

* Für einige untergeordnete von der IDE verwendete Dialogfelder wurde die Unterstützung für Stile hinzugefügt, wie z. B. die Aufforderung an Benutzer, das Überschreiben von Dateien zu bestätigen, sowie die Anzeige einer Warnung dazu, die Prüfung auf Unicode-Projektnamen und die Verwendung einer ungültigen Codepage.
* Das Problem, dass eine Projektdatei eine inkonsistente Sortierreihenfolge der bereitgestellten Dateien haben könnte, was bedeutet, dass sie sich ändert, ohne dass sich ihr Inhalt ändert, wurde behoben.
* Die standardmäßige C++-Konsolen-App wurde verbessert, und das Erstellen einer Konsolen-App erfolgt jetzt über ein Tastenkürzel im Menü "Datei > Neu" (und "Neu erstellen") sowohl für C++ als auch für Delphi.
* Eine kleine Anzahl von Elementen aus dem IDE Fix Pack wurde integriert.
** Die IDE-Symbolleisten, wie etwa die Symbolleisten für die Bearbeitung
** Fehlende Bildlaufleisten auf den Seiten des Dialogfelds "Optionen"
** Rendering-Probleme im Objektinspektor
** IDE und der Code-Editor wurden beim Debuggen leer angezeigt
** Sondertasten (wie die Windows-Taste) bei der Texteingabe im FMX-Formular-Designer
** Listenmodus in der Ansicht "Projekte"
** Eine Reihe von Exceptions und vieles mehr
* Im Dialogfeld "Objektgalerie" werden Plattformen für alle Elemente angezeigt.

[[File:Compile dialog.png|600px|link=]]

* Im Dialogfeld "Neu", in dem Sie Ihrem Projekt Elemente hinzufügen können, werden Elemente auf Grundlage der aktiven Plattform des Projekts ausgeblendet.
* Das Dialogfeld "Neu" unterstützt auch mehrere Ansichtsstile und nicht nur eine vertikale Liste (Karte, Liste, Symbole und kleine Symbole).
* Das Dialogfeld "Objektgalerie" verwendet jetzt das VCL-Steuerelement TControlList, wodurch das Scrollen verbessert wird.
* Im Dialogfeld "Compilieren" werden jetzt die Plattform und die Build-Konfiguration und Fehler vor Warnungen und Hinweisen angezeigt.

[[File:New items.png|600px |link=]]

===High-DPI-Qualitätsverbesserungen in der IDE===

* Datenmodule speichern jetzt die Eigenschaft PixelsPerInch, wenn ihr Wert 96, dem Standard, entspricht. Dies trifft auch für VCL-Formulare zu.
* Dynamisch erstellte Frames werden jetzt beim Entwurf mit High DPI korrekt skaliert.

===Willkommensseite===

* Die Willkommensseite unterstützt jetzt Hintergrundbilder. Wenn Sie ein Bild auswählen, wird es so skaliert, dass es auf die Willkommensseite passt. Das Seitenverhältnis wird beibehalten, was bedeutet, dass die linke/rechte oder obere/untere Seite des Bildes außerhalb des Bildschirms liegen kann, solange die andere Achse der Größe der Willkommensseite entspricht.
* Das Dialogfeld "IDE-Optionen" enthält eine neue Seite für die Einstellungen der Willkommensseite, darunter der Hintergrund (der nach Theme festgelegt werden kann) und das Schließen der Seite beim Öffnen eines Projekts. Sie können auf diese Seite auch über den Layout-Editor zugreifen.
* Die Frames der Willkommensseite sind jetzt standardmäßig transparent. Das Hintergrundbild, das Sie festlegen, scheint teilweise hindurch. Der Transparenzwert ist eine der in der ToolsAPI verfügbaren Metriken für die Willkommensseite.
* Der Abstand zwischen Frames und den oberen und unteren Rändern der Willkommensseite wurde etwas verringert.

===='''ToolsAPI-Unterstützung!'''====

Die Willkommensseite unterstützt jetzt vollständig das Erstellen von Frames mit der ToolsAPI! Unsere Frames verwenden dieselbe API, das bedeutet, dass alles, was unsere Frames können, auch Ihre können.

Auf unserem öffentlichen [https://github.com/Embarcadero/RADStudio11Demos/tree/main/Object%20Pascal/VCL/VCL%20WelcomePage Github ] finden Sie zwei Willkommensseiten-Demos, die eine einfache und eine fortgeschrittene Verwendung zeigen.

In der einfachsten Form können Sie eine von TFrame abgeleitete Klasse erstellen und Titel anzeigen. Dieser Frame kann beliebigen Inhalt haben. Wir verfügen jedoch über komplexere Funktionen, die Sie ebenfalls nutzen können:

* Frame-Titel können angepasste UI-Elemente von Chrome enthalten (implementiert über einen zweiten Frame), genau wie einige unsere Frames z. B. der Frame "Letzte öffnen" (Schaltflächen) und der Frame "Erstellen" (Umschalten zwischen Delphi und C++)
* Unsere Frames verwenden ein MVC-Muster und laden Daten in einen Hintergrund-Thread. Sie können unsere Implementierung verwenden, einschließlich derselben Frames und Listenansichten, mit denen unsere erstellt wurden. Das bedeutet, dass Sie dasselbe Verhalten und Aussehen erhalten können, ohne unserer Setup zu imitieren, auch wenn in Zukunft Änderungen am Standardlayout, den Größen usw. vorgenommen werden.

===Verbesserungen des GetIt-Dialogfelds===

* Das GetIt-Dialogfeld wurde umgestaltet, dabei wurde die Benutzeroberfläche ähnlich beibehalten, aber es wurde eine ControlList-Komponente für die Liste der Packages hinzugefügt. Dies hat spürbare Auswirkungen auf die Leistung.
* RAD Studio speichert jetzt die Package-Symbole in GetIt, wodurch die Zeit für das erneute Öffnen des Dialogfelds verkürzt wird.
* Es gibt eine neue Option zum Ignorieren von Patches in GetIt. Damit können Sie die Installation eines Patches überspringen und die Benachrichtigung über den anstehenden Patch stoppen.

==Verbesserungen von Compilern und Toolketten==

===Delphi und C++===

===='''ASLR, DEP/NX und TSAWARE'''====

In Delphi und C++ bieten die Windows-Linker jetzt eine bessere Unterstützung für Plattform-Sicherheitskonfigurationen:
Für Delphi:

* Diese Features waren bereits als Compiler-/Linker-Flags verfügbar:
** <code>{$DYNAMICBASE} für ASLR</code>
** <code>{$SetPEOptFlags $40} für DEP/NX oder die entsprechende Option ‑‑peflags</code>

Für C++:

* Verwenden Sie die Linker-Option -GE:, um diese Flags zu aktivieren oder zu deaktivieren:

**-GE:option|0xNNNN[=on|off] Set DLL characteristics flags
ALLOWBIND | ALLOWISOLATION | DYNAMICBASE | HIGHENTROPYVA
NXCOMPAT | TSAWARE
HIGHENTROPYVA is ASLR; NXCOMPAT is DEP/NX; and TSAWARE is for Terminal Server.

Für Delphi und C++:

* Die Aktivierung dieser Einstellungen ist jetzt der Standard
* Wir erstellen weitergabefähige Binärdateien (wie BPL-Package-Dateien) mit aktivierten Sicherheitskonfigurationen

===Delphi-Debugger für macOS ARM und Android===

Wir haben einen neuen Debugger für die Ausführung einer macOS-Anwendung auf einem Apple ARM-Gerät. Dieser Debugger wird auf Intel-Computern nicht verwendet.

Dieser neue Debugger ist ein neuer Build von LLDB, und seine Schlüsseltechnologie ist ein Delphi-Parser, der eine Teilmenge der Delphi-Syntax versteht. (Beispielsweise versteht er Delphi-Ausdrücke, obwohl Sie keine neue Klasse definieren können. Er sollte genug Delphi für alle Debugger-Ausdrücke verstehen, die Sie verwenden müssen.) Diese Syntax sollte wirklich Delphi entsprechen: ohne Berücksichtigung der Groß-/Kleinschreibung und fähig, komplexe Ausdrücke in der Delphi-Syntax auszuwerten.

Wir haben '''diesen Debugger auch für Android 64 Bit aktiviert'''. Bei diesem Debugger ist es viel unwahrscheinlicher, dass er "Verbindungsabbrüche" oder Einfrieren verursacht.

===C++-Compiler und Toolkette===

* Der Standardkonstruktor für UnicodeString ist jetzt nicht mehr inline, was hilfreich ist, wenn beim Debuggen und Aufrufen einer Funktion, die einen String zurückgibt, nicht der Konstruktor herangezogen werden soll.
* AnsiStringT hat das Namespace-Präfix System::
* Viele intrinsische Header (xmmintrin.h usw.) sollten jetzt verfügbar sein.
* Dieses Release umfasst ein "Breaking Change" der C++-RTL. Das bedeutet, dass C++-Bibliotheken in 11.1 neu erzeugt werden müssen (d. h. nicht mit Objektdateien oder .lib-s linken, die mit 11 erstellt wurden). Diese Änderung bezieht sich auf die korrekte Handhabung von Handles für Win64. Einige interne RTL-Strukturen wurden in der Vergangenheit nicht verbreitert, sodass Handles möglicherweise abgeschnitten wurden. Jetzt sind sie breit genug.
* Zusätzliche intrinsische Elemente (z. B. SSE-AVX) werden jetzt mit unserer RTL ausgeliefert.
* System::DynamicArray enthält STL-Member für die Iteration, wie z. B. begin().
* Einige String-Funktionen, die in Delphi in unterstützenden Klassen waren, sind jetzt in C++ verfügbar.
* Die IDE wies ein Problem auf, bei dem die Verknüpfungspfade dazu führten, dass der Linker die klassischen Debug-Bibliotheken (falls vorhanden) vor den Clang-Release-Binärdateien fand. Das bedeutet, dass Ihre Kunden letztendlich mit der Version des falschen Compilers linken würden, wenn Sie Debug-Builds Ihrer Komponente oder Bibliothek bereitstellen und beide Compiler unterstützen würden. Dies ist jetzt behoben.
* Eine Vielzahl von Compiler-Fehlern im Debugger (insbesondere Win64) und Debug-Informationen wurden verbessert, die Verwendung einer TDS-Datei im Release-Modus, Optimierungen der Gebietseinstellungen und viele andere RTL- und STL-Bereiche, viele Verbesserungen an den Import-Bibliotheken, Korrekturen an coff2omf für die generierten OMF-Bibliotheken usw.

==LSP-Verbesserungen (Delphi und C++)==

===Delphi LSP===

* Bei DelphiLSP wurde großer Wert auf Qualität und Geschwindigkeit gelegt, und 11.1 bringt einige erhebliche Leistungsverbesserungen.
* Die wichtigste Änderung besteht darin, dass die neue höhere Leistung für alle Projekttypen gilt, auch für Packages.
* Exception-Infos werden wieder in der Symbolbeschreibung angezeigt.
* Informationen zu den Zeilennummern sind jetzt in der Symbolbeschreibung für Arrays und Mengen verfügbar.
* Durch Drücken von STRG+UMSCHALT-AB in einem inaktiven Makro/ifdef wurde zur Implementierung der nächsten deklarierten Methode gesprungen.
* Die Navigation bei gedrückter STRG-Taste funktioniert jetzt auch mit aliasierten generischen Typen. Wenn IntArray beispielsweise ein TArray<Integer> ist, führt ein STRG-Klick auf IntArray zu der Stelle mit der Deklaration des Typs TArray<Integer> und nicht zur Position von TArray<> in System.pas.
* Ein Problem wurde behoben, bei dem die Navigation mit STRG+UMSCHALT+AUF/AB nicht korrekt funktionierte, wenn sich Include-Anweisungen in der Unit befanden.
* Die Fehlermarkierung hat nicht funktioniert, wenn das Projekt Dateien verwendete, die sich auf einem anderen Laufwerk als das Projekt befanden.
* Normale Projekte werden jetzt viel schneller geladen. Die Technik, die wir zum Laden eines Projekts verwenden, wurde erheblich geändert, mit deutlich weniger Parsen. DelphiLSP sollte das Laden eines Projekts viel schneller beenden und wieder schneller auf Anforderungen reagieren.
* Die Ergebnisse der Fehlermarkierung werden jetzt viel schneller aktualisiert. Auch hier können Sie mit einer 5- bis 30-fachen Geschwindigkeitssteigerung rechnen. Die größte Verbesserung ist bei Units mit vielen Abhängigkeiten (viele andere Units werden verwendet) zu verzeichnen.

Weitere Verbesserungen:

* Bessere Handhabung von Makros (defines), sodass das Umschalten zwischen der Implementierung und der Deklaration einer Methode besser funktioniert, wenn IFDEFs vorhanden sind, ebenso bei der Programmierhilfe in Klassendeklarationen.
* Makros (defines) werden auch gefunden, wenn sie in einer einbezogenen Datei deklariert sind, was sich auf das oben Genannte auswirkt.
* Bei der Deklaration einer Eigenschaft schlägt die Programmierhilfe Getter und Setter vor.
* Die Programmierhilfe zeigt Mengentypen an.
* Typparameter werden in der Programmierhilfe in einer Klassendeklaration angezeigt, einschließlich generischer Typen (z. B., T) in einer generischen Deklaration.
* Kurzhinweise/Hilfe zu Parametern kann bei der Instanziierung generischer Typen angezeigt werden.
* Die Programmierhilfe hat einige TObject-spezifische Vervollständigungen angezeigt, wie AfterConstruction, bei der Vervollständigung innerhalb einer Record-Deklaration. Dies wurde behoben.

===C++ und cquery===

[[File:Cpp options.png|600px |link=]]

Die neue Registerkarte "LSP-Verhalten" enthält zwei Optionen, die steuern, wie der cquery-LSP-Server Dateien indiziert, d. h. wie er die Informationen speichert, die er für die Programmierhilfe, die Navigation usw. verwendet. "Server bei jeder Aktivierung eines Projekts neu starten" und "Nur im Editor geöffnete Dateien indizieren".

{{Note| Die Indizierung kann sehr rechenintensiv sein und Sie können Code Insight in der Regel nicht verwenden, bevor sie abgeschlossen ist. Beachten Sie, dass bei einem Neustart des Servers, z. B. bei einem Plattformwechsel, auch der Index gelöscht wird.}}

Weitere Verbesserungen:

* Die Elemente der Programmierhilfe werden in der Reihenfolge angezeigt, in der sie von cquery zurückgegeben werden, d. h. in der Reihenfolge des Gültigkeitsbereichs, es sei denn, Sie aktivieren die alphabetische Sortierung (ist standardmäßig deaktiviert).
* Die Indizierung sollte in den Projektoptionen für alle C++-Projekte standardmäßig aktiviert sein.
* Sie können nun Code vollständig in Header-Dateien schreiben, die nicht direkt Teil des Projekts sind (z. B. nicht Teil eines cpp/Header-Unit-Paars).
* Wenn Sie Projektoptionen oder die aktive Plattform ändern, wird der Server neu gestartet, um die neuen Projekteinstellungen zu übernehmen.
* Dem Server ist jetzt bekannt, wann eine Datei gespeichert wurde, und er aktualisiert sie korrekt. Dies ist wichtig für neue Dateien, da Code Insight in diesem Build erst dann funktioniert, wenn die Datei auf der Festplatte vorhanden ist.

Weitere C++-Features:

* Die IDE wartet korrekterweise, bis der Server bereit ist.
* Sie können Code vollständig in die Hauptquelldatei eines Projekts schreiben.

===='''Verbesserungen der Leistung'''====

* Die Programmierhilfe wird in zwei Sekunden oder weniger angezeigt, unabhängig von der Größe des Projekts. Beachten Sie, dass beim Aufrufen der Programmierhilfe im globalen Gültigkeitsbereich für ein VCL-Projekt über achtzigtausend Elemente zurückgegeben werden.

==Verbesserungen der Bibliotheken==

Um die gemeinsame Nutzung von Code in Projekten, die mit FMX und der VCL erstellt wurden, zu erleichtern, haben wir Framework-spezifische vordefinierte Symbole hinzugefügt:

* '''FRAMEWORK_VCL''' – Diese vordefinierte Variable wird auf true gesetzt, wenn das Projekt das VCL-Framework verwendet.
* '''FRAMEWORK_FMX''' – Diese vordefinierte Variable wird auf true gesetzt, wenn das Projekt das FireMonkey-Framework (FMX) verwendet.

===Delphi-RTL===

===='''Optimierungen'''====

* In Bezug auf die Delphi-RTL haben wir einige Leistungsoptimierungen durchgeführt.
* Wir haben auch Verbesserungen an _CopyArray, _IntToStr64, _IntToStr32, InitInstance, InvokeRecordInitializer, _FinalizeRecord, _UStrAsg (einschließlich der PurePascal-Version), _LStrAsg, _LStrLAsg, AnsiLowerCase/AnsiUpperCase und TStringHelper.IndexOf vorgenommen.

===='''Neue Klasse TURLStream'''====

* Es gibt eine neue Stream-Klasse, TURLStream, und eine allgemeine Basisklasse: TAsyncStream ist eine neue Basisklasse für asynchrone Streams, geerbt von TMemoryStream. TURLStream ist ein asynchroner Stream, der URL-Pfade unterstützt, geerbt von TAsyncStream.
* TAsyncStream.Create startet APopulate im Hintergrund-Thread. Solange dies nicht abgeschlossen ist, werden alle TStream-Methoden, die TAsyncStream aufrufen, blockiert. Eine Anwendung kann:
** IAsyncResult verwenden, um auf den Abschluss des Füllens von TAsyncStream zu warten/das Füllen zu prüfen. TAsyncStream unterstützt IAsyncResult.
** Eine anonyme AProvide-Methode bereitstellen, die beim Abschluss des Füllens aufgerufen wird.
* Der TURLStream-Konstruktor erweitert den Basisklassenkonstruktor und wird wie folgt deklariert:

constructor TURLStream.Create(const AURL: string;

const AProvide: TAsyncStream.TStreamer;
ASynchronizeProvide, AFreeOnCompletion: Boolean);

* TURLStream erbt das Verhalten der TAsyncStream-Basisklasse, aber verwendet intern THttpClient oder TFileStream, je nach dem URL-Schema.
* TAsyncStream definiert die folgenden als public deklarierten Methoden: Destroy, AfterConstruction, Read, Write, Seek, SetSize(Int64), SetSize(Longint), SaveToStream.
* TURLStream definiert die folgenden als public deklarierten Methoden: Destroy, RegisterSyncReqExexcutor, UnRegisterSyncReqExecutor.

===='''Weitere RTL-Verbesserungen'''====

* Unterstützung für Windows 11 und Server 2022 in der TOSVersion-Datenstruktur
* TURI.ToString berücksichtigt den Port
* TMetaFile kann nun aus einem großen Stream laden

===='''TMemIniFile und doppelte Abschnitte'''====

* TIniFile wurde geändert, um die Kompatibilität mit dem Verhalten vor 10.3 in Bezug auf doppelte Abschnitte zu verbessern.

===VCL===

Wir haben uns in erster Linie mit Problemen im Zusammenhang mit neuen Funktionen wie TTreeView, TRichEdit, TEdgeBrowser und TNumberBox befasst.

===FireMonkey===

===='''Verbesserte Android-SDK-Integration'''====

* Wir haben die Abhängigkeiten zum android.bat-Dateitool zugunsten von advmanager entfernt und das Dialogfeld "IDE-SDK-Manager" für die Android-Plattform aktualisiert.
* Die DEX-Compilierung und DEX-Zusammenführung sind jetzt nach dem C++-/Delphi-Linken verschoben, wodurch die Compilierung ohne Bereitstellung schneller erfolgt.
* Für die Kernintegration der Android-Plattform haben wir Unterstützung für Delphi-Klassen hinzugefügt, die Java-Schnittstellen mit Methodenüberladungen implementieren. Dadurch wird ein Problem mit Android 12 und dem Zugriff auf Sensoren gelöst (Korrektur der SensorInfo-Demo).
* Delphi-Klassen, die Java-Schnittstellen implementieren, können jetzt Funktionen haben, die Int8-, Int16-, Int64-, Float32- und Float64-Werte zurückgeben.

===='''TWebBrowser'''====

* Verbesserungen an TWebBrowser unter Windows (mit WebView 2-Unterstützung), einschließlich der Möglichkeit, die Windows-Engine mehrmals zu ändern. Der Standardwert der Eigenschaft WindowsEngine wurde geändert.
* Es wurden auch Probleme mit der Größenänderung und der Transparenz des Steuerelements behoben. Außerdem wurde WebBrowser für die Arbeit mit lokalen Dateien auf mobilen Geräten verbessert.

===='''Zusätzliche FMX-Qualitätsverbesserungen'''====

* Mehrere Probleme im Zusammenhang mit Windows HighDPI behoben
* Verbesserte Leistung von TMessageManager.Unsubscribe
* Option "Rückgängig" dem Kontextmenü von TMemo hinzugefügt und Probleme mit dem automatischen Scrollen des Inhalts behoben
* Verbesserungen bei der Emoji-Farbe für Android und iOS
* Verbesserungen der Unterstützung für den Metal-GPU-Treiber auf der macOS-Plattform

===Daten===

===='''Allgemein'''====

* Wir haben den Bereich "Feldverbindungs-Designer" und das Dialogfeld "Neues Feld" vergrößert und benutzerfreundlicher gemacht.
* Zur Unterstützung der langen Firebird 4.0-Feldnamen (bis zu 63 Zeichen) wurde die Begrenzung auf 31 Zeichen in Feldnamen in der Datenbank-RTL entfernt.

===='''FireDAC'''====

* Unterstützung für die '''Strukturansicht''' für FireDAC implementiert. Auch einige der FireDAC-Fenster bieten eine bessere Unterstützung für High DPI.
* Unterstützung für '''MariaDB''' 10.6-Server mit einem 10.6-Client hinzugefügt
* Unterstützung für '''SQLite SEE''' hinzugefügt mit einem Befehlszeilen-Batch zum Erzeugen von SQLite-OBJs mit C++Builder für die statische FireDAC-Bindung. In der Readme-Datei sqlite_see.txt ist der Prozess erklärt (dieses Feature war bereits für RAD Studio 11 über ein GetIt-Plugin verfügbar).
* FireDAC verbessert den Firebird 4.0-Treiber durch Unterstützung [https://firebirdsql.org/file/documentation/release_notes/html/en/4_0/rlsnotes40.html#rnfb40-ddl-new-data-types weiterer Datentypen]:
** INT128
** NUMERIC mit einer Genauigkeit von 19..38
** TIME WITH TIME ZONE, TIMESTAMP WITH TIME ZONE (begrenzt)
** DECFLOAT(16/34)
* FireDAC fügt Unterstützung für die native Anweisungszeitüberschreitung für FireBird 4.0 hinzu.
* FireDAC fügt Unterstützung für Seitengröße 32768 von FireBird 4.0 hinzu.

{{Note| Der Firebird 4.0-Client benötigt möglicherweise einige ICU-Dateien, wenn Sie mit Datentypen wie <code>TIMESTAMP WITH TIME ZONE</code> und <code>TIME WITH TIME ZONE</code> arbeiten möchten. Weitere Informationen finden Sie [https://ib-aid.com/download/docs/fb4migrationguide.html#_installing_client hier].}}

{{Warning|Für Firebird 4.0 ist die Installation von Microsoft Runtime ++ 2017 mit derselben Bitanzahl wie in der Datei <code>FBCLIENT.DLL</code> erforderlich.}}

===Internet===

===='''WebBroker auf Android'''====

* Die WebBroker-Serveranwendungen können jetzt auf Android-Geräten oder Entwicklerboards (wie Raspberry Pi mit dem Android-Betriebssystem) bereitgestellt werden. 32-Bit-Android und 64-Bit-Android werden unterstützt.

===='''DataSnap'''====

* Wir haben Web.Win.ISAPIThreadPool erweitert, um mehr als 64 Threads zuzulassen. Der Variablentyp NumberOfThreads wurde in Cardinal geändert. Die Variable ShutdownTimeout (eine Zeitüberschreitung in Millisekunden, die der Thread-Pool wartet, bevor alle Worker-Threads finalisiert werden) hat den Standardwert 2 Minuten.

===='''RAD Server'''====

* Einige Verbesserungen an der Datenbankstruktur und neue entsprechende REST-SysAdmin-Endpunkte:
** GET /sysadmin/log – gibt Informationen über den LOG-Tabelleninhalt zurück.
** POST /sysadmin/log?minTime=<ISO8601 date> – löscht alle Datensätze aus der LOG-Tabelle, die älter als das angegebene Datum/die angegebene Uhrzeit sind.
** DELETE /sysadmin/log – löscht alle Datenätze aus der LOG-Tabelle.
** GET /sysadmin/backup?backupFile=<file path> – erstellt eine angegebene Sicherungsdatei der Datenbank emsserver.ib. Die Sicherungsdatei wird auf dem InterBase-Server gespeichert.
** POST /sysadmin/backup?backupFile=<file path> – stellt die Datenbank emsserver.ib aus der angegebenen Sicherungsdatei wieder her. Die Sicherungsdatei wird auf dem InterBase-Server gespeichert.
** GET /sysadmin/validate – führt eine Validierung der emsserver.ib-Datenbank durch und gibt den Datenbankstatus zurück.
* RAD Server-Benutzer können sich von mehr als einer Sitzung aus gleichzeitig anmelden.
* Neue Bereitstellungsfunktion für RSLite
** Option in EMS.INI zum Auswählen einer bestimmten Interbase-Clientbibliothek (für eingebettete oder reguläre DB) mit dem Eintrag "ClientLib" im Abschnitt "Data".
** Es gibt jetzt eine gebrauchsfertige Bereitstellungsfunktion für RSLite.

===='''Sonstiges'''====

* Eine Option zum Auswählen eines clientseitigen Zertifikats im REST-Debugger.
* Der REST-Debugger ist jetzt DPI-fähig.
* Die Klasse TCustomRESTRequest hat die neue Eigenschaft BodyCodePage, die die Codeseite des Anforderungsrumpfs angibt. Einige der speziellen Werte sind:
** -1 (der Standardwert) – die Standardcodierung der Plattform verwenden
** 0 – aktuell aktive Codeseite
** 65001 – UTF8
* Unterstützung für das Umschalten der Region in AmazonAPI

===Siehe auch===

* [[Installationshinweise|Installationshinweise]]
* [[Release-Hinweise|Release-Hinweise]]
* [[New features and customer reported issues fixed in RAD Studio 11.1|Neue Funktionen und behobene Probleme]]
* [[Neuerungen in den letzten Releases|Neuerungen in den letzten Releases]]

[[Category:Alexandria]]

[[en:11 Alexandria - Release 1]]
[[ja:11 Alexandria - Release 1]]

Aktualisieren von VCL-Stilen

2024-04-25T13:40:04Z

Nicolas.rios: Added <code> to clActiveCaption

{{Parent|Arbeiten mit VCL-Stilen}}

Wenn Sie das Erscheinungsbild einer VCL-Anwendung ändern möchten, müssen Sie manchmal die VCL-Stile aktualisieren. Ansonsten kann es zu IDE-Problemen im Zusammenhang mit Folgendem kommen:

* Titeltext
* Schaltflächen auf der Titelleiste
* Titel des angedockten Formulars
* Symbole

[[Image:Copper Before.png|900px|link=|border]]

Um dieses Problem zu beheben, können Sie den VCL-Stil im Bitmap-Stil-Designer aktualisieren.

==Konfigurieren Ihres VCL-Stils==

Sie können die System- und Schriftfarben für den VCL-Stil wie folgt ändern:

# Wählen Sie {{Menu|Tools > [[Bitmap-Stil-Designer|Bitmap-Stil-Designer]]}} aus.
# Wählen Sie in der Objekthierarchie die Option '''Syscolors''' aus.
# Aktivieren Sie in der Ansicht "Systemfarben" die Farben <code>clActiveCaption</code> und <code>clCaptionText</code>. [[Image:System ColorsI.png|link=|border]] {{Note|Wenn die oben genannten Fehler auftreten, haben <code>clActiveCaption</code> und <code>clCaptionText</code> möglicherweise dieselbe Farbkonfiguration. Wenn Sie die Konfiguration ändern, können Sie dieses Problem beheben.}}
# Legen Sie unterschiedliche Farben dafür fest. [[Image:System Colors GoodI.png|link=|border]]
# Speichern Sie die Änderungen.
# Nach dem Speichern der Änderungen und dem Öffnen der IDE ist das Problem behoben. [[Image:VCLSyst.png|link=|border]]

==Relevante System- und Schriftfarben==

Neben der Überprüfung der obigen Konfiguration gibt es noch weitere Parameter, die Sie überprüfen sollten, wenn Sie Probleme mit der Benutzeroberfläche haben.

===Systemfarben===

clActiveCaption, clInActiveCaption, clCaptionText, clInActiveCaptionText, clWindow, clWindowsText, clBtnFace, clBtnText

===Schriftfarben===

CategoryButtonsCategoryNormal, CategoryButtonsCategorySelected, CategoryButtonsCNormal, StaticTextNormal, RadioButtonTextNormal, CheckBoxTextNormal.

==Siehe auch==

* [[Überblick über VCL-Stile|Überblick über VCL-Stile]]
* [[Bitmap-Stil-Designer|Bitmap-Stil-Designer]]
* [[Erstellen eines Stils mit dem Bitmap-Stil-Designer|Erstellen eines Stils mit dem Bitmap-Stil-Designer]]
* [[Arbeiten mit Bildern im Bitmap-Stil-Designer|Arbeiten mit Bildern im Bitmap-Stil-Designer]]
* [[Verwenden von IDE-Stilen in Plugins von Fremdherstellern|Verwenden von IDE-Stilen in Plugins von Fremdherstellern]]

[[Category:Mit Delphi fﾃｼr Windows arbeiten]]
[[Category:Delphi]]

[[en:Updating VCL Styles]]
[[ja:VCL スタイルの更新]]

Anwendungsentwicklung für Linux

2024-03-22T14:41:15Z

Nicolas.rios: RS-121905

Mit RAD Studio können Sie Anwendungen für die Linux-Plattform entwickeln. Wenn RAD Studio auf einem Windows-Computer installiert ist, können Sie eine 64-Bit-Linux-Anwendung entwickeln und sie auf einem Linux-Computer bereitstellen.
Die Entwicklung von Linux-Anwendungen ist mit der Entwicklung von Android-Apps in RAD Studio vergleichbar. Für Linux können Sie allerdings keine visuellen VCL- und FireMonkey-Anwendungen erstellen. Die folgenden Apps sind für die Linux-Plattform verfügbar:

* Konsolenanwendung
* EMS-Package (RAD Server)
* DataSnap
* DataSnap-WebBroker
* WebBroker
* Dynamische Linkbibliotheken
* DUnitX-Projekt

==Voraussetzungen==

Um Linux-Anwendungen zu entwickeln, benötigen Sie einen Windows-PC, auf dem RAD Studio installiert ist, sowie einen Computer mit der Linux-Plattform (kann eine virtuelle Maschine sein).

==Vorbereiten der Linux-Entwicklungsumgebung==

So bereiten Sie Ihr Entwicklungssystem (PC) und den Linux-Computer für die Anwendungsentwicklung mit RAD Studio vor:

# Installieren Sie RAD Studio auf dem Windows-PC.
# [[Anwendungsentwicklung für Linux#Installieren von Entwicklungs-Packages|Installieren von Entwicklungs-Packages]]
# [[Anwendungsentwicklung für Linux#Vorbereiten_des_Linux-Computers|Bereiten Sie den Linux-Computer vor]].
# [[Anwendungsentwicklung für Linux#Erstellen_eines_Verbindungsprofils|Erstellen Sie ein Verbindungsprofil]].
# [[Anwendungsentwicklung für Linux#Hinzufügen_des_installierten_SDK_zu_RAD_Studio|Fügen Sie RAD Studio das installierte SDK hinzu]].
# [[Anwendungsentwicklung für Linux#Ausführen_von_PAServer_auf_dem_Linux-Computer|Führen Sie PAServer auf dem Linux-Computer aus]].

===Installieren von Entwicklungs-Packages===

So installieren Sie Entwicklungs-Packages auf Ubuntu:

# Klicken Sie auf dem Desktop mit der rechten Maustaste, und wählen Sie '''Terminal öffnen'''.
# Um für bereits installierte Packages ein Upgrade durchzuführen, geben Sie in das Terminal <code> sudo apt update && sudo apt upgrade && sudo apt dist-upgrade</code> ein.
# Geben Sie Ihr Benutzerpasswort ein, und drücken Sie die '''Eingabetaste'''.
# Warten Sie, bis Sie aufgefordert werden, dem Upgrade der Packages zuzustimmen. Geben Sie '''J''' ein, und drücken Sie die '''Eingabetaste'''.
# Warten Sie, bis das Upgrade der Packages abgeschlossen ist. Dies kann einige Minuten dauern.
# Geben Sie zum Hinzufügen von Entwicklungs-Packages im Terminal <code> sudo apt install joe wget p7zip-full curl openssh-server build-essential zlib1g-dev libcurl4-gnutls-dev libncurses5</code> ein.
# Geben Sie Ihr Benutzerpasswort ein, und drücken Sie die '''Eingabetaste'''.
# Warten Sie, bis Sie aufgefordert werden, der Installation der Packages zuzustimmen. Geben Sie '''J''' ein, und drücken Sie die '''Eingabetaste'''.
# Warten Sie, bis die Installation der Packages abgeschlossen ist. Dies kann einige Minuten dauern.

So installieren Sie Entwicklungs-Packages auf Red Hat:

# Klicken Sie auf dem Desktop mit der rechten Maustaste, und wählen Sie '''Terminal öffnen'''.
# Geben Sie <code>yum groupinstall 'Development Tools'</code> in das Terminal ein.
# Drücken Sie die '''Eingabetaste''', und warten Sie, bis die Installation der Packages abgeschlossen ist. Dies kann einige Minuten dauern.

===Vorbereiten des Linux-Computers===

Um Linux-Anwendungen zu erstellen, müssen Sie eine virtuelle Maschinen mit PAServer hinzufügen:

: 1. Suchen Sie die Datei <code>{{PAServerLinuxInstallerFile}}</code> im folgenden Verzeichnis:
::{{Path|{{InstallPath}}\PAServer\{{PAServerLinuxInstallerFile}}}}
: 2. Entpacken Sie die Datei <code>{{PAServerLinuxInstallerFile}}</code>.

So verwenden Sie die Unit <code>System.zLib</code> unter Red Hat:

: 1. Installieren Sie die Bibliothek <code>zLib-devel</code> mit dem folgenden Befehl auf Ihrem RHEL-Computer:
:: <code>sudo yum install zlib-devel </code>
: 2. Aktualisieren Sie den lokalen SDK-Zwischenspeicher.

So verwenden Sie die Unit <code>System.zLib</code> unter Ubuntu:

: 1. Installieren Sie die Bibliothek <code>zLib-devel</code> mit dem folgenden Befehl auf Ihrem Ubuntu-Computer:
:: <code>sudo apt-get install zlib1g-dev </code>
: 2. Aktualisieren Sie den lokalen SDK-Zwischenspeicher.

===Erstellen eines Verbindungsprofils===

# Klicken Sie mit der rechten Maustaste auf den Ordner, in dem Sie die Datei <code>{{PAServerLinuxInstallerFile}}</code> entpackt haben, und klicken Sie dann auf '''Im Terminal öffnen'''.
# Geben Sie im Terminal <code>./paserver</code> ein. Drücken Sie dann '''Eingabe'''.
# Klicken Sie auf der Seite '''Tools > Optionen > Umgebungsoptionen > Verbindungsprofil-Manager''' auf die Schaltfläche '''Hinzufügen'''. Der Experte '''Verbindungsprofil erstellen''' wird geöffnet.
# Geben Sie auf der Seite '''Profilinformation''' Folgendes ein:
#* Geben Sie in das Feld '''Profilname''' den erforderlichen Namen ein.
#* Klicken Sie im Feld '''Plattform''' auf die Plattform '''64-Bit-Linux'''.
#* Klicken Sie auf '''Weiter'''.
# Geben Sie auf der Seite '''Informationen zum Remote-Computer''' Folgendes ein:
#* Geben Sie in das Feld '''Remote-Computer''' die IP-Adresse oder den Namen des Computers ein.
#* Klicken Sie auf '''Verbindung testen''', um die Gültigkeit der eingegebenen Werte zu überprüfen.
# Klicken Sie auf '''Fertig stellen'''.

===Hinzufügen des installierten SDK zu RAD Studio===

# Klicken Sie auf der Seite '''Tools > Optionen > Umgebungsoptionen > SDK-Manager''' auf die Schaltfläche '''Hinzufügen'''.
# Geben Sie im Dialogfeld '''Neues SDK hinzufügen''' Folgendes ein:
#* Klicken Sie im Feld '''Plattform auswählen''' auf '''64-Bit-Linux'''.
#* Wählen Sie im Feld '''Profil für Verbindung auswählen''' ein erstelltes Profil aus der Dropdown-Liste aus.
#* Im Feld '''SDK-Version auswählen''' wird automatisch der Name des SDK, das Sie gerade installiert haben, angezeigt. Wenn Sie das SDK nicht installiert haben, können Sie das in diesem Schritt nachholen. Wenn Sie das SDK bereits installiert haben, fahren Sie mit dem nächsten Schritt fort.

===Ausführen von PAServer auf einem Linux-Computer===

So führen Sie den PAServer auf einem Linux-Computer aus:

* Öffnen Sie das Terminal, und führen Sie PAServer im Terminal aus.

==Entwickeln von Anwendungen==

# Wählen Sie den Projekttyp für Ihre '''Delphi'''-Anwendung aus.
#*'''Datei > Neu > Weitere > Delphi-Projekte:'''
#** Konsolenanwendung
#** DUnitX-Projekt
#** Dynamische Link-Bibliothek
#** Package
#*'''Datei > Neu > Weitere > Delphi-Projekte > DataSnap-Server:'''
#** DataSnap-Server
#** DataSnap-WebBroker
#* '''Datei > Neu > Weitere > Delphi-Projekte > WebBroker > WebBroker-Anwendung'''

==Siehe auch==

* [[Anwendungsentwicklung für Linux#Installieren_des_Linux-SDK|Installieren Sie das Linux-SDK]].
* [[Anwendungsentwicklung für Linux#Vorbereiten_des_Linux-Computers|Bereiten Sie den Linux-Computer vor]].
* [[Anwendungsentwicklung für Linux#Erstellen_eines_Verbindungsprofils|Erstellen Sie ein Verbindungsprofil]].
* [[Anwendungsentwicklung für Linux#Hinzufügen_des_installierten_SDK_zu_RAD_Studio|Fügen Sie RAD Studio das installierte SDK hinzu]].
* [[Anwendungsentwicklung für Linux#Ausführen_von_PAServer_auf_dem_Linux-Computer|Führen Sie PAServer auf dem Linux-Computer aus]].
* [[FireMonkey for Linux]]
* [[Linux-Konsolenanwendung "Hello World" erstellen|Linux-Konsolenanwendung "Hello World" erstellen]]
* [[Warnmeldungen (Delphi)|Warnmeldungen (Delphi)]]
* [https://chapmanworld.com/2016/12/29/configure-delphi-and-redhat-or-ubuntu-for-linux-development/%7CConfigure Delphi and RedHat or Ubuntu for Linux development (EN)]
* [https://community.idera.com/developer-tools/b/blog/posts/preparing-ubuntu-16-04-lts-for-linux-development-with-upcoming-delphi-10-2---part-2%7CPreparing Ubuntu 16.04 LTS for Linux Development with Upcoming Delphi 10.2 (EN)]

{{DEFAULTSORT:Anwendungsentwicklung fur Linux}}

[[en:Linux Application Development]]
[[fr:Développement d'applications Linux]]
[[ja:Linux アプリケーション開発]]

InterBase-Datenbankverschlüsselung

2024-03-20T19:57:10Z

Nicolas.rios: {{Note|

{{Parent|Datenbankanwendungen entwickeln}}

Die '''InterBase-Verschlüsselung''' wird ab InterBase 2009 unterstützt. InterBase ermöglicht die Verschlüsselung von Informationen auf einer oder zwei der folgenden Ebenen:

* Verschlüsselung auf Datenbankebene (InterBase verschlüsselt alle Datenbankseiten, die Benutzerinformationen enthalten).
* Verschlüsselung auf Spaltenebene (die Verschlüsselung auf Spaltenebene ist flexibler und spezifischer).

Mit der '''InterBase-Datenbankverschlüsselung''' können Sie auch Datenbanksicherungsdateien verschlüsseln. Weitere Informationen zur Verschlüsselung von Daten mit InterBase finden Sie im '''[https://docwiki.embarcadero.com/InterBase/2020/en/Data_Definition_Guide Data Definition Guide (EN)]'''.

==Erstellen von Verschlüsselungen mit InterBase==

Um bestimmte Verschlüsselungsaufgaben in InterBase zu erstellen, müssen Sie den '''Eigentümer der Systemdatensicherheit (SYSDSO, System Data Security Owner)''' anlegen. Beide Benutzer, der '''SYSDSO''' und der '''SYSDBA''' (Datenbankeigentümer), sind für die '''InterBase-Verschlüsselung''' verantwortlich. In der folgenden Tabelle sind die Unterschiede zwischen den Aufgaben der beiden Benutzer aufgeführt:

{| border="1" frame="hsides" rules="rows"
|-
! '''Berechtigungen'''
! ''' Datenbank-   eigentümer'''
! ''' SYSDSO'''
|-
|
Erstellen von Verschlüsselungsschlüsseln
| style="text-align: center;" |'''NEIN'''
| style="text-align: center;" |'''JA'''

|-
|
Festlegen des '''SEP'''
| style="text-align: center;" |'''NEIN'''
| style="text-align: center;" |'''JA'''

|-
|
Erteilen von Verschlüsselungsberechtigungen
| style="text-align: center;" |'''NEIN'''
| style="text-align: center;" |'''JA'''

|-
|
Verschlüsseln der Datenbank
| style="text-align: center;" |'''JA'''

| style="text-align: center;" |'''NEIN'''
|-
|
Verschlüsseln von Spalten
| style="text-align: center;" |'''JA'''

| style="text-align: center;" |'''NEIN'''
|-
|
Erteilen von Entschlüsselungsberechtigungen
| style="text-align: center;" |'''JA'''

| style="text-align: center;" |'''NEIN'''
|}

Darüber hinaus können Verschlüsselungsaufgaben von jedem einzelnen Tabellenbenutzer mit der Berechtigung zum Verschlüsseln von Spalten in einer Tabelle durchgeführt werden.

==Verschlüsseln einer Datenbank mit IBConsole==

InterBase bietet zwei Möglichkeiten zur Verschlüsselung von Datenbanken. Die Verschlüsselung kann mit '''isql''' aktiviert und implementiert werden, oder Sie können mit '''IBConsole''' eine Datenbank verschlüsseln. In diesem Thema wird die zweite Option – '''Verschlüsseln einer Datenbank mit IBConsole''' – verwendet.

Führen Sie die folgenden Schritte aus, um eine Verschlüsselung beim Erstellen einer neuen Datenbank durchzuführen:

# Öffnen Sie '''IBConsole'''.
# Wählen Sie aus dem Menü '''Server > Login'''.
# Melden Sie sich als '''SYSDBA''' oder als Datenbankeigentümer an.
# Wählen Sie aus dem Menü '''Database > Create Database'''.
# Wählen Sie im Feld '''Save In''' den Ordner aus, in dem die Datenbank gespeichert werden soll.
# Geben Sie einen Dateinamen an, und klicken Sie auf '''Save'''. Das Dialogfeld wird geschlossen.
# Ändern Sie den Wert im Feld '''Embedded User Authentication''' in '''Yes'''.
#: {{Note| Das Feld '''Use Encryption''' ist jetzt sichtbar.}}
# Ändern Sie den Wert im Feld '''Use Encryption''' in '''Yes'''.
#: [[File:CreateDatabase-Encryption.png]]
# Klicken Sie auf die Schaltfläche '''OK''', um eine Datenbank zu erstellen.
# Geben Sie Ihre Verbindungsinformationen ein, und klicken Sie auf die Schaltfläche '''Connect'''.
# Klicken Sie im "Encryption Wizard" auf die Schaltfläche '''Next'''.
# Geben Sie das '''SYSDSO'''-Passwort ein, und klicken Sie auf die Schaltfläche '''Next'''.
# Geben Sie das '''SEP'''-Passwort ein, und klicken Sie auf die Schaltfläche '''Next'''.
#: [[File:ExternalOptionEnc.png]]
#: {{Note| Die Option '''External''' erschwert es nicht autorisierten Benutzern, auf eine verschlüsselte Datenbank auf einem mobilen Gerät, wie einem Laptop-Computer, oder auf einem gesicherten Desktop-Computer zuzugreifen.}}
# Geben Sie den Namen für den '''Encryption Key''' ein.
# Wählen Sie für die Option "Cipher" '''DES''' aus.
# Klicken Sie auf '''OK'''.
#: [[File:EncryptionKeyWiz.png]]
# Geben Sie den Namen und das Passwort für "BackupKey" ein.
#: {{Note| Um die Sicherheit und Vertraulichkeit von verschlüsselten Datenbanken aufrechtzuerhalten, müssen Sie auch die Datenbanksicherungsdateien verschlüsseln.}}
# Klicken Sie auf '''OK'''.
#: [[File:EncDBCompleted.png]]
# Klicken Sie im angezeigten Dialogfeld auf die Schaltfläche '''OK'''.

==Parameter für das Systemverschlüsselungspasswort in InterBase==

Bei einer verschlüsselten Datenbank in InterBase kann das '''SEP''' (System Encryption Password, Systemverschlüsselungspasswort) '''intern''' (Vorgabe, keine Verwendung eines Schlüsselwortes) oder '''extern''' (Verwendung eines Schlüsselwortes) festlegt werden.

* Das '''interne SEP''' ermöglicht, dass von Datenbankbenutzern auf die Datenbank zugegriffen werden kann, wenn die Datenbank bereits einmal mit dem '''SEP''' auf diesem Computer verwendet wurde. Bei folgenden Verbindungen oder einer Verbindung nach einem Neustart muss der '''SEP'''-Wert nicht angegeben werden. Wenn die '''{{Product}}'''-Anwendung auf einem Mac oder einem mobilen Gerät bereitgestellt wird, dann ist für die erste Verbindung der '''SEP'''-Parameterwert erforderlich.
* Bei Datenbanken, für die ein '''externes SEP''' festgelegt ist, muss bei der ersten Verbindung der '''SEP'''-Parameterwert angegeben werden. Nach einem Neustart des Computers muss die Anwendung bei der ersten Verbindung das '''SEP''' angeben. Das externe '''Systemverschlüsselungspasswort''' ist für mobile Geräte sicherer.
*: {{Note| Aktivieren Sie zum Festlegen des externen '''SEP''' im "Encryption Wizard" die Option '''External''', oder verwenden Sie den Befehl <code>alter database set system encryption password <String mit 255 Zeichen> [external]</code>.}}

{{f|dbexpress|

===Systemverschlüsselungspasswort in dbExpress===

Bei '''dbExpress''' können Sie den '''SEP'''-Wert in der [[lib_de:Data.SqlExpr.TSQLConnection|TSQLConnection]]-'''Params'''-Sammlung festlegen oder den '''SEP'''-Wert programmseitig setzen. 
[[File:ValueListEditorDBX.png]]
 

<source lang="Delphi">
procedure TForm10.BtnConnectClick(Sender: TObject);
begin
try
SQLConnection1.Params.Values['SEP']:='password';
SQLConnection1.Connected:=true;
except
on E:Exception do
ShowMessage(E.ClassName + ' ' + E.Message);
end;
end;
</source>

}}

===Systemverschlüsselungspasswort in FireDAC===

Bei '''FireDAC''' können Sie den Parameter '''SEPassword''' in den [[lib_de:FireDAC.Comp.Client.TFDConnection|TFDConnection]]-[[Herstellen einer Verbindung zu InterBase (FireDAC)|Verbindungsdefinitionsparametern]] festlegen. 
[[File:FDConnectionEdt.png]] 

<source lang="Delphi">
procedure TForm10.BtnConnectClick(Sender: TObject);
begin
try
FDConnection1.Params.Values['SEPasword']:='password';
FDConnection1.Connected:=true;
except
on E:Exception do
ShowMessage(E.ClassName + ' ' + E.Message);
end;
end;
</source>
{{f|ibx|

===Systemverschlüsselungspasswort in InterBase Express===

Bei InterBase Express ('''IBX''') wird der Parameter '''SysEncryptPassword'''-[[lib_de:IBX.IBDatabase.TIBDatabase|TIBDatabase]] programmseitig festgelegt.

<source lang="Delphi">
procedure TForm10.BtnConnectClick(Sender: TObject);
begin
try
IBDatabase1.SysEncryptPassword:='password';
IBDatabase1.Open;
except
on E:Exception do
ShowMessage(E.ClassName + ' ' + E.Message);
end;
end;
</source>}}

==Siehe auch==

* [[InterBase|InterBase]]

{{f|radstudio|

* [[InterBase ToGo|InterBase ToGo]]
* [[Lizenzierung von IBLite und IBToGo in RAD Studio|Lizenzierung von IBLite und IBToGo in {{Product}}]]
* [[Übersicht über die Funktionen von dbExpress|Übersicht über die Funktionen von dbExpress]]

}}{{f|appmethod|

* [[InterBase ToGo|InterBase ToGo]]
* [[Lizenzierung von IBLite und IBToGo|Lizenzierung von IBLite und IBToGo]]

}}
{{f|dbexpress|

* [[Übersicht über die Funktionen von dbExpress|Übersicht über die Funktionen von dbExpress]]

}}

* [[FireDAC|FireDAC]]

{{DEFAULTSORT:InterBase-Datenbankverschlusselung}}
[[Category:Delphi]]
[[Category:XE5]]
[[Category:AMMigrate]]

[[en:InterBase Database Encryption]]
[[fr:Cryptage de bases de données InterBase]]
[[ja:InterBase データベース暗号化]]

InterBase-Datenbankverschlüsselung

2024-03-20T18:05:26Z

Nicolas.rios:

{{Parent|Datenbankanwendungen entwickeln}}

Die '''InterBase-Verschlüsselung''' wird ab InterBase 2009 unterstützt. InterBase ermöglicht die Verschlüsselung von Informationen auf einer oder zwei der folgenden Ebenen:

* Verschlüsselung auf Datenbankebene (InterBase verschlüsselt alle Datenbankseiten, die Benutzerinformationen enthalten).
* Verschlüsselung auf Spaltenebene (die Verschlüsselung auf Spaltenebene ist flexibler und spezifischer).

Mit der '''InterBase-Datenbankverschlüsselung''' können Sie auch Datenbanksicherungsdateien verschlüsseln. Weitere Informationen zur Verschlüsselung von Daten mit InterBase finden Sie im '''[https://docwiki.embarcadero.com/InterBase/2020/en/Data_Definition_Guide Data Definition Guide (EN)]'''.

==Erstellen von Verschlüsselungen mit InterBase==

Um bestimmte Verschlüsselungsaufgaben in InterBase zu erstellen, müssen Sie den '''Eigentümer der Systemdatensicherheit (SYSDSO, System Data Security Owner)''' anlegen. Beide Benutzer, der '''SYSDSO''' und der '''SYSDBA''' (Datenbankeigentümer), sind für die '''InterBase-Verschlüsselung''' verantwortlich. In der folgenden Tabelle sind die Unterschiede zwischen den Aufgaben der beiden Benutzer aufgeführt:

{| border="1" frame="hsides" rules="rows"
|-
! '''Berechtigungen'''
! ''' Datenbank-   eigentümer'''
! ''' SYSDSO'''
|-
|
Erstellen von Verschlüsselungsschlüsseln
| style="text-align: center;" |'''NEIN'''
| style="text-align: center;" |'''JA'''

|-
|
Festlegen des '''SEP'''
| style="text-align: center;" |'''NEIN'''
| style="text-align: center;" |'''JA'''

|-
|
Erteilen von Verschlüsselungsberechtigungen
| style="text-align: center;" |'''NEIN'''
| style="text-align: center;" |'''JA'''

|-
|
Verschlüsseln der Datenbank
| style="text-align: center;" |'''JA'''

| style="text-align: center;" |'''NEIN'''
|-
|
Verschlüsseln von Spalten
| style="text-align: center;" |'''JA'''

| style="text-align: center;" |'''NEIN'''
|-
|
Erteilen von Entschlüsselungsberechtigungen
| style="text-align: center;" |'''JA'''

| style="text-align: center;" |'''NEIN'''
|}

Darüber hinaus können Verschlüsselungsaufgaben von jedem einzelnen Tabellenbenutzer mit der Berechtigung zum Verschlüsseln von Spalten in einer Tabelle durchgeführt werden.

==Verschlüsseln einer Datenbank mit IBConsole==

InterBase bietet zwei Möglichkeiten zur Verschlüsselung von Datenbanken. Die Verschlüsselung kann mit '''isql''' aktiviert und implementiert werden, oder Sie können mit '''IBConsole''' eine Datenbank verschlüsseln. In diesem Thema wird die zweite Option – '''Verschlüsseln einer Datenbank mit IBConsole''' – verwendet.

Führen Sie die folgenden Schritte aus, um eine Verschlüsselung beim Erstellen einer neuen Datenbank durchzuführen:

# Öffnen Sie '''IBConsole'''.
# Wählen Sie aus dem Menü '''Server > Login'''.
# Melden Sie sich als '''SYSDBA''' oder als Datenbankeigentümer an.
# Wählen Sie aus dem Menü '''Database > Create Database'''.
# Wählen Sie im Feld '''Save In''' den Ordner aus, in dem die Datenbank gespeichert werden soll.
# Geben Sie einen Dateinamen an, und klicken Sie auf '''Save'''. Das Dialogfeld wird geschlossen.
# Ändern Sie den Wert im Feld '''Embedded User Authentication''' in '''Yes'''.
#: '''Hinweis''': Das Feld '''Use Encryption''' ist jetzt sichtbar.
# Ändern Sie den Wert im Feld '''Use Encryption''' in '''Yes'''.
#: [[File:CreateDatabase-Encryption.png]]
# Klicken Sie auf die Schaltfläche '''OK''', um eine Datenbank zu erstellen.
# Geben Sie Ihre Verbindungsinformationen ein, und klicken Sie auf die Schaltfläche '''Connect'''.
# Klicken Sie im "Encryption Wizard" auf die Schaltfläche '''Next'''.
# Geben Sie das '''SYSDSO'''-Passwort ein, und klicken Sie auf die Schaltfläche '''Next'''.
# Geben Sie das '''SEP'''-Passwort ein, und klicken Sie auf die Schaltfläche '''Next'''.
#: [[File:ExternalOptionEnc.png]]
#: '''Hinweis''': Die Option '''External''' erschwert es nicht autorisierten Benutzern, auf eine verschlüsselte Datenbank auf einem mobilen Gerät, wie einem Laptop-Computer, oder auf einem gesicherten Desktop-Computer zuzugreifen.
# Geben Sie den Namen für den '''Encryption Key''' ein.
# Wählen Sie für die Option "Cipher" '''DES''' aus.
# Klicken Sie auf '''OK'''.
#: [[File:EncryptionKeyWiz.png]]
# Geben Sie den Namen und das Passwort für "BackupKey" ein.
#: '''Hinweis''': Um die Sicherheit und Vertraulichkeit von verschlüsselten Datenbanken aufrechtzuerhalten, müssen Sie auch die Datenbanksicherungsdateien verschlüsseln.
# Klicken Sie auf '''OK'''.
#: [[File:EncDBCompleted.png]]
# Klicken Sie im angezeigten Dialogfeld auf die Schaltfläche '''OK'''.

==Parameter für das Systemverschlüsselungspasswort in InterBase==

Bei einer verschlüsselten Datenbank in InterBase kann das '''SEP''' (System Encryption Password, Systemverschlüsselungspasswort) '''intern''' (Vorgabe, keine Verwendung eines Schlüsselwortes) oder '''extern''' (Verwendung eines Schlüsselwortes) festlegt werden.

* Das '''interne SEP''' ermöglicht, dass von Datenbankbenutzern auf die Datenbank zugegriffen werden kann, wenn die Datenbank bereits einmal mit dem '''SEP''' auf diesem Computer verwendet wurde. Bei folgenden Verbindungen oder einer Verbindung nach einem Neustart muss der '''SEP'''-Wert nicht angegeben werden. Wenn die '''{{Product}}'''-Anwendung auf einem Mac oder einem mobilen Gerät bereitgestellt wird, dann ist für die erste Verbindung der '''SEP'''-Parameterwert erforderlich.
* Bei Datenbanken, für die ein '''externes SEP''' festgelegt ist, muss bei der ersten Verbindung der '''SEP'''-Parameterwert angegeben werden. Nach einem Neustart des Computers muss die Anwendung bei der ersten Verbindung das '''SEP''' angeben. Das externe '''Systemverschlüsselungspasswort''' ist für mobile Geräte sicherer.
*: '''Hinweis''': Aktivieren Sie zum Festlegen des externen '''SEP''' im "Encryption Wizard" die Option '''External''', oder verwenden Sie den Befehl <code>alter database set system encryption password <String mit 255 Zeichen> [external]</code>.

{{f|dbexpress|

===Systemverschlüsselungspasswort in dbExpress===

Bei '''dbExpress''' können Sie den '''SEP'''-Wert in der [[lib_de:Data.SqlExpr.TSQLConnection|TSQLConnection]]-'''Params'''-Sammlung festlegen oder den '''SEP'''-Wert programmseitig setzen. 
[[File:ValueListEditorDBX.png]]
 

<source lang="Delphi">
procedure TForm10.BtnConnectClick(Sender: TObject);
begin
try
SQLConnection1.Params.Values['SEP']:='password';
SQLConnection1.Connected:=true;
except
on E:Exception do
ShowMessage(E.ClassName + ' ' + E.Message);
end;
end;
</source>

}}

===Systemverschlüsselungspasswort in FireDAC===

Bei '''FireDAC''' können Sie den Parameter '''SEPassword''' in den [[lib_de:FireDAC.Comp.Client.TFDConnection|TFDConnection]]-[[Herstellen einer Verbindung zu InterBase (FireDAC)|Verbindungsdefinitionsparametern]] festlegen. 
[[File:FDConnectionEdt.png]] 

<source lang="Delphi">
procedure TForm10.BtnConnectClick(Sender: TObject);
begin
try
FDConnection1.Params.Values['SEPasword']:='password';
FDConnection1.Connected:=true;
except
on E:Exception do
ShowMessage(E.ClassName + ' ' + E.Message);
end;
end;
</source>
{{f|ibx|

===Systemverschlüsselungspasswort in InterBase Express===

Bei InterBase Express ('''IBX''') wird der Parameter '''SysEncryptPassword'''-[[lib_de:IBX.IBDatabase.TIBDatabase|TIBDatabase]] programmseitig festgelegt.

<source lang="Delphi">
procedure TForm10.BtnConnectClick(Sender: TObject);
begin
try
IBDatabase1.SysEncryptPassword:='password';
IBDatabase1.Open;
except
on E:Exception do
ShowMessage(E.ClassName + ' ' + E.Message);
end;
end;
</source>}}

==Siehe auch==

* [[InterBase|InterBase]]

{{f|radstudio|

* [[InterBase ToGo|InterBase ToGo]]
* [[Lizenzierung von IBLite und IBToGo in RAD Studio|Lizenzierung von IBLite und IBToGo in {{Product}}]]
* [[Übersicht über die Funktionen von dbExpress|Übersicht über die Funktionen von dbExpress]]

}}{{f|appmethod|

* [[InterBase ToGo|InterBase ToGo]]
* [[Lizenzierung von IBLite und IBToGo|Lizenzierung von IBLite und IBToGo]]

}}
{{f|dbexpress|

* [[Übersicht über die Funktionen von dbExpress|Übersicht über die Funktionen von dbExpress]]

}}

* [[FireDAC|FireDAC]]

{{DEFAULTSORT:InterBase-Datenbankverschlusselung}}
[[Category:Delphi]]
[[Category:XE5]]
[[Category:AMMigrate]]

[[en:InterBase Database Encryption]]
[[fr:Cryptage de bases de données InterBase]]
[[ja:InterBase データベース暗号化]]

Herstellen einer Verbindung zu InterBase (FireDAC)

2024-03-20T17:59:16Z

Nicolas.rios: RS-121926

{{Parent|Datenbankkonnektivität (FireDAC)}}
In diesem Thema wird beschrieben, wie eine Verbindung zu {{Company}} InterBase hergestellt wird.

==Unterstützte Versionen==

Der native FireDAC-Treiber unterstützt die {{Company}}-Editionen von InterBase Server, Desktop, Developer, [http://edn.embarcadero.com/article/42319 ToGo (EN)] und IBLite Version 6 und höher.

Verwenden Sie den FireDAC-[[Herstellen einer Verbindung zu Firebird (FireDAC)|Firebird-Treiber]], um eine Verbindung zu Firebird oder dem Jaffil-Server herzustellen.

==Client-Software==

===Windows-Client-Software===

Für FireDAC muss die folgende x86- oder x64-Client-Software auf dem Arbeitsplatz-Computer installiert sein:

*'''InterBase Server''':
** '''Win32''': Die Bibliothek '''GDS32.DLL''' für die Verbindung zu InterBase Server, Desktop oder Developer von x86-Anwendungen aus.
** '''Win64''': Die Bibliothek '''IBCLIENT64.DLL''' für die Verbindung zu InterBase Server, Desktop oder Developer von x64-Anwendungen aus.
*'''InterBase ToGo''':
** '''Win32''': Die Bibliothek '''IBTOGO.DLL''' für die Arbeit mit Datenbanken mit eingebettetem InterBase ToGo von x86-Anwendungen aus.
** '''Win64''': Die Bibliothek '''IBTOGO64.DLL''' für die Arbeit mit Datenbanken mit eingebettetem InterBase ToGo von x64-Anwendungen aus.

Sie können die erforderlichen Dateien in einen der folgenden Ordner einfügen:

* In einen in der Umgebungsvariable PATH aufgeführten Ordner (z. B. <Windows>\SYSTEM32).
* In Ihren Anwendungs-EXE-Ordner.
* In einen beliebigen anderen Ordner und in der Datei [[Konfigurieren von Treibern (FireDAC)|FDDrivers.ini]] Folgendes angeben:

<source lang="ini">
[IB]
VendorLib=<folder>\gds32.dll</source>

Wenn die InterBase-Client-Bibliothek nicht ordnungsgemäß installiert wurde, wird beim Verbindungsversuch eine Exception ausgelöst:

[FireDAC][Phys][IB]-314. Cannot load vendor library [gds32.dll]. The specified module could not be found.
Check [gds32.dll], which is located in one of the PATH directories or in the application EXE directory.

===macOS-Client-Software===

FireDAC benötigt:

* Die x86-Client-Bibliothek '''libgds.dylib''', um eine Verbindung zum InterBase-Server herzustellen. Verwenden Sie in {{Product}} {{Menu|Projekt > Bereitstellung > Weitere Dateien hinzufügen > InterBase-Client\OSX32}}.
* Die eingebettete InterBase-x86-Datei '''libibtogo.dylib'''. Verwenden Sie in {{Product}} {{Menu|Projekt > Bereitstellung > Weitere Dateien hinzufügen > InterBase ToGo\OSX32}}.

===iOS-Client-Software===

FireDAC benötigt:

* Für 64-Bit-iOS-Geräte - die eingebettete InterBase-Datei '''libibtogo.a''' als statische ARM-Bibliothek. Verwenden Sie in {{Product}} {{Menu|Projekt > Bereitstellung > Weitere Dateien hinzufügen > InterBase ToGo\iOSDevice64}}.

Beachten Sie, dass der Einbindungsmodus nicht ausgewählt werden kann.

===Android-Client-Software===

FireDAC benötigt:

* Die eingebettete InterBase-Datei '''libibtogo.a''' als statische ARM-Bibliothek. Verwenden Sie in {{Product}} {{Menu|Projekt > Bereitstellung > Weitere Dateien hinzufügen > InterBase ToGo\Android}}.

Beachten Sie, dass der Einbindungsmodus nicht ausgewählt werden kann.

===Linux-Client-Software===

FireDAC benötigt:

* Die x64-Client-Bibliothek '''libgds.so''', um eine Verbindung zum InterBase-Server herzustellen. Verwenden Sie in {{Product}} {{Menu|Projekt > Bereitstellung > Weitere Dateien hinzufügen > InterBase-Client\Linux}}.
* Die eingebettete InterBase-x64-Datei '''libibtogo.so'''. Verwenden Sie in {{Product}} {{Menu|Projekt > Bereitstellung > Weitere Dateien hinzufügen > InterBase ToGo\Linux}}.

==Treibereinbindung==

So binden Sie den Treiber ein:

* Ziehen Sie aus der [[Tool-Palette|Tool-Palette]] eine [[lib_de:FireDAC.Phys.IB.TFDPhysIBDriverLink|TFDPhysIBDriverLink]]- und eine [[lib_de:FireDAC.Comp.Client.TFDConnection|TFDConnection]]-Komponente auf das Formular.
* Oder nehmen Sie die Unit [[lib_de:FireDAC.Phys.IB|FireDAC.Phys.IB]] in die uses-Klausel auf.

==Verbindungsdefinitionsparameter==

Für eine Verbindung mit InterBase ist für die meisten Anwendungen die Angabe der Verbindungsdefinitionsparameter '''DriverID''', '''Protocol''', '''Server''', '''Database''', '''User_Name''', '''Password''' und '''CharacterSet''' erforderlich (Einzelheiten finden Sie unter [[Definieren von Verbindungen (FireDAC)|Definieren von Verbindungen (FireDAC)]]).

'''DriverID=IB''' oder '''DriverID=IBLite''' 

{| border="1" frame="hsides" rules="rows"
|-
! '''Parameter'''
! '''Beschreibung'''
! '''Beispielwert'''
|-
| style="text-align: left; vertical-align: top;" | '''Database '''
| style="text-align: left; vertical-align: top;" |
Der Name der zuzuordnenden Datenbank. Folgende Werte sind möglich:
* Datenbankdateipfad.
* Vollständiger Datenbankpfad, einschließlich Serveradresse.

Bei einer eingebetteten Datenbank kann ein Pfad [[Pfadvariablen (FireDAC)|Pfadvariablen]] enthalten.
| style="text-align: left; vertical-align: top;" |
* C:\ib\ADDEMO_IB2007.IB
* 127.0.0.1:C:\ib\ADDEMO_IB2007.IB
* \\MySrv\C:\ib\ADDEMO_IB2007.IB
|-
| style="text-align: left; vertical-align: top;" | '''OSAuthent '''
| style="text-align: left; vertical-align: top;" |
{{note|Nur für '''DriverID<nowiki> = </nowiki>IB'''.}}
Steuert den Authentifizierungsmodus:
* '''Yes''' – Windows-Authentifizierung verwenden.
* '''No''' – DBMS-Authentifizierung verwenden. Das ist der Vorgabewert.
| style="text-align: left; vertical-align: top;" | Yes
|-
| style="text-align: left; vertical-align: top;" | '''User_Name '''
| style="text-align: left; vertical-align: top;" | Der Benutzername.
| style="text-align: left; vertical-align: top;" | sysdba
|-
| style="text-align: left; vertical-align: top;" | '''Password '''
| style="text-align: left; vertical-align: top;" | Das Benutzerpasswort.
| style="text-align: left; vertical-align: top;" | masterkey
|-
| style="text-align: left; vertical-align: top;" | '''CharacterSet '''
| style="text-align: left; vertical-align: top;" | Legt den zu verwendenden Zeichensatz fest. Es wird dringend empfohlen, den Parameter '''CharacterSet''' auf einen der folgenden Werte zu setzen:
* UTF8, wenn Ihre Anwendung Unicode unterstützen muss. Einzelheiten finden Sie unter "Verwenden von Unicode (FireDAC)".
* WIN1250 für Mitteleuropa.
* WIN1251 für Kyrillisch.
* WIN1252 für Westeuropa, Amerika.
* usw.
| style="text-align: left; vertical-align: top;" | WIN1252
|-
| style="text-align: left; vertical-align: top;" | '''ExtendedMetadata '''
| style="text-align: left; vertical-align: top;" |
Steuert die [[Erweiterte Metadaten (FireDAC)|erweiterte Beschreibung]] von Abfrage-Ergebnismengen:
* '''True''' – FireDAC erhält Spaltendomänennamen zusätzlich zu den anderen Spaltenattributen. Wenn eine Spalte zu einer Domäne mit demselben Namen gehört, wie z. B. '''%BOOL%''', wird sie als '''dtBoolean''' beschrieben. Wenn eine Tabelle über einen '''INSERT-Trigger''' verfügt, der eine einzelne Sequenz liest und deren Wert einer einzelnen Spalte zuweist, dann wird diese Spalte als eine '''Auto-Inkrementierungsspalte''' beschrieben. Durch Setzen dieser Option auf '''True''' wird das Öffnen von Datenmengen geringfügig verlangsamt.
* '''False''' – FireDAC verwendet die beschränkten Informationen über die Abfragespalten. Das ist der Vorgabewert.
| style="text-align: left; vertical-align: top;" | False
|-
| style="text-align: left; vertical-align: top;" | '''Port'''
| style="text-align: left; vertical-align: top;" |
{{note|Nur für '''DriverID<nowiki> = </nowiki>IB'''.}}
Der TCP/IP-Port, über den der InterBase-Server empfängt. Standardmäßig entspricht dieser Port dem in den Diensten definierten Port von '''gds_db'''. Normalerweise ist dies Port 3050. Wenn '''gds_db''' nicht definiert ist, dann sollten Sie den Parameter '''Port''' auf den erforderlichen Wert setzen.
| style="text-align: left; vertical-align: top;" | 3051
|-
| style="text-align: left; vertical-align: top;" | '''Protocol '''
| style="text-align: left; vertical-align: top;" |
{{note|Nur für '''DriverID<nowiki> = </nowiki>IB'''.}}
Das für die Verbindung mit dem DB-Server verwendete Protokoll. Folgende Werte sind möglich:
* '''Local''' – Herstellen einer Verbindung zu einem lokal ausgeführten Server, zu einem eingebetteten Server oder zu einem Server mit einem Alias.
* '''NetBEUI''' – Herstellen einer Verbindung über das Microsoft NetBIOS-Protokoll.
* '''SPX''' – Herstellen einer Verbindung über das Novell SPX-Protokoll.
* '''TCPIP''' – Herstellen einer Verbindung über das TCP/IP-Protokoll.

Wenn der Parameter "Protocol" angegeben ist, erstellt FireDAC vollständige Datenbankpfade im entsprechenden Protokollformat und mit den jeweiligen Parameterwerten für "Server" und "Database".
| style="text-align: left; vertical-align: top;" | TCPIP
|-
| style="text-align: left; vertical-align: top;" | '''Server '''
| style="text-align: left; vertical-align: top;" |
{{note|Nur für '''DriverID<nowiki> = </nowiki>IB'''.}}
Legt die Adresse des Servers, zu dem eine Verbindung hergestellt werden soll, fest. Der "Server"-Parameterwert wird nur verwendet, wenn der Parameter "Protocol" angegeben ist.
| style="text-align: left; vertical-align: top;" | 127.0.0.1
|-
| style="text-align: left; vertical-align: top;" | '''InstanceName '''
| style="text-align: left; vertical-align: top;" |
{{note|Nur für '''DriverID<nowiki> = </nowiki>IB'''.}}
Der Name der InterBase-Instanz. Wird ab InterBase 2007 unterstützt.
| style="text-align: left; vertical-align: top;" | srv2
|-
| style="text-align: left; vertical-align: top;" | '''SQLDialect '''
| style="text-align: left; vertical-align: top;" |
{{note|Nur für '''DriverID<nowiki> = </nowiki>IB'''.}}
Der für die Verbindung zu verwendende SQL-Dialekt. 3 ist der Vorgabewert.
| style="text-align: left; vertical-align: top;" | 1
|-
| style="text-align: left; vertical-align: top;" | '''RoleName '''
| style="text-align: left; vertical-align: top;" |
{{note|Nur für '''DriverID<nowiki> = </nowiki>IB'''.}}
Der Standardrollenname.
| style="text-align: left; vertical-align: top;" | Admin
|-
| style="text-align: left; vertical-align: top;" | '''OpenMode '''
| style="text-align: left; vertical-align: top;" |
Legt fest, wie die Datenbank geöffnet werden soll. Die folgenden Modi werden unterstützt:
* '''Open''' -- Öffnen einer vorhandenen Datenbankdatei, die im Parameter '''Database''' angegeben ist, unmittelbar nach der Verbindung mit dem Server. Wenn die angegebene Datenbank nicht vorhanden ist, löst die Anwendung eine Exception aus. Das ist der Vorgabewert.
* '''Create''' – Erstellen einer neuen Datenbank. Wenn die angegebene Datenbank vorhanden ist, löst die Anwendung eine Exception aus.
* '''OpenOrCreate''' – Öffnen einer vorhandenen Datenbank oder Erstellen einer neuen Datenbank, wenn die angegebene Datenbank nicht vorhanden ist.
| style="text-align: left; vertical-align: top;" | Open
|-
| style="text-align: left; vertical-align: top;" | '''DropDatabase '''
| style="text-align: left; vertical-align: top;" |
Steuert das Löschen einer vorhandenen Datenbank:
* '''Yes''' – Löschen der Datenbankdatei, die im Parameter "Database" angegeben ist, unmittelbar nach Aufheben der Verbindung mit dem Server.
* '''No''' – Datenbank nicht löschen. Das ist der Vorgabewert.
| style="text-align: left; vertical-align: top;" | Yes
|-
| style="text-align: left; vertical-align: top;" | '''PageSize '''
| style="text-align: left; vertical-align: top;" | Die Seitengröße für die neu erstellte Datenbank, wenn "CreateDatabase = Yes". 4096 ist der Vorgabewert.
| style="text-align: left; vertical-align: top;" | 8192
|-
| style="text-align: left; vertical-align: top;" | '''IBAdvanced '''
| style="text-align: left; vertical-align: top;" | Die durch ";" getrennte Liste mit weiteren Parametern. In der Unit FireDAC.Phys.IBWrapper (beim Konstanten-Array DPBInfos) finden Sie die vollständige Liste der unterstützten Parameter. Die Beschreibung des hier aufgeführten Codes finden Sie in den InterBase-Handbüchern.
| style="text-align: left; vertical-align: top;" |
|-
| style="text-align: left; vertical-align: top;" | '''GUIDEndian '''
| style="text-align: left; vertical-align: top;" | Definiert, wie der GUID-Wert auf dem Client repräsentiert wird. "Little" ist der Vorgabewert.
| style="text-align: left; vertical-align: top;" | Big
|}

==Anwendungsfälle==

===Verwenden einer sicheren Verbindung===

Übergeben Sie für die Verwendung der TLS/SSL-Verschlüsselung das Schlüssel/Wertepaar {{Code|1=ssl=true}} für den Wert des Parameters '''Database''' wie folgt:

DriverID=IB
Database=my.interbasehost.net/3065?ssl=true?serverPublicFile=C:\PublicCertFileOnClient\CertFile.pem??:C:/DB/TEST.IB
User_Name=sysdba
Password=masterkey
CharacterSet=UTF8
ExtendedMetadata=True

Weitere Einzelheiten finden Sie in der [https://docwiki.embarcadero.com/InterBase/2020/en/Operations_Guide Dokumentation zu InterBase (EN)] in Kapitel 5 ab Seite 5.

===Weitere Anwendungsfälle===

* Herstellen einer Verbindung über das TCP/IP-Protokoll zu einer Datenbank, die auf einem Remote-Server ausgeführt wird:

DriverID=IB
Database=C:\ib\ADDEMO_IBXE3.gdb
Protocol=TCPIP
Server=IBSrv
User_Name=sysdba
Password=masterkey
CharacterSet=win1252
ExtendedMetadata=True

* Herstellen einer Verbindung über das TCP/IP-Protokoll zu einer Datenbank, die auf einem Remote-Server ausgeführt wird:

DriverID=IB
Database=IBSrv:C:\ib\ADDEMO_IBXE3.gdb
User_Name=sysdba
Password=masterkey
CharacterSet=utf8

* Herstellen einer Verbindung zu einer lokalen Datenbank:

DriverID=IB
Database=C:\ib\ADDEMO_IBXE3.gdb
User_Name=sysdba
Password=masterkey
CharacterSet=win1251

* Herstellen einer Verbindung zu einer InterBase ToGo-Datenbank:

Legen Sie die Komponente TFDPhysIBDriverLink auf dem Formular ab, und setzen Sie "VendorLib" auf <Ihr Pfad>\ibtogo.dll, oder verwenden Sie eine virtuelle Treiberdefinition.

DriverID=IB
Database=C:\ib\ADDEMO_IBXE3.gdb
User_Name=sysdba
Password=masterkey
CharacterSet=utf8

* Herstellen einer Verbindung zu einer Datenbankdatei im Ordner "Documents" auf einem iOS-Gerät:

DriverID=IB
User_Name=sysdba
Password=masterkey
Database=$(DOC)/ADDEMO.GDB
SQLDialect=3
CharacterSet=UTF8
ExtendedMetadata=True

* Herstellen einer Verbindung zu einer verschlüsselten Datenbankdatei im externen Speicher des Android-Geräts:

DriverID=IB
User_Name=sysdba
Password=masterkey
Database=$(DOC)/ADDEMO.GDB
SQLDialect=3
CharacterSet=UTF8
ExtendedMetadata=True
SEPassword=12345

* Herstellen einer Verbindung zu einer IBLite-Datenbank:

DriverID=IBLite
Database=C:\ib\ADDEMO_IBXE3.gdb
User_Name=sysdba
Password=masterkey
CharacterSet=utf8

==Siehe auch==

* [[Allgemeine Verbindungsparameter (FireDAC)|Allgemeine Verbindungsparameter]]
* [[FAQ (FireDAC)|FAQs]]
* [[Konfigurieren von Treibern (FireDAC)|Konfigurieren von FireDAC-Treibern]]
* [[Definieren von Verbindungen (FireDAC)|Verwalten von FireDAC-Verbindungsdefinitionen]]
* [[Tutorial: Verwenden von FireDAC aus einer geräteübergreifenden Anwendung auf Desktop-Plattformen|Tutorial: Verwenden von FireDAC aus einer geräteübergreifenden Anwendung auf Desktop-Plattformen]]

===Beispiele===

* [[samp_en:FireDAC.InterBase Sample|FireDAC InterBase]] (Beispiel)

[[Category:FireDAC]]
[[Category:AMMigrate]]

[[en:Connect to InterBase (FireDAC)]]
[[fr:Connexion à InterBase (FireDAC)]]
[[ja:InterBase への接続（FireDAC）]]

InterBase

2024-03-20T17:55:46Z

Nicolas.rios: RS-121926

{{Parent|Datenbankanwendungen entwickeln}}

{{Product}} unterstützt InterBase {{InterBaseVersion}}-Datenbanken vollständig. InterBase {{InterBaseVersion}} wird mit {{Product}} in folgendem Verzeichnis installiert: {{Path|{{InstallPath}}\InterBase{{InterBaseVersion}}}}.

==Voraussetzungen==

Folgende Voraussetzungen sind für die Verwendung von InterBase {{InterBaseVersion}}-Datenbanken erforderlich:

* Die neueste Client-Version von InterBase (wenn Sie {{Variables|Product}} installieren, wird die richtige Client-Version von InterBase {{InterBaseVersion}} automatisch installiert, außer Sie deaktivieren InterBase {{InterBaseVersion}} ausdrücklich.)
* Ein x64-Computer für die neue Plattformunterstützung (nur bei Verwendung von 64 Bit)

Die 64-Bit-Edition kann auf den folgenden Betriebssystemen installiert werden:

* Microsoft Windows 10
* Microsoft Windows 8.1
* Microsoft Windows 7
* Windows Server 2016
* Windows Server 2012 R2
* macOS El Capitan 10.11
* macOS Sierra 10.12
* macOS High Sierra 10.13
* macOS Mojave 10.14
* macOS Catalina 10.15

===Starten des InterBase-Servers===

#Wählen Sie dazu {{InterBaseServerManagerMenu}}
#Starten Sie im '''InterBase {{InterBaseVersion}} 64 Server Manager''' den InterBase-Server, falls er noch nicht ausgeführt wird.

=={{Product}}-Unterstützung für InterBase==

===Integrierte Lizenzierung für InterBase {{InterBaseVersion}}===

'''InterBase {{InterBaseVersion}} Developer Edition''' wird mit {{Product}} installiert <f s="radstudio" t="span" />(gilt nicht für die Starter-Edition)<f e="radstudio" t="span" /> und ist in der {{Product}}-Lizenz integriert. '''InterBase {{InterBaseVersion}} ToGo''' muss nicht auf einem Server oder einem Endbenutzer-Arbeitsplatz installiert werden und verfügt über zwei Lizenzierungsoptionen für die Bereitstellung: '''ToGo''' und '''IBLite'''. Dieses Leistungsmerkmal erleichtert Entwicklern das Erstellen von {{CBuilder}}- und {{Delphi}}-InterBase-Anwendungen mit {{Product}}.

{{Note|Unterstützung für macOS-64-Bit steht nur für Delphi-Anwendungen zur Verfügung.}}

{{Attention|Die macOS-64-Bit-Dateien sind jetzt in einem eigenen Ordner vorhanden, nicht mehr im selben Ordner wie die macOS-32-Bit-Dateien für InterBase ToGo.}}

==Neuerungen InterBase {{InterBaseVersion}}==

Einzelheiten finden Sie in der [http://docwiki.embarcadero.com/InterBase/2020/en/Readme Readme-Datei] zu InterBase {{InterBaseVersion}}.

Weitere Einzelheiten zu den neuen Features in InterBase {{InterBaseVersion}} finden Sie unter [http://docwiki.embarcadero.com/InterBase/2020/en/What%27s_New InterBase 2020]

==Siehe auch==

* [[Datenbankanwendungen entwickeln - Index|Datenbankanwendungen entwickeln - Index]]
* [http://www.embarcadero.com/database-in-action/interbase-labs InterBase-Videos (EN)]
* [[Tutorial: Eine InterBase-Datenbank in einer Delphi- oder C++-Anwendung verwenden|Tutorial: Eine InterBase-Datenbank in einer {{Delphi}}- oder C++-Anwendung verwenden]]
* [[Tutorial: Mit InterBase Express auf eine Datenbank zugreifen|Tutorial: Mit InterBase Express auf eine Datenbank zugreifen]]
* [[InterBase-Datenbankverschlüsselung|InterBase-Datenbankverschlüsselung]]
* [[Bereitstellungslizenz für IBLite und IBToGo|Bereitstellungslizenz für IBLite und IBToGo]]
* InterBase 2020-Readme, verfügbar im Produktinstallationsverzeichnis im Ordner \Interbase2020\Doc.
** [https://docwiki.embarcadero.com/InterBase/2020/en/InterBase_2020_Readme InterBase 2020 Online Readme (EN)]

===Beispiele===

* [[samp_en:FireDAC.InterBase Sample|FireDAC InterBase]] sample

[[Category:Windows-Entwicklerhandbuch]]
[[Category:Delphi]]
[[Category:XE6]]
[[Category:AMMigrate]]

[[en:InterBase]]
[[fr:InterBase]]
[[ja:InterBase]]

Verwenden von InterBase mit FireDAC

2024-03-20T15:19:08Z

Nicolas.rios: RS-121926

{{Parent|Arbeiten mit DBMS (FireDAC)}}

==Transaction Wait Time==

Mit dem folgenden Code können Sie [http://docwiki.embarcadero.com/InterBase/2020/en/Wait_time Transaction Wait Time (EN)] mit FireDAC verwenden:
<source lang="sql">

FDConnection1.TxOptions.Params.Clear;
FDConnection1.TxOptions.Params.Add('wait_time=1000'); // 1000 seconds
FDConnection1.StartTransaction;
try
// perform required DB actions
FDConnection1.Commit;
except
FDConnection1.Rollback;
raise;
end;
</source>

==Exclusive Isolation Level==

Mit dem folgenden Code verwenden Sie [http://docwiki.embarcadero.com/InterBase/2020/en/Exclusive_Isolation_Level Exclusive Isolation Level (EN)] mit FireDAC verwenden:
<source lang="sql">
FDConnection1.TxOptions.Isolation := xiUnspecified;
FDConnection1.TxOptions.Params.Clear;
FDConnection1.TxOptions.Params.Add('exclusive');
FDConnection1.StartTransaction;
try
// perform required DB actions
FDConnection1.Commit;
except
FDConnection1.Rollback;
raise;
end;
</source>

==Siehe auch==

* [[Herstellen einer Verbindung zu InterBase (FireDAC)|Herstellen einer Verbindung zu InterBase]]

[[en:Using InterBase with FireDAC]]
[[fr:Utilisation d'InterBase avec FireDAC]]
[[ja:FireDAC での InterBase の利用]]

Arbeiten mit DBMS (FireDAC)

2024-03-20T15:16:49Z

Nicolas.rios: RS-121926

{{Parent|FireDAC}}

Dieser Abschnitt enthält eine Reihe von Artikeln über die Arbeit mit einer bestimmten Datenbank in einer FireDAC-Anwendung.

==Themen==

{| border="1" frame="hsides" rules="rows"
|-
! '''Thema'''
! '''Beschreibung'''
|-
| style="text-align: left; vertical-align: top;" | [[Verwenden von SQLite mit FireDAC|Verwenden von SQLite mit FireDAC]]
| style="text-align: left; vertical-align: top;" | In diesem Artikel werden die Aspekte der Entwicklung von [http://www.sqlite.org/ SQLite (EN)]-Datenbankanwendungen mit FireDAC für {{Delphi}} beschrieben. SQLite ist eine eingebettete SQL-Datenbank-Engine, die weltweit [http://www.sqlite.org/mostdeployed.html am häufigsten eingesetzte (EN)] SQL-Datenbank.
|-
| style="text-align: left; vertical-align: top;" | [[Verwenden von Oracle mit FireDAC|Verwenden von Oracle mit FireDAC]]
| style="text-align: left; vertical-align: top;" | In diesem Artikel werden die Aspekte der Entwicklung von [http://www.oracle.com/us/products/database/overview/index.html Oracle (EN)]-Datenbankanwendungen mit FireDAC für {{Delphi}} beschrieben. Oracle ist ein relationaler Datenbankserver auf Unternehmensebene, weltweit führend bei den mit RDBMS-Software erzielten Umsätzen.
|-
| style="text-align: left; vertical-align: top;" | [[Verwenden von InterBase mit FireDAC|Verwenden von InterBase mit FireDAC]]
| style="text-align: left; vertical-align: top;" | In diesem Artikel werden die Aspekte der Entwicklung von [http://docwiki.embarcadero.com/InterBase/2020/en/Main_Page InterBase (EN)]-Datenbankanwendungen mit FireDAC für {{Delphi}} beschrieben. InterBase ist eine schlanke, integrierbare relationale Hochleistungsdatenbank ohne Verwaltungsaufwand für Softwareentwickler.
|}

[[Category:FireDAC]]
[[Category:AMMigrate]]

[[en:Working with DBMS (FireDAC)]]
[[fr:Utilisation des SGBD (FireDAC)]]
[[ja:DBMS での作業（FireDAC）]]

Mobile-Tutorial: Herstellen einer Verbindung zu Unternehmensdatenbanken von mobilen Client-Anwendungen aus (iOS und Android)

2024-03-20T15:08:06Z

Nicolas.rios: RS-121926

{{Parent|Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)}}

Bevor Sie dieses Tutorial beginnen:

* Arbeiten Sie die folgenden Tutorials durch:
** '''[[Mobile-Tutorial: Verwenden von Listenfeld-Komponenten zur Anzeige von Tabellenansichten (iOS und Android)|Mobile-Tutorial: Verwenden von Listenfeld-Komponenten zur Anzeige von Tabellenansichten (iOS und Android)]]'''
** '''[[Mobile-Tutorial: Verwenden von InterBase ToGo mit dbExpress (iOS und Android)|Mobile-Tutorial: Verwenden von InterBase ToGo mit dbExpress (iOS und Android)]]'''
* Wählen Sie '''Start | Alle Programme | Embarcadero InterBase {{InterBaseVersion}} | <xx>-bit instance = gd_db | InterBase Server Manager''' und starten Sie den InterBase-Server. Der InterBase-Server muss ausgeführt werden, bevor Sie das Beispiel erstellen oder ausführen.

__TOC__

In diesem Tutorial wird beschrieben, wie Sie von einer mobilen Client-Anwendung aus eine Verbindung zu einer Unternehmensdatenbank herstellen.

Für die Verbindung zu einer Unternehmensdatenbank benötigen Sie eine '''Client-Bibliothek'''. Meistens wird die Client-Bibliothek vom Hersteller der Datenbank als DLL bereitgestellt. Für mobile Geräte ist dieses Vorgehen nicht angebracht, weil keine Client-Bibliothek verfügbar ist. Zur Lösung dieses Problems können Sie eine '''Mittelschicht''' für die Verbindung zu einer Unternehmensdatenbank entwickeln, und Ihre Anwendung kann mit der Mittelschicht interagieren.

{{Variables|Product}} stellt das '''DataSnap'''-Framework bereit, mit dem Sie die Mittelschicht, fast ohne zu programmieren, entwickeln (und darauf zugreifen) können. In diesem Tutorial werden die Schritte zum Entwickeln der Mittelschicht und des mobilen Clients beschrieben.

[[File:NTiersMobileAppDiagram.png]]

==Erstellen der Mittelschicht: Ein DataSnap-Server==

Erstellen Sie zunächst einen DataSnap-Server, der eine Tabelle von einem Datenbankserver bereitstellt. In diesem Tutorial wird als DataSnap-Server eine '''DataSnap-Server-VCL-Formularanwendung''' verwendet.

<blockquote>
'''Hinweis:''' In diesem Tutorial dient der DataSnap-Server (eine VCL-Anwendung) als Mittelschicht in einer mehrschichtigen Datenbankanwendung.
Sie können eine Instanz eines DataSnap-Servers einfach erstellen und später wieder löschen. Wenn Ihnen die grundlegenden Schritte klar sind, können Sie die Mittelschicht in eine Windows-Dienstanwendung umwandeln.
</blockquote>

===Erstellen einer DataSnap-Server-VCL-Anwendung===

# Um ein neues {{Delphi}}- oder C++-Projekt zu erstellen, wählen Sie '''Datei > Neu > Weitere''', und im Dialogfeld '''Objektgalerie''' wählen Sie dann:
#* '''Für Delphi:''' '''{{Delphi}}-Projekte > DataSnap-Server > DataSnap-Server'''
#* '''Für C++:''' '''{{CBuilder}}-Projekte > DataSnap-Server > DataSnap-Server'''
#: [[File:DSServer iOS1.png|400px]] 
# Der Experte [[DataSnap-Server-Experte|Neuer DataSnap-Server]] wird angezeigt:
#: [[File:DSServer iOS2.png|700px]] 
## Wählen Sie als ersten Schritt '''Formularanwendung''' als Projekttyp aus.
## Wählen Sie als zweiten Schritt '''VCL-Anwendung''' als Anwendungstyp aus.
## Wählen Sie als dritten Schritt das Protokoll '''TCP/IP''', die '''Servermethodenklasse''' und '''Beispielmethoden''' aus der Liste aus.
## Belassen Sie im vierten Schritt die Einstellung des Standard-TCP/IP Kommunikations-Ports auf '''211'''. Damit wird sichergestellt, dass die Kommunikation zwischen dem Client und dem Server über den Standard-DataSnap-Port ausgeführt wird.
## Wählen Sie als fünften und letzten Schritt '''TDSServerModule''' als Vorfahre für die Servermethoden aus.
# Speichern Sie die neue Formular-Unit unter '''DataSnapServerUnit'''.
# Wechseln Sie zu '''DataSnapServerUnit''', und ändern Sie die Eigenschaft '''Name''' des Formulars in '''DSServerForm'''.
# Speichern Sie die Servermethoden-Unit (vom Experten standardmäßig als '''ServerMethodsUnit1''' erstellt) unter dem Namen '''ServerModuleUnit'''.
# Speichern Sie die Servercontainer-Unit (vom Experten standardmäßig als '''ServerContainerUnit1''' erstellt) unter dem Namen '''ServerContainerUnit'''.
# Speichern Sie das neue Projekt unter '''DataSnapServerProject'''.
# Wählen Sie in der [[Projekte-Fenster|Projektverwaltung]] ProjectGroup1 aus, und speichern Sie das Projekt unter '''DataSnapTutorialProjectGroup.groupproj'''.
#: [[File:SaveAsDataSnapTutorialProjectGroup.png]]

===Definieren einer Datenmenge für den DataSnap-Server===

# Wechseln Sie zur Datei '''ServerContainerUnit.pas''', und ersetzen Sie für Delphi die uses-Klausel in der Implementierung durch <code>uses Winapi.Windows, ServerModuleUnit</code>, und ersetzen Sie für C++ in '''ServerContainerUnit.cpp''' '''#include "ServerMethodsUnit.h" ''' durch <code> #include "ServerModuleUnit.h"</code> .
# Wechseln Sie zur Datei '''ServerModuleUnit.pas'''.
# Ändern Sie im Formular-Designer die Eigenschaft '''Name''' des Servermoduls in '''DSServerModule_EMPLOYEE'''.
# Konfigurieren Sie die folgenden Komponenten für das Servermodul:
#* Ziehen Sie eine [[lib_de:Data.SqlExpr.TSQLConnection|TSQLConnection]]-Komponente in das Servermodul, und legen Sie die folgenden Eigenschaften fest:
#*: '''TSQLConnection''' kapselt die dbExpress-Verbindung zu einem Datenbankserver.
#** Setzen Sie die Eigenschaft [[lib_de:System.Classes.TComponent.Name|Name]] auf '''SQLConnection_EMPLOYEE'''.
#** Setzen Sie die Eigenschaft [[lib_de:Data.SqlExpr.TSQLConnection.LoginPrompt|LoginPrompt]] auf '''False'''.
#** Setzen Sie '''Driver''' auf '''InterBase Server'''.
#*:
#*:: '''Hinweis:''' Stellen Sie sicher, dass der '''InterBase-Server''' ausgeführt wird.
#** Erweitern Sie den Knoten '''Driver''', und setzen Sie die Eigenschaft '''DataBase''' auf {{Path|{{DataSamplesPath}}\EMPLOYEE.GDB}}.
#** Setzen Sie Eigenschaft [[lib_de:Data.SqlExpr.TSQLConnection.Connected|Connected]] auf '''True'''. Falls Sie eine Fehlermeldung erhalten, überprüfen Sie die '''Driver'''-Eigenschaften:
#**: [[File:DefineConnectionToInterBase.png|500px]] 
#* Ziehen Sie eine [[lib_de:Data.SqlExpr.TSQLDataSet|TSQLDataSet]]-Komponente in das Servermodul, und legen Sie die folgenden Eigenschaften fest:
#*: '''TSQLDataSet''' stellt die Daten dar, die mit dbExpress abgerufen wurden.
#** Setzen Sie die Eigenschaft '''[[lib_de:System.Classes.TComponent.Name|Name]]''' auf '''SQLDataSet_EMPLOYEE'''.
#** Setzen Sie die Eigenschaft '''[[lib_de:Data.SqlExpr.TSQLDataSet.SQLConnection|SQLConnection]]''' auf '''SQLConnection_EMPLOYEE'''.
#** Setzen Sie die Eigenschaft '''[[lib_de:Data.SqlExpr.TSQLDataSet.CommandType|CommandType]]''' auf '''ctTable'''.
#** Setzen Sie die Eigenschaft '''[[lib_de:Data.SqlExpr.TSQLDataSet.CommandText|CommandText]]''' auf '''EMPLOYEE'''.
#** Setzen Sie die Eigenschaft '''[[lib_de:Data.SqlExpr.TCustomSQLDataSet.Active|Active]]''' auf '''True'''. Falls Sie eine Fehlermeldung erhalten, überprüfen Sie die Eigenschaften, die Sie gerade konfiguriert haben.
#* Ziehen Sie eine [[lib_de:Datasnap.Provider.TDataSetProvider|TDataSetProvider]]-Komponente in das Servermodul, und legen Sie die folgenden Eigenschaften fest:
#*: Die Komponente '''TDataSetProvider''' packt Daten aus einer Datenmenge und übergibt ein oder mehrere übertragbare Datenpakete an den DataSnap-Client.
#** Setzen Sie die Eigenschaft '''[[lib_de:System.Classes.TComponent.Name|Name]]''' auf '''DataSetProvider_EMPLOYEE'''.
#** Setzen Sie die Eigenschaft '''[[lib_de:Datasnap.Provider.TDataSetProvider.DataSet|DataSet]]''' auf '''SQLDataSet_EMPLOYEE''':
#** [[File:ServerModuleUnit.png]]

<blockquote>
'''Hinweis:''' In diesem Tutorial wird InterBase verwendet. Sie können aber mit denselben Schritten eine Verbindung zu jedem beliebigen Datenbankserver herstellen. Wählen Sie für die Verbindung den entsprechenden Treiber und andere Eigenschaften für die jeweilige Datenbank aus.
</blockquote>

===Bereitstellen der Datenmenge vom DataSnap-Server===

Sie haben gerade ein neues Servermodul mit einer DataSet-Komponente und einer DataSetProvider-Komponente erstellt, die Daten in die nächste Schicht packt. Als Nächstes muss das Servermodul für den DataSnap-Client bereitgestellt werden.

# Öffnen Sie im Formular-Designer '''ServerContainerUnit'''.
# Wählen Sie '''DSServerClass1''', und aktualisieren Sie die vorhandene Ereignisbehandlungsroutine für das Ereignis '''OnGetClass'''. Fügen Sie der Ereignisbehandlungsroutine '''DSServerClass1''' den folgenden Quelltext hinzu:

'''Delphi:'''

<source lang="Delphi">
procedure TServerContainer1.DSServerClass1GetClass(DSServerClass: TDSServerClass;
var PersistentClass: TPersistentClass);
begin
PersistentClass := TDSServerModule_EMPLOYEE;
end;
</source>

'''C++ (nur für iOS):'''
<source lang="cpp">
void __fastcall TServerContainer1::DSServerClass1GetClass(TDSServerClass *DSServerClass,
TPersistentClass &PersistentClass)
{
PersistentClass = __classid(TDSServerModule_EMPLOYEE);
}
</source>
Mit dieser Ereignisbehandlungsroutine stellt der DataSnap-Server Provider und public-Methoden in dieser Klasse für einen DataSnap-Client bereit.
Ausgehend von den Schritten im vorherigen Abschnitt wird nun die Komponente '''DataSetProvider_EMPLOYEE DataSetProvider''' für den DataSnap-Client bereitgestellt.

===Ausführen des DataSnap-Servers===

Die Implementierung des DataSnap-Servers ist abgeschlossen. Klicken Sie mit der rechten Maustaste auf '''DataSnapServerProject.exe''', und wählen Sie '''Ohne Debugger ausführen'''.

[[File:RunDataSnapServerProjectWihoutDebugging.png]].

Der DataSnap-Server wird nun auf Ihrem Windows-Computer ausgeführt. Da dieser DataSnap-Server keine UI-Elemente hat, sieht er wie ein leeres Formular aus, und das ist hier genau das erwartete Verhalten.

[[File:RunDataSnapServerRunningOnWindows.png]]

==Erstellen einer mobilen Anwendung für die Verbindung zum DataSnap-Server==

Als Nächstes wird die mobile Client-Anwendung erstellt.

# Klicken Sie in der [[Projekte-Fenster|Projektverwaltung]] mit der rechten Maustaste auf '''DataSnapTutorialProjectGroup''', und wählen Sie '''Neues Projekt hinzufügen'''.
#: [[File:AddNewProjectToDataSnapTutorialProjectGroup.png]] 
# Wählen Sie auf der Seite '''{{Delphi}}-Projekte''' den Eintrag '''Geräteübergreifende Anwendung''' aus:
#: [[File:SelectFireMonkeyMobileApplication.png|400px]] 
# Speichern Sie die neue Unit unter '''DataSnapClientUnit'''.
# Speichern Sie das neue Projekt unter '''DataSnapClientProject'''.
# Öffnen Sie '''DataSnapClientUnit''', und ändern Sie die Eigenschaft '''Name''' des Formulars in '''DSClientForm'''.
# Ziehen Sie die folgenden Komponenten in den '''[[Formular-Designer|Formular-Designer]]''':
#*[[lib_de:Data.SqlExpr.TSQLConnection|TSQLConnection]] (SQLConnection1)
#*: '''TSQLConnection''' kapselt die dbExpress-Verbindung zu einem Datenbankserver. Außerdem unterstützt die Komponente den DataSnap-Server.
#** Setzen Sie die Eigenschaft '''Driver''' auf '''DataSnap'''.
#** Erweitern Sie die Eigenschaft '''Driver''', und setzen Sie die Eigenschaft '''HostName''' auf den Host-Namen oder die IP-Adresse des DataSnap-Servers.
#** Setzen Sie die Eigenschaft [[lib_de:Data.SqlExpr.TSQLConnection.LoginPrompt|LoginPrompt]] auf '''False'''.
#** Setzen Sie Eigenschaft [[lib_de:Data.SqlExpr.TSQLConnection.Connected|Connected]] auf '''True'''.
#**: Wenn Sie eine Fehlermeldung erhalten, überprüfen Sie die gerade festgelegten Eigenschaften nochmals.
#*[[lib_de:Datasnap.DSConnect.TDSProviderConnection|TDSProviderConnection]] (DSProviderConnection1)
#*: Die Komponente [[lib_de:Datasnap.DSConnect.TDSProviderConnection|TDSProviderConnection]] stellt die Konnektivität zu DataSnap-Servern mithilfe von dbExpress her.
#** Setzen Sie die Eigenschaft [[lib_de:Datasnap.DSConnect.TDSProviderConnection.SQLConnection|SQLConnection]] auf '''SQLConnection1'''.
#** Setzen Sie '''ServerClassName''' auf '''TDSServerModule_EMPLOYEE'''. Dieser Name muss mit dem Namen der Klasse des Servermoduls des DataSnap-Servers übereinstimmen.
#** Setzen Sie Eigenschaft [[lib_de:Datasnap.DSConnect.TDSProviderConnection.Connected|Connected]] auf '''True'''.
#*[[lib_de:Datasnap.DBClient.TClientDataSet|TClientDataSet]] (ClientDataSet1)
#*: TClientDataSet implementiert eine datenbankunabhängige Datenmenge, die als lokaler Speicherpuffer der Datensätze aus einer anderen Datenmenge verwendet werden kann.
#** Setzen Sie die Eigenschaft [[lib_de:Datasnap.DBClient.TClientDataSet.RemoteServer|RemoteServer]] auf '''DSProviderConnection1'''.
#** Setzen Sie die Eigenschaft [[lib_de:Datasnap.DBClient.TClientDataSet.ProviderName|ProviderName]] auf '''DataSetProvider_EMPLOYEE'''. Dieser Name muss mit dem Namen des Providers für den DataSnap-Server übereinstimmen.
#** Setzen Sie die Eigenschaft [[lib_de:Datasnap.DBClient.TClientDataSet.Active|Active]] auf '''True'''.
#*[[lib_de:FMX.ListBox.TListBox|TListBox]]
#** Setzen Sie die Eigenschaft [[lib_de:FMX.ListBox.TListBox.Align|Align]] auf '''Client''':
#: [[File:Configure iOSDataSnapClient.png]] 
# Öffnen Sie den [[LiveBindings-Designer|LiveBindings-Designer]], und verbinden Sie die Daten und die Benutzeroberfläche folgendermaßen:
## Klicken Sie in BindSourceDB1 auf '''FULL_NAME''', und ziehen Sie den Mauszeiger auf '''Item.Text''' in ListBox1:
##: [[File:ConnectFullNameToItemText.png]] 
## Nun haben Sie den DataSnap-Client auf der mobilen Plattform erstellt und konfiguriert. Die Daten vom DataSnap-Server sollten nun in der IDE angezeigt werden:
##:

{|
|-
!
''' iOS'''
!
''' Android'''
|-
|[[File:DSClientCompleted.png|250px]]   
|[[File:DSClientCompletedAndroid.png|250px]]  
|}

==Bereitstellen der MIDAS-Bibliothek auf dem iOS-Simulator==

Damit Ihre Anwendung auf dem iOS-Simulator ausgeführt werden kann, müssen Sie die folgenden Dateien bereitstellen:

* MIDAS-Bibliothek

# Öffnen Sie den [[Bereitstellungs-Manager|Bereitstellungs-Manager]] durch Auswahl von '''Projekt > Bereitstellung'''.
# Wählen Sie [[Bereitstellungs-Manager - Weitere Dateien hinzufügen|Weitere Dateien hinzufügen]] ([[Image:DMgrAddFeatFiles.png]]):
#: [[File:AddingFeaturedFiles.png]] 
# Wählen Sie das folgende Modul aus, und klicken Sie dann auf '''OK''', um den Bereitstellungs-Manager zu schließen:
#* MIDAS-Bibliothek
#*: [[File:SelectingMIDASFeaturedFiles.png]] 

==Ausführen der Anwendung auf der mobilen Plattform==

Ihre Anwendung kann nun ausgeführt werden.

Wählen Sie in der [[Projekte-Fenster|Projektverwaltung]] die mobile Zielplattform, und führen Sie Ihre Anwendung aus. Sie sollten genau wie in der IDE durch die Daten blättern können.

==Siehe auch==

* [[Mobile-Tutorial: Verwenden von InterBase ToGo mit dbExpress (iOS und Android)|Mobile-Tutorial: Verwenden von InterBase ToGo mit dbExpress (iOS und Android)]]
* [[Mobile-Tutorial: Verwenden von dbExpress und SQLite (iOS und Android)|Mobile-Tutorial: Verwenden von dbExpress und SQLite (iOS und Android)]]
* [[Mobile-Tutorial: Verwenden von FireDAC in mobilen Anwendungen (iOS und Android)|Mobile-Tutorial: Verwenden von FireDAC in mobilen Anwendungen (iOS und Android)]]
* [[DataSnap-Anwendungen entwickeln|DataSnap-Anwendungen entwickeln]]
* [[Grundlagen der mehrschichtigen Datenbank-Anwendungen|Grundlagen der mehrschichtigen Datenbank-Anwendungen]]
* [[lib_de:Datasnap.DSServer.TDSServer|Datasnap.DSServer.TDSServer]]
* [http://docwiki.embarcadero.com/InterBase/2020/en/Start_the_InterBase_Server Start the InterBase Server]

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

[[en:Mobile Tutorial: Connecting to an Enterprise Database from a Mobile Client (iOS and Android)]]
[[fr:Tutoriel mobile : Connexion à une base de données d'entreprise depuis un client mobile (iOS et Android)]]
[[ja:モバイルチュートリアル：モバイルクライアントからエンタープライズデータベースに接続する（iOS および Android）]]

InterBase ToGo mit dbExpress

2024-03-20T15:04:23Z

Nicolas.rios: RS-121926

{{Parent|Datenbankanwendungen entwickeln}}
Ab XE3 unterstützt {{Product}} InterBase ToGo-Datenbanken.

==Änderungen==
Ab XE3 wurde in {{Product}} das [[DbExpress-Framework|dbExpress-Framework]] durch Hinzufügen eines InterBase ToGo-spezifischen Treibers erweitert. Durch diese Änderung können Benutzer Verbindungen mit InterBase ToGo-Datenbanken in {{Delphi}}- und C++-Anwendungen über dbExpress einfacher einrichten.

==Verwenden des InterBase ToGo-Treibers==

Der InterBase ToGo-Treiber kann nur zur Laufzeit verwendet werden.

Wenn Sie beim Entwurf eine Verbindung mit InterBase ToGo aktivieren oder im [[Daten-Explorer]] eine geöffnete InterBase ToGo-Verbindung vorhanden ist und Sie versuchen, die Anwendung auszuführen, erhalten Sie einen Laufzeitfehler. Und zwar, weil für die InterBase ToGo-Serverlizenz der exklusive Zugriff auf die Datenbank erforderlich ist. Da beim Entwurf bereits eine Verbindung geöffnet ist, können Sie in der Anwendung, die Sie erzeugen/ausführen, keine lokale Verbindung zu derselben Datenbank öffnen. InterBase ToGo ist nur als Bereitstellungsoption gedacht und sollte nicht in der IDE oder im [[Daten-Explorer]] verwendet werden.

Verwenden Sie deshalb beim Entwurf und im [[Daten-Explorer]] die Vollversion des [[InterBase|InterBase]]-Clients.

==Beispiel==
Das folgende Beispiel ist ein Tutorial zum Einrichten einer Verbindung mit einer InterBase ToGo-Datenbank in einer {{Delphi}}-VCL-Formularanwendung:

===Schritte===
# Wählen Sie '''Datei > Neu > VCL-Formularanwendung - {{Delphi}}'''.
# Fügen Sie dem Formular die folgenden Komponenten hinzu:
#* Ein [[lib_de:Vcl.StdCtrls.TButton|TButton]]-Steuerelement; setzen Sie im [[Objektinspektor|Objektinspektor]] die Eigenschaft [[lib_de:System.Classes.TComponent.Name|Name]] der Schaltfläche auf <code>connectButton</code> und die Eigenschaft [[lib_de:Vcl.StdCtrls.TButton.Caption|Caption]] auf <code>Connect</code>.
#* Ein [[lib_de:Data.SqlExpr.TSQLConnection|TSQLConnection]]-Steuerelement.
#* Ein [[lib_de:Vcl.StdCtrls.TMemo|TMemo]]-Steuerelement; setzen Sie im [[Objektinspektor|Objektinspektor]] die Eigenschaft [[lib_de:System.Classes.TComponent.Name|Name]] auf <code>outputMemo</code>.
# Fügen Sie der [[lib_de:Vcl.Controls.TControl.OnClick|OnClick]]-Ereignisbehandlungsroutine für <code>connectButton</code> den folgenden Code hinzu.
<source lang=Delphi>
procedure TForm1.connectButtonClick(Sender: TObject);
begin
// create a new TSQLConnection object
SQLConnection1 := TSQLConnection.Create(nil);
// set the driver of the TSQLConnection control
SQLConnection1.DriverName := 'IBToGo';
// add the Database parameter to Params
SQLConnection1.Params.Add('Database=full_path_to_your_database_file');
// set the Username and Password parameters
SQLConnection1.Params.Add('User_Name=SYSDBA');
SQLConnection1.Params.Add('Password=masterkey');
try
// open the connection
SQLConnection1.Open;
Memo1.Text := 'Connection established';
except
on E: Exception do
Memo1.Text := 'Exception raised with message : ' + #13#10 + E.Message;
end;
end;
</source>

==Siehe auch==
* [[InterBase ToGo]]
* [[Mobile-Tutorial: Verwenden von InterBase ToGo mit dbExpress (iOS und Android)]]
* [http://docwiki.embarcadero.com/InterBase/2020/en/ToGo_Quick_Start InterBase 2020 ToGo Quick Start Guide]
* [[lib_de:Data.SqlExpr.TSQLConnection|Data.SqlExpr.TSQLConnection]]
* [[lib_de:Vcl.StdCtrls.TButton|Vcl.StdCtrls.TButton]]
* [[lib_de:Vcl.StdCtrls.TMemo|Vcl.StdCtrls.TMemo]]
* [[lib_de:Vcl.Controls.TControl.OnClick|Vcl.Controls.TControl.OnClick]]
* [[Objektinspektor|Objektinspektor]]
* [[lib_de:System.Classes.TComponent.Name|System.Classes.TComponent.Name]]
* [[lib_de:Vcl.StdCtrls.TButton.Caption|Vcl.StdCtrls.TButton.Caption]]
* [[Daten-Explorer]]
* [[InterBase]]
[[Category:XE3]]

[[en:InterBase ToGo with dbExpress]]
[[fr:InterBase ToGo avec dbExpress]]
[[ja:DbExpress での InterBase ToGo の使用]]

Benachrichtigungen über Datenänderungen (FireDAC)

2024-03-20T14:31:10Z

Nicolas.rios: RS-121926

__TOC__
{{Parent|Arbeiten mit Anweisungen (FireDAC)}}

Mit der Funktion "Benachrichtigungen über Datenänderungen" können Sie Datenbank-Clients über Datenänderungen für einige Datenbanken benachrichtigen. Diese Funktion findet Änderungen in Daten in einer Datenbank (wie {{code|INSERT}}-, {{code|UPDATE}}- oder {{code|DELETE}}-Operationen) und benachrichtigt den Datenbank-Client über diese Änderungen.

FireDAC unterstützt die Funktion "Benachrichtigungen über Änderungen" für verschiedene Datenbanken (siehe [[#Unterstützung für Änderungsbenachrichtigungen|Unterstützung für Änderungsbenachrichtigungen]]). FireDAC verwendet verschiedene Methoden, um diese Funktion, abhängig von der Art der Datenbank, zu implementieren. Dieses Thema beschreibt die allgemeinen Informationen der Funktion "Benachrichtigungen über FireDAC-Datenänderungen" und gibt dann einige [[#Benachrichtigungen über Datenänderungen für Spezifisches DBMS|Gesichtspunkte für spezifische DBMS-Implementierungen]].

Weitere Informationen über Mechanismen für Datenbankwarnungen finden Sie unter [[Datenbankwarnungen (FireDAC)|Datenbankwarnungen]].

==Einrichten der Funktion "Benachrichtigung über FireDAC-Datenänderungen"==

Um die Funktion "Benachrichtigung über FireDAC-Datenänderungen" auf einer FireDAC-Anwendung einzurichten, sollten Sie die folgenden Hauptkomponenten hinzufügen und konfigurieren:

* Ein [[lib_de:FireDAC.Comp.Client.TFDConnection|TFDConnection]]-Objekt - Dies ist das FireDAC-Verbindungsobjekt, mit dem eine Verbindung zu einem DBMS hergestellt wird.
{{Note| In diesem Abschnitt wird davon ausgegangen, dass Sie das Tutorial [[Erste Schritte bei der Verwendung von FireDAC|Erste Schritte bei der Verwendung von FireDAC]], das Anleitungen zum Entwickeln einer einfachen VCL-Anwendung zur Verbindung mit Demo-Datenbanken bereitstellt, gelesen und verstanden haben.}}

* Ein [[lib_de:FireDAC.Comp.Client.TFDQuery|TFDQuery]]-Objekt - Dies ist das FireDAC-Objekt, mit dem Datenmengen, die SQL-Abfragen ausführen können, implementiert werden. Sie sollten die folgenden Grundeigenschaften der SQL-Abfrage, die festgestellt wird, implementieren:
** Die [[lib_de:FireDAC.Comp.Client.TFDRdbmsDataSet.Connection|Connection]]-Eigenschaft muss gesetzt werden, damit das FireDAC-Verbindungsobjekt angegeben wird.
** Die [[lib_de:FireDAC.Comp.Client.TFDQuery.SQL|SQL]]-Eigenschaft muss mit der gewünschten SQL-Anweisung gesetzt werden.
** Die [[lib_de:FireDAC.Comp.Client.TFDQuery.ChangeAlerter|ChangeAlerter]]-Eigenschaft muss gesetzt werden, damit das FireDAC-Warnobjekt, das mit Ihrer Datenmenge assoziiert ist, angegeben wird.
** Die [[lib_de:FireDAC.Comp.Client.TFDQuery.ChangeAlertName|ChangeAlertName]]-Eigenschaft kann gesetzt werden, damit der Name der Basistabelle, deren Änderungen festgestellt wurden, angegeben wird.

* Ein [[lib_de:FireDAC.Comp.Client.TFDEventAlerter|TFDEventAlerter]]-Objekt - Dies ist das Objekt, mit dem die Benachrichtigungen über Datenbankänderungen behandelt werden. Sie sollten die folgenden Grundeigenschaften der Ereigniswarnung konfigurieren:
** Mit der [[lib_de:FireDAC.Comp.Client.TFDEventAlerter.Options|Options]]-Eigenschaft kann eine [[lib_de:FireDAC.Stan.Option.TFDEventAlerterOptions|Menge von Eigenschaften]] festgelegt werden, um das Verhalten der Ereigniswarnung zu kontrollieren.
** Die [[lib_de:FireDAC.Comp.Client.TFDEventAlerter.SubscriptionName|SubscriptionName]]-Eigenschaft muss gesetzt werden, damit der Substriptionsname der Änderungsbenachrichtigung angegeben wird. Es hängt vom Typ der Datenbank, die Sie verwenden, ab.
{{Note| Aktivieren Sie [[lib_de:FireDAC.Comp.Client.TFDEventAlerter|TFDEventAlerter]] vor der Ausführung der gefundenen [[lib_de:FireDAC.Comp.Client.TFDQuery|TFDQuery]]. Dies ist nötig, da die Anweisung mit der Abfragebenachrichtigungs-API vor der Ausführung registriert werden muss. Dies ist eine Anforderung vom SQL-Server und Oracle.}}

==Antworten auf Änderungsbenachrichtigungen==

Beim Empfang einer Benachrichtigung über Datenänderungen ruft FireDAC die Änderungen automatisch ab und aktualisiert die Datenmenge. Dieser Prozess wird von den folgenden Eigenschaften der Komponente [[lib_de:FireDAC.Comp.Client.TFDEventAlerter|TFDEventAlerter]] gesteuert:

* [[lib_de:FireDAC.Comp.Client.TFDCustomEventAlerter.Options|FireDAC.Comp.Client.TFDCustomEventAlerter.Options]].[[lib_de:FireDAC.Stan.Option.TFDEventAlerterOptions.AutoRefresh|AutoRefresh]]
* [[lib_de:FireDAC.Comp.Client.TFDCustomEventAlerter.Options|FireDAC.Comp.Client.TFDCustomEventAlerter.Options]].[[lib_de:FireDAC.Stan.Option.TFDEventAlerterOptions.Timeout|Timeout]]
* [[lib_de:FireDAC.Comp.Client.TFDCustomEventAlerter.Options|FireDAC.Comp.Client.TFDCustomEventAlerter.Options]].[[lib_de:FireDAC.Stan.Option.TFDEventAlerterOptions.MergeData|MergeData]]

Jedes der Demo-Projekte, die in [[#Benachrichtigungen über Datenänderungen für Spezifisches DBMS|Benachrichtigungen über Datenänderungen für Spezifisches DBMS]] aufgelistet sind, zeigt, wie das oben genannte Szenario verwendet wird.

Außerdem können Sie die [[lib_de:FireDAC.Comp.Client.TFDCustomEventAlerter.OnAlert|TFDCustomEventAlerter.OnAlert]]-Ereignisbehandlungsroutine verwenden, die nach dem Ermitteln jeder Änderung der gefundenen Datenmenge ausgelöst wird. Mit dieser Ereignisbehandlungsroutine können Sie Ihr benutzerdefiniertes Szenario implementieren, um auf Benachrichtigungen über Datenänderungen zu antworten. Der folgende Code implementiert eine [[lib_de:FireDAC.Comp.Client.TFDCustomEventAlerter.OnAlert|OnAlert]]-Ereignisbehandlungsroutine, die eine Benachrichtigung anzeigt, wenn jede Daten in einer Datenbank geändert werden.

<l s="delphi" />'''{{Delphi}}''': 
<source lang="Delphi">
procedure TForm1.FDEventAlerter1Alert(ASender: TFDCustomEventAlerter;
const AEventName: string; const AArgument: Variant);
begin
ShowMessage('Detected changes to the demo dataset.');
end;</source><l e="delphi" /><l s="cpp" />'''{{CBuilder}}:''' 
<source lang="cpp">
void __fastcall TForm1::FDEventAlerter1Alert(TFDCustomEventAlerter *ASender, const UnicodeString AEventName,
const Variant &AArgument)
{
ShowMessage("Detected changes to the demo dataset. ");
}</source><l e="cpp" />

==Unterstützung für Änderungsbenachrichtigungen==

Die folgende Tabelle enthält eine Zusammenfassung der für das jeweilige DBMS verwendeten Änderungsbenachrichtigung.

{| border="1" frame="hsides" rules="rows"
|-
! '''DBMS'''
! '''Typ der Änderungsbenachrichtigung'''
! '''Delta-Typ'''
! '''TFDEventAlerter.SubscriptionName'''
|-
| style="text-align: left; vertical-align: top;" |InterBase
| style="text-align: left; vertical-align: top;" |Event Alerter (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Change Views (automatisches Delta)
| style="text-align: left; vertical-align: top;" |Abonnementname von InterBase Change View
|-
| style="text-align: left; vertical-align: top;" |MS SQL Server
| style="text-align: left; vertical-align: top;" |Query Update Notification (automatische Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| rowspan="2" style="text-align: left; vertical-align: middle;" | Oracle
| style="text-align: left; vertical-align: top;" |DBMS_ALERT / DBMS_PIPE (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |Continuous Query Notification (CQN)
| style="text-align: left; vertical-align: top;" |Automatisches Delta
| style="text-align: left; vertical-align: top;" |Jeder Wert
|-
| style="text-align: left; vertical-align: top;" |Advantage Database
| style="text-align: left; vertical-align: top;" |Event Alerter (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |Sybase SQL Anywhere
| style="text-align: left; vertical-align: top;" |Meldungen (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |DataSnap-Server
| style="text-align: left; vertical-align: top;" |Callbacks (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |DB2
| style="text-align: left; vertical-align: top;" |DBMS_ALERT / DBMS_PIPE (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |Firebird
| style="text-align: left; vertical-align: top;" |Event Alerter (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |Informix
| style="text-align: left; vertical-align: top;" |DBMS_ALERT (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |PostgreSQL
| style="text-align: left; vertical-align: top;" |Ereignisbenachrichtigung (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|-
| style="text-align: left; vertical-align: top;" |SQLite
| style="text-align: left; vertical-align: top;" |Event Alerter (manuelle Benachrichtigung)
| style="text-align: left; vertical-align: top;" |Keiner (vollständige Datenmengenaktualisierung)
| style="text-align: left; vertical-align: top;" |Benachrichtigungsmeldungstext
|}

==Benachrichtigungen über Datenänderungen für Spezifisches DBMS==

Dieser Abschnitt gibt einige Gesichtpunkte zur Implementierung der Funktion "Benachrichtigung über Datenänderungen" für verschiedene Datenbanken.

===InterBase Change Views===

Die Funktion Change Views ist die Interbase-Methode zur Implementierung von Benachrichtigungen über Datenbankänderungen. Weitere Informationen finden Sie unter [http://docwiki.embarcadero.com/InterBase/2020/en/Change_Views Change Views (EN)].

Vor der Entwicklung einer InterBase-Anwendung, die die Funktion Change Views verwendet, sollten Sie eine Subskription von Change Views erstellen. Der folgende Quelltextabschnitt ist ein Beispiel für die Erstellung der Subskription:

<source lang="sql">
/* Create the xxx subscription to track changes to the 'yyy' table */
CREATE SUBSCRIPTION xxx ON yyy FOR ROW (INSERT, UPDATE, DELETE);
</source>

Weitere Informationen zur Konfigurierung der Funktion Change Views finden Sie in dem Demo-Projekt unter:

* {{SamplesMenu}} und zu '''Object Pascal\Database\FireDAC\Samples\DBMS Specific\InterBase\ChangeView\Generic''' navigieren.

===Oracle CQN===

De Funktion Continuous Query Notification (CQN) ist die Oracle-Implementierung der Funktion "Benachrichtigung über Datenänderungen". Weitere Informationen finden Sie unter [http://docs.oracle.com/cd/B28359_01/appdev.111/b28395/oci10new.htm#CJGHFEDD Continuous Query Notification (EN)].

Um die Oracle-CQN-Funktion zu konfigurieren, sollten Sie die folgenden Gesichtspunkte in Betracht ziehen:

* Der Oracle-Client muss die '''Änderungsbenachrichtigung'''-Rechte besitzen. Der folgende Quelltextabschnitt ist ein Beispiel dafür, wie der Benutzer dieses Recht verwendet:

<blockquote><source lang="sql">
/* Give change notification privilege to the xxx Oracle user */
GRANT DBMS_CHANGE_NOTIFICATION TO xxx;
</source></blockquote>

* Die [[lib_de:FireDAC.Comp.Client.TFDQuery.SQL|SQL]]-Eigenschaft sollte die [[Verwenden von Oracle mit FireDAC#Implicit ROWIDs|{{code|ROWID}}-Spalten]] der {{code|SELECT}} Liste für die Basistabelle hinzufügen. Zum Beispiel: {{code|SELECT t.ROWID, t.* FROM table t}}.
{{Note| Der {{code|ROWID}}-Bezeichner ist ein [[Eindeutige Kennzeichnungsfelder (FireDAC)|Eindeutige Kennzeichnungsfeld (FireDAC) (FireDAC)]] für einer Zeile in einer Datenbank. Es wird in der Zeit erstellt, in der die Zeile in die Tabelle eingefügt wird, und freigegeben wird, wenn sie entfernt wird. ROWID-Werte haben verschiedenen wichtige Verwendungen; sie sind z. B. der schnellste Weg, um auf eine Reihe zuzugreifen.}}

* Die folgenden Eigenschaften des [[lib_de:FireDAC.Comp.Client.TFDEventAlerter|TFDEventAlerter]]-Objekts sollten wie folgt konfiguriert werden:
** Setzen Sie die [[lib_de:FireDAC.Comp.Client.TFDEventAlerter.Options|Options]].[[lib_de:FireDAC.Stan.Option.TFDEventAlerterOptions.Kind|Kind]]-Eigenschaft auf {{code|QueryNotifies}}.
** Setzen Sie die [[lib_de:FireDAC.Comp.Client.TFDEventAlerter.SubscriptionName|SubscriptionName]]-Eigenschaft auf jeden Wert. Diese Eigenschaft kann nicht leer sein. Andernfalls ist die Abfrage völlig, statt inkrementell, aktualisiert.

Weitere Informationen zur Konfiguration der Oracle-CQN-Funktion finden Sie unter dem Beispiel [[samp_en:FireDAC.Oracle CQN Sample|FireDAC Oracle CQN]].

====Bekannte Oracle-Probleme====

Im Gegensatz zu Versionen der 11.2-Datenbank, können einige Versionen von 11.2-Client-Software keine Änderungsbenachrichtigungen, OCI-Callbacks oder Advanced Queuing (AQ)-Benachrichtigungen empfangen. Dies ist ein bekanntes Oracle-Problem. Weitere Informationen finden Sie auf der folgenden Oracle-[https://support.oracle.com/epmos/faces/DocumentDisplay?id=1310859.1 Seite (EN)].

===Microsoft-SQL===

Weitere Informationen zur Konfigurierung der Funktion "Benachrichtigungen über Datenänderungen" für eine MSSQL-Datenbank finden Sie in dem Demo-Projekt unter:

* {{SamplesMenu}} und navigieren Sie zu '''Object Pascal\Database\FireDAC\Samples\DBMS Specific\MSSQL\QueryNotify'''

==Siehe auch==

* [[Datenbankwarnungen (FireDAC)|Datenbankwarnungen (FireDAC)]]
* [[lib_de:FireDAC.Comp.Client.TFDEventAlerter|FireDAC.Comp.Client.TFDEventAlerter]]
* [[lib_de:FireDAC.Comp.Client.TFDQuery|FireDAC.Comp.Client.TFDQuery]]

{{DEFAULTSORT:Benachrichtigungen uber Datenanderungen (FireDAC)}}
[[Category:FireDAC]]
[[Category:AMMigrate]]

[[en:Data Change Notifications (FireDAC)]]
[[fr:Notifications de changements de données (FireDAC)]]
[[ja:データ変更通知（FireDAC）]]

MediaWiki:Sidebar

2024-01-30T20:00:02Z

Nicolas.rios: {{Note|

* SEARCH

* RAD Studio 11 Alexandria
** Hauptseite | Themen
** lib_de:Hauptseite | Bibliothek-Referenz
** samp_en:Main_Page | Codebeispiele

* RAD Studio 11 Themen
** Neuerungen | Neuerungen
** Tutorials | Tutorials
** {{FM}}-Anwendungsplattform | {{FM}}-Anwendungsplattform
** Geräteübergreifende Anwendungen - Index | Geräteübergreifende Anwendungen
** Einführung in {{Product}} | Einführung
** Arbeitsschritte bei der Projektentwicklung | Arbeitsschritte bei der Projektentwicklung
** Hauptanwendungstypen | Hauptanwendungstypen
** FireDAC | FireDAC
** Windows-Entwicklerhandbuch - Index | Windows-Entwicklerhandbuch
** Mit den Modellierungstools arbeiten | Modellierungstools
** IDE-Referenz und Befehlszeilenhilfsprogramme | IDE-Referenz und Befehlszeilenhilfsprogramme
** {{Delphi}}-Referenz | {{Delphi}}-Referenz
** C++-Referenz | C++-Referenz
** Index | Subjekt-Index

* LANGUAGES

* Frühere Versionen
** https://docwiki.embarcadero.com/RADStudio/Sydney/de/Hauptseite | Sydney-Themen
** https://docwiki.embarcadero.com/RADStudio/Rio/de/Hauptseite | Rio-Themen
** Hilfe von früheren Versionen | Ältere Versionen

* Assistenz
** recentchanges-url | Letzte Änderungen

* TOOLBOX

Deklarationen und Anweisungen (Delphi)

2023-12-11T21:21:50Z

Nicolas.rios: RS-85687

{{Parent|Grundlegende syntaktische Elemente - Index}}
Dieses Thema enthält eine Beschreibung der Deklarations- und Anweisungssyntax in {{Delphi}}.

Neben der '''uses'''-Klausel (und reservierten Wörtern zur Abgrenzung von Abschnitten in Units, wie '''implementation''') besteht ein Programm ausschließlich aus ''Deklarationen'' und ''Anweisungen'', die in so genannten ''Blöcken'' organisiert sind.

Dieses Thema enthält Informationen zu folgenden Bereichen:

* Deklarationen
* Einfache Anweisungen, wie z. B. Zuweisungen
* Strukturierte Anweisungen, wie bedingte Tests (z. B. if-then und '''case'''), Iterationen (z. B. for und while).

==Deklarationen==

Die Namen von Variablen, Konstanten, Typen, Feldern, Eigenschaften, Prozeduren, Funktionen, Programmen, Units, Bibliotheken und Packages werden ''Bezeichner'' genannt. (Numerische Konstanten wie 26057 sind keine Bezeichner.) Damit ein Bezeichner verwendet werden kann, muss er zuerst deklariert werden. Ausnahmen bilden einige vordefinierte Typen, Routinen und Konstanten, die vom Compiler auch ohne Deklaration interpretiert werden können, die Variable Result innerhalb eines Funktionsblocks und die Variable Self in einer Methodenimplementierung.

Eine Deklaration definiert den Bezeichner und sorgt dafür, dass bei Bedarf Speicher für ihn reserviert wird. Zum Beispiel:

var Size: Extended;

Diese Anweisung deklariert eine Variable namens Size, die einen '''Extended'''-Wert (Typ Real) enthält:

function DoThis(X, Y: string): Integer;

Diese Anweisung deklariert eine Funktion mit dem Namen DoThis, die zwei Strings als Argumente übernimmt und einen Integerwert zurückgibt. Jede Deklaration wird durch einen Strichpunkt abgeschlossen. Werden mehrere Variablen, Konstanten, Typen oder Labels gleichzeitig deklariert, genügt es, das entsprechende reservierte Wort nur einmal anzugeben:
<source lang="delphi">
var
Size: Extended;
Quantity: Integer;
Description: string;
</source>
Die Syntax und der Ort einer Deklaration sind vom Typ des Bezeichners abhängig, der definiert werden soll. In der Regel erfolgen Deklarationen nur am Anfang eines Blocks bzw. am Anfang des interface- oder '''implementation'''-Abschnitts einer Unit (nach der '''uses'''-Klausel). Die Konventionen für die Deklaration von Variablen, Konstanten, Typen, Funktionen usw. werden in den betreffenden Themen erläutert.

===Hinweis-Direktiven===

Die Hinweis-Direktiven '''platform''', '''deprecated''' und '''library''' können an jede Deklaration angehängt werden. Diese Direktiven erzeugen beim Compilieren Warnungen. Hinweis-Direktiven können für Typdeklarationen, Variablendeklarationen, Klassen-, Interface- und Strukturdeklarationen, Felddeklarationen innerhalb von Klassen oder Records, Prozedur-, Funktions- und Methodendeklarationen sowie Unit-Deklarationen angewendet werden.

Tritt eine Hinweis-Direktive in einer Unit-Deklaration auf, bedeutet dies, dass der Hinweis für alle Elemente in der Unit gilt. Die Unit OleAuto.pas im Windows 3.1-Stil ist beispielsweise unter Windows völlig veraltet. Jeder Verweis auf diese Unit oder auf ein Symbol in dieser Unit erzeugt die Meldung, dass diese veraltet ist.

Die Hinweis-Direktive '''platform''' bei einem Symbol oder einer Unit gibt an, dass diese eventuell nicht existiert oder die Implementierungen auf unterschiedlichen Plattformen wesentlich voneinander abweichen. Die Hinweis-Direktive '''library''' bei einem Symbol oder einer Unit gibt an, dass der Quelltext eventuell nicht existiert oder die Implementierungen in unterschiedlichen Bibliotheksarchitekturen wesentlich voneinander abweichen.

Die Direktiven '''platform''' und '''library''' enthalten keine Angaben über die Plattform oder Bibliothek. Wenn Sie beabsichtigen, plattformunabhängigen Code zu erstellen, müssen Sie nicht wissen, für welche Plattform ein Symbol spezifisch ist. Es reicht aus, das Symbol für ''irgendeine'' Plattform als spezifisch zu kennzeichnen, damit Sie wissen, dass es eventuell bei der Portabilität Probleme bereiten könnte.

In einer Prozedur- oder Funktionsdeklaration sollte die Hinweis-Direktive durch einen Strichpunkt vom Rest der Deklaration getrennt werden. Beispiele:
<source lang="delphi">
procedure SomeOldRoutine; stdcall; deprecated;

var
VersionNumber: Real library;

type
AppError = class(Exception)
...
end platform;
</source>
Wenn der Quelltext im Status {$HINTS ON} {$WARNINGS ON} compiliert wird, erzeugt jede Referenz auf einen Bezeichner, der mit einer dieser Direktiven deklariert wurde, einen entsprechenden Hinweis oder eine entsprechende Warnung. Mit der Direktive '''platform''' werden Elemente gekennzeichnet, die für ein bestimmtes Betriebssystem (z. B. Windows) spezifisch sind. Mit '''deprecated''' wird angegeben, dass ein Element veraltet ist oder nur aus Gründen der Abwärtskompatibilität unterstützt wird. Die Direktive '''library''' wird verwendet, um auf die Abhängigkeit von einem bestimmten Bibliotheks- oder Komponenten-Framework hinzuweisen.

Der {{Delphi}}-Compiler erkennt auch die Hinweis-Direktive '''experimental'''. Mit dieser Direktive werden Units gekennzeichnet, die sich in einem instabilen Entwicklungszustand befinden. Beim Compilieren einer Anwendung, die diese Unit verwendet, wird eine Warnung ausgegeben.

Weitere Informationen zu den {{Delphi}}-Hinweis-Direktiven finden Sie unter '''[[Methoden (Delphi)#Allgemeines zu Methoden|Warnungs-Direktiven in Methodendeklarationen]]'''. Alle {{Delphi}}-Direktiven sind unter [[Grundlegende syntaktische Elemente (Delphi)#Direktiven|Direktiven]] aufgelistet.

==Anweisungen==

Anweisungen definieren algorithmische Aktionen in einem Programm. Einfache Anweisungen (z. B. Zuweisungen und Prozeduraufrufe) können kombiniert werden. Auf diese Weise lassen sich Schleifen, bedingte Anweisungen und andere strukturierte Anweisungen erstellen.

Mehrere Anweisungen in einem Block sowie im initialization- und finalization-Abschnitt einer Unit werden durch Strichpunkte voneinander getrennt.

==Einfache Anweisungen==

Einfache Anweisungen enthalten keine anderen Anweisungen. Zu ihnen gehören Zuweisungen, Aufrufe von Prozeduren und Funktionen sowie goto-Sprünge.

===Zuweisungen===

Eine Zuweisung hat folgendes Format:

''variable'' := ''expression''

''variable'' ist eine beliebige Variablenreferenz, d. h. eine Variable, eine Variablenumwandlung, ein dereferenzierter Zeiger oder eine Komponente einer strukturierten Variable. ''expression'' kann jeder zuweisungskompatible Ausdruck sein (in einem Funktionsblock kann die Variable durch den Namen der definierten Funktion ersetzt werden; siehe [[Prozeduren und Funktionen (Delphi)|Prozeduren und Funktionen (Delphi)]].) Das Symbol ''':=''' wird auch als '''Zuweisungsoperator''' bezeichnet.

Eine Zuweisung ersetzt den aktuellen Wert der Variable durch den Wert des Ausdrucks. Zum Beispiel:

I := 3;

Mit dieser Anweisung wird der Variable I der Wert 3 zugewiesen. Die Variablenreferenz auf der linken Seite der Zuweisung kann auch im Ausdruck auf der rechten Seite enthalten sein. Zum Beispiel:

I := I + 1;

Hier wird der Wert von I inkrementiert. Weitere Beispiele für Zuweisungen:
<source lang="delphi">
X := Y + Z;
Done := (I >= 1) and (I < 100);
Hue1 := [Blue, Succ(C)];
I := Sqr(J) - I * K;
Shortint(MyChar) := 122;
TByteRec(W).Hi := 0;
MyString[I] := 'A';
SomeArray[I + 1] := P^;
TMyObject.SomeProperty := True;
</source>

===Prozedur- und Funktionsaufrufe===

Ein Prozeduraufruf besteht aus dem Namen einer Prozedur (mit oder ohne Qualifizierer) und (falls erforderlich) einer Parameterliste. Hier einige Beispiele für Prozeduraufrufe:
<source lang="delphi">
PrintHeading;
Transpose(A, N, M);
Find(Smith, William);
Writeln('Hello world!');
DoSomething();
Unit1.SomeProcedure;
TMyObject.SomeMethod(X,Y);
</source>
Wenn die erweiterte Syntax ('''{$X+}''') aktiviert ist, können auch Funktionsaufrufe, wie z. B. Aufrufe von Prozeduren, als Anweisungen behandelt werden:

MyFunction(X);

Bei dieser Verwendung eines Funktionsaufrufs wird der Rückgabewert verworfen.

Weitere Informationen zu Prozeduren und Funktionen finden Sie unter [[Prozeduren und Funktionen (Delphi)|Prozeduren und Funktionen (Delphi)]].

===Goto-Anweisungen===

Die Syntax für '''goto'''-Anweisungen lautet:

goto label

Eine goto-Anweisung setzt die Ausführung des Programms mit der Anweisung fort, die mit dem angegebenen Label gekennzeichnet ist. Zur Kennzeichnung einer Anweisung deklarieren Sie zunächst das Label. Dann fügen Sie vor der zu kennzeichnenden Anweisung das Label und einen Doppelpunkt ein:

''label: statement''

Labels werden folgendermaßen deklariert:

label ''label;''

Es können auch mehrere Labels gleichzeitig deklariert werden:

label ''label1'', ..., ''labeln;''

Als Label kann jeder gültige Bezeichner und jede Zahl von 0 bis 4294967295 verwendet werden.

Da Labels keine Sprünge aus einer Prozedur bzw. Funktion in eine andere erlauben, müssen sich die Label-Deklaration, die gekennzeichnete Anweisung und die '''goto'''-Anweisung innerhalb eines Blocks befinden. (siehe "Blöcke und Gültigkeitsbereich" weiter unten). In einem Block darf jedes Label nur einmal zur Kennzeichnung einer Anweisung verwendet werden.

Zum Beispiel:
<source lang="delphi">
label StartHere;
...
StartHere: Beep;
goto StartHere;
</source>
Dieser Quelltext ergibt eine Endlosschleife, in der immer wieder die Prozedur Beep aufgerufen wird.

Sprünge in oder aus '''try'''-'''finally'''- oder '''try'''-'''except'''-Anweisungen sind nicht möglich.

Im Sinne eines guten Programmierstils sollten '''goto'''-Anweisungen so sparsam wie möglich eingesetzt werden. In bestimmten Fällen bieten sie sich aber an, um eine verschachtelte Schleife zu verlassen. Dazu ein Beispiel:
<source lang="delphi">
procedure FindFirstAnswer;
var X, Y, Z, Count: Integer;
label FoundAnAnswer;
begin
Count := SomeConstant;
for X := 1 to Count do
for Y := 1 to Count do
for Z := 1 to Count do
if ... { some condition holds on X, Y, and Z } then
goto FoundAnAnswer;

... { Code to execute if no answer is found }
Exit;

FoundAnAnswer:
... { Code to execute when an answer is found }
end;
</source>
Die '''goto'''-Anweisung wird hier eingesetzt, um eine verschachtelte Schleife zu verlassen. Sprünge in eine Schleife oder strukturierte Anweisung müssen vermieden werden, da dies zu unvorhersehbaren Ergebnissen führen könnte.

==Strukturierte Anweisungen==

Strukturierte Anweisungen setzen sich aus anderen Anweisungen zusammen. Sie werden eingesetzt, wenn andere Anweisungen sequenziell, wiederholt oder in Abhängigkeit von einer Bedingung ausgeführt werden sollen.

* Eine Verbundanweisung (auch als '''with'''-Anweisung bezeichnet) führt eine Folge von Teilanweisungen aus.
* Eine bedingte Anweisung (also eine '''if'''- oder '''case'''-Anweisung) führt nach der Auswertung einer Bedingung mindestens eine ihrer Teilanweisungen aus.
* Schleifenanweisungen ('''repeat'''-, '''while'''- und '''for'''-Schleifen) führen eine Folge von Teilanweisungen mehrmals hintereinander aus.
* Eine spezielle Anweisungsgruppe (einschließlich Konstruktionen mit '''raise''', '''try'''...'''except''' und '''try'''...'''finally''' dienen zur Generierung und Behandlung von Exceptions. Einzelheiten zum Erzeugen und Behandeln von Exceptions finden Sie unter [[Exceptions (Delphi)|Exceptions ({{Delphi}})]].

===Verbundanweisungen===

Eine Verbundanweisung setzt sich aus einer Folge von anderen (einfachen oder strukturierten) Anweisungen zusammen, die nacheinander ausgeführt werden. Die in einer Verbundanweisung enthaltenen Teilanweisungen sind zwischen den reservierten Wörtern '''begin''' und '''end''' eingeschlossen und durch Strichpunkte voneinander getrennt. Zum Beispiel:
<source lang="delphi">
begin
Z := X;
X := Y;
X := Y;
end;
</source>
Der letzte Strichpunkt vor '''end''' ist optional. Die Verbundanweisung könnte demnach auch folgendermaßen aussehen:
<source lang="delphi">
begin
Z := X;
X := Y;
Y := Z
end;
</source>
Verbundanweisungen sind wichtig, wenn die Syntax von {{Delphi}} eine einzelne Anweisung verlangt. Sie können in Programm-, Funktions- und Prozedurblöcke und in andere strukturierte Anweisungen (z. B. bedingte Anweisungen oder Schleifen) integriert werden. Zum Beispiel:
<source lang="delphi">
begin
I := SomeConstant;
while I > 0 do
begin
...
I := I - 1;
end;
end;
</source>
Es gibt auch Verbundanweisungen, die nur eine einzelne Teilanweisung enthalten. Wie runde Klammen in einem komplexen Ausdruck tragen die Wörter '''begin''' und '''end''' zur Vermeidung von Mehrdeutigkeiten und zur Verbesserung der Lesbarkeit bei. Es ist auch möglich, mit einer leeren Verbundanweisung einen Block zu erzeugen, der keine Aktion ausführt:

begin
end;

===with-Anweisungen===

Eine '''with'''-Anweisung stellt eine einfache und bequeme Möglichkeit dar, die Felder eines Records oder die Felder, Eigenschaften und Methoden eines Objekts zu referenzieren. Die Syntax einer '''with'''-Anweisung lautet:

'''with''' ''obj'' '''do''' ''statement''

oder:

'''with''' ''obj1, ..., objn'' '''do''' ''statement''

''obj'' ist ein Ausdruck mit einer Referenz auf einen Record, eine Objektinstanz, eine Klasseninstanz, eine Interface- oder Klassentyp-(Metaklassen-)Instanz. ''statement'' ist eine einfache oder eine strukturierte Anweisung. Innerhalb von ''statement'' können Felder, Eigenschaften und Methoden von ''obj'' nur über ihren Bezeichner referenziert werden. Die Angabe von Qualifizierern ist nicht erforderlich.

Ausgehend von den Deklarationen:
<source lang="delphi">
type
TDate = record
Day: Integer;
Month: Integer;
Year: Integer;
end;

var
OrderDate: TDate;
</source>
könnten Sie die folgende '''with'''-Anweisung:
<source lang="delphi">
with OrderDate do
if Month = 12 then
begin
Month := 1;
Year := Year + 1;
end
else
Month := Month + 1;
</source>
oder eine '''with'''-Anweisung schreiben:
<source lang="delphi">
if OrderDate.Month = 12 then
begin
OrderDate.Month := 1;
OrderDate.Year := OrderDate.Year + 1;
end
else
OrderDate.Month := OrderDate.Month + 1;
</source>
Wenn die Interpretation von ''obj'' die Indizierung von Arrays oder die Dereferenzierung von Zeigern verlangt, werden diese Aktionen einmal durchgeführt, bevor die Anweisung ausgeführt wird. Dies macht '''with'''-Anweisungen sowohl effizient als auch kurz. Außerdem können sich während der aktuellen Ausführung der '''with'''-Anweisung Zuweisungen an eine Variable innerhalb der Anweisung nicht auf die Interpretation von ''obj'' auswirken.

Jede Variablenreferenz und jeder Methodenname in einer '''with'''-Anweisung wird, wenn möglich, als Member des angegebenen Objekts bzw. Records interpretiert. Wenn in der '''with'''-Anweisung auf eine andere Variable oder Methode mit demselben Namen zugegriffen werden soll, ist ein Qualifizierer erforderlich:
<source lang="delphi">
with OrderDate do
begin
Year := Unit1.Year;
...
end;
</source>
Wenn auf '''with''' mehrere Objekte oder Records folgen, wird die gesamte Anweisung als Folge von verschachtelten '''with'''-Anweisungen behandelt. Die Anweisung:

'''with''' ''obj1, obj2, ..., objn'' '''do''' ''statement''

ist gleichbedeutend mit:
<source lang="delphi">
with obj1 do
with obj2 do
...
with objn do
// statement
</source>
In diesem Fall wird jede Variablenreferenz und jeder Methodenname in der Anweisung als Member von ''objn'' behandelt, wenn dies möglich ist. Andernfalls wird die Referenz bzw. der Name als Member von ''objn1'' interpretiert usw. Dieselbe Regel gilt für die Interpretation von ''objs'' selbst. Ist beispielsweise ''objn'' sowohl ein Member von ''obj1'' als auch von ''obj2'', wird es als ''obj2.objn'' interpretiert.

Da für eine '''with'''-Anweisung eine Variable oder ein Feld erforderlich ist, kann deren Verwendung mit Eigenschaften manchmal kompliziert sein. Variablen für eine '''with'''-Anweisung müssen '''per Referenz''' zur Verfügung stehen.

Beachten Sie bei der Verwendung von '''with''' Folgendes:

* '''with''' kann bei schreibgeschützten Eigenschaften ''nur zum Lesen'' verwendet werden. Der Versuch, ein Feld in dem betreffenden Record oder Objekt zu ändern, führt zu einem Compilierfehler.
* Auch wenn die Eigenschaft einen Schreibzugriff auf das Feld zulässt, können Sie deren Felder nicht mit '''with''' ändern.

Der folgende Code veranschaulicht das Problem bei der Verwendung der '''with'''-Anweisung für schreibgeschützte Eigenschaften, die einen Record bereitstellen. Angenommen, es gibt die folgende Klasse:
<source lang="delphi">
TShape = class
private
FCenter: TPoint;
public
property Center: TPoint read FCenter;
end;
</source>
TPoint ist ein folgendermaßen deklarierter Record:
<source lang="delphi">
TPoint = record
X, Y: Integer;
end;
</source>
Normalerweise ist die Eigenschaft '''Center''' schreibgeschützt und erlaubt das Ändern der Werte oder Felder des '''FCenter'''-Feldes nicht.
In diesem Fall misslingt eine '''with'''-Anweisung wie die folgende mit einem Compilierfehler, weil Shape.Center keine Variable ist und nicht referenziert werden kann:
<source lang="delphi">
with Shape.Center do
begin
X := 100;
Y := 100;
end;
</source>
Eigenschaften für Lese- und Schreibzugriffe komplizieren die Verwendung der '''with'''-Anweisung. Die ursprüngliche '''TShape'''-Klasse wurde geändert, um einen Schreibzugriff auf das Feld '''FCenter''' zuzulassen:
<source lang="delphi">
TShape = class
private
FCenter: TPoint;
public
property Center: TPoint read FCenter '''write FCenter''';
end;
</source>
Obwohl die Eigenschaft '''Center''' nicht schreibgeschützt ist, wird derselbe Compilierfehler ausgegeben. Zur Lösung dieses Problems muss der folgende Code:
<source lang="delphi">
with Shape.Center do
begin
X := 100;
Y := 100;
end;
</source>
in diesen Code geändert werden:
<source lang="delphi">
{ Copy the value of Center to a local variable. }
TempPoint := Shape.Center;

with TempPoint do
begin
X := 100;
Y := 100;
end;

{ Set the value back. }
Shape.Center := TempPoint;
</source>

===if-Anweisungen===

Es gibt zwei Formen der '''if'''-Anweisung: '''if'''...'''then''' und '''if'''...'''then'''...'''else'''. Die Syntax für eine '''if'''...'''then'''-Anweisung lautet:

'''if''' ''expression'' '''then''' ''statement''

Das Ergebnis von ''expression'' ist ein Wert vom Typ '''Boolean'''. ''statement'' wird nur ausgeführt, wenn expression '''True''' ergibt. Zum Beispiel:

if J <> 0 '''then''' Result := I / J;

Die Syntax für eine '''if'''...'''then'''...'''else'''-Anweisung lautet:

'''if''' ''expression'' '''then''' ''statement1'' '''else''' ''statement2''

Das Ergebnis von ''expression'' ist ein Wert vom Typ '''Boolean'''. Wenn expression den Wert '''True''' ergibt, wird ''statement1'' ausgeführt, andernfalls ''statement2''. Zum Beispiel:
<source lang="delphi">
if J = 0 then
Exit
else
Result := I / J;
</source>
Die '''then'''- und '''else'''-Klauseln enthalten jeweils nur eine Anweisung, die aber auch eine strukturierte Anweisung sein könnte. Zum Beispiel:
<source lang="delphi">
if J <> o then
begin
Result := I / J;
Count := Count + 1;
end
else if Count = Last then
Done := True
else
Exit;
</source>
Zwischen der '''then'''-Klausel und dem Wort '''else''' darf kein Strichpunkt stehen. Nach einer vollständigen '''if'''-Anweisung können Sie einen Strichpunkt verwenden, um sie von der nächsten Anweisung innerhalb des Blocks zu trennen. Zwischen der '''then'''- und der '''else'''-Klausel wird nur ein Leerzeichen oder ein Wagenrücklaufzeichen benötigt. Das Einfügen eines Strichpunkts vor dem Wort '''else''' (in einer '''if'''-Anweisung) ist ein häufiger Programmierfehler.

Auch verschachtelte '''if'''-Anweisungen bergen die Gefahr von Programmierfehlern. Und zwar deshalb, weil für bestimmte '''if'''-Anweisungen '''else'''-Klauseln existieren, für andere jedoch nicht. Ansonsten ist die Syntax für die beiden Konstrukte identisch. Wenn in einer Folge von Bedingungen weniger '''else'''-Klauseln als '''if'''-Anweisungen vorhanden sind, ist möglicherweise die Zuordnung der '''else'''-Klauseln zu den '''if'''-Anweisungen nicht eindeutig erkennbar. Die Anweisung

'''if''' ''expression1'' '''then''' '''if''' ''expression2'' '''then''' ''statement1'' '''else''' ''statement2'';

könnte demnach auf zwei Arten interpretiert werden:

'''if''' ''expression1'' '''then''' [ '''if''' ''expression2'' '''then''' ''statement1'' '''else''' ''statement2'' ];

'''if''' ''expression1'' '''then''' [ '''if''' ''expression2'' '''then''' ''statement1'' ] '''else''' ''statement2'';

Der Compiler verwendet aber immer die erste Interpretationsart. Dies bedeutet, dass die Anweisung:
<source lang="delphi">
if ... { expression1} then
if ... {expression2} then
... {statement1}
else
... {statement2}
</source>
gleichbedeutend ist mit:
<source lang="delphi">
if ... {expression1} then
begin
if ... {expression2} then
... {statement1}
else
... {statement2}
end;
</source>
Die Interpretation von verschachtelten Bedingungen beginnt immer bei der innersten Bedingung. Dabei wird jedes '''else''' dem letzten vorhergehenden '''if''' zugeordnet. Wenn der Compiler die zweite Interpretationsart verwenden soll, muss der Quelltext folgendermaßen aussehen:
<source lang="delphi">
if ...
{expression1}

then
begin
if ...
{expression2}

then
...
{statement1}

end
else
...
{statement2}

;
</source>

===case-Anweisungen===

Die '''case'''-Anweisung ist eine Alternative zur '''if'''-Anweisung, die aufgrund der besseren Lesbarkeit bei komplexen Verschachtelungen eingesetzt werden sollte. Die Syntax einer '''case'''-Anweisung lautet:
<source lang="delphi">
case selectorExpression of
caseList1: statement1;
...
caseListn: statementn;
end
</source>
''selectorExpression'' ist ein beliebiger Ausdruck mit einem ordinalen Typ, der kleiner als 32 Bit ist (String-Typen und ordinale Typen, die größer als 32 Bit sind, sind nicht zulässig). Für ''caseList'' kann Folgendes angegeben werden:

* Eine Zahl, eine deklarierte Konstante oder ein anderer Ausdruck, den der Compiler auswerten kann, ohne dazu das Programm selbst auszuführen. Dieser Wert muss ein ordinaler Typ sein, der mit dem Typ von ''selectorExpression'' kompatibel ist. 7, '''True''', 4 + 5 * 3, 'A' und Integer('A') sind demnach als ''caseLists'' zulässig, Variablen und die meisten Funktionsaufrufe dagegen nicht. (Einige integrierte Funktionen wie Hi und Lo können in einer ''caseList'' enthalten sein. Siehe [[Deklarierte Konstanten|Deklarierte Konstanten]].)
* Ein Teilbereich der Form ''Erster..Letzter'', wobei ''Erster'' und ''Letzter'' dem obigen Kriterium entsprechen müssen und ''Erster'' kleiner oder gleich ''Letzter'' sein muss.
* Eine Liste der Form ''Element1, ..., Elementn'', wobei jedes ''Element'' den obigen Kriterien entsprechen muss.

Jeder in einer ''caseList'' angegebene Wert muss innerhalb der '''case'''-Anweisung eindeutig sein. Teilbereiche und Listen dürfen sich nicht überschneiden. Eine '''case'''-Anweisung kann über eine abschließende '''else'''-Klausel verfügen:
<source lang="delphi">
case selectorExpression of
caseList1: statement1;
...
caselistn: statementn;
else
statements;
end
</source>
''statements'' ist eine Folge von Anweisungen, die durch Strichpunkte voneinander getrennt sind. Bei der Ausführung einer '''case'''-Anweisung wird höchstens eine ''statement1 ...statementn''-Anweisung ausgeführt. Dabei handelt es sich um genau diejenige, deren ''caseList''-Wert mit dem von ''selectorExpression'' identisch ist. Ist kein entsprechender ''selectorExpression''-Wert in ''caseList'' vorhanden, werden die Anweisungen in der '''else'''-Klausel (falls vorhanden) ausgeführt.

'''Die case-Anweisung'''
<source lang="delphi">
case I of
1..5: Caption := 'Low';
6..9: Caption := 'High';
0, 10..99: Caption := 'Out of range';
else
Caption := '';
end
</source>
ist mit der folgenden verschachtelten Anweisung identisch:
<source lang="delphi">
if I in [1..5] then
Caption := 'Low';
else if I in [6..10] then
Caption := 'High';
else if (I = 0) or (I in [10..99]) then
Caption := 'Out of range'
else
Caption := '';
</source>'''Weitere Beispiele für case-Anweisungen'''
<source lang="delphi">
case MyColor of
Red: X := 1;
Green: X := 2;
Blue: X = 3;
Yellow, Orange, Black: X := 0;
end;

case Selection of
Done: Form1.Close;
Compute: calculateTotal(UnitCost, Quantity);
else
Beep;
end;
</source>

===Schleifen===

Schleifen ermöglichen die wiederholte Ausführung einer Anweisungsfolge. Eine Bedingung oder eine Variable bestimmt, wann die Ausführung angehalten wird. {{Delphi}} unterstützt drei Arten von Schleifen: '''repeat'''-, '''while'''- und '''for'''-Anweisungen.

Mit den Standardprozeduren Break und Continue können Sie den Ablauf einer '''repeat'''-, '''while'''- oder '''for'''-Anweisung steuern. Break beendet eine Schleife, Continue fährt mit der nächsten Iteration fort.

====repeat-Anweisungen====

Die Syntax einer '''repeat'''-Anweisung lautet:

'''repeat''' ''statement1; ...; statementn;'' '''until''' ''expression''

Das Ergebnis von ''expression'' ist ein Wert vom Typ '''Boolean'''. (Die Angabe des letzten Strichpunkts vor '''until''' ist optional.) Alle '''repeat'''-Anweisungen werden der Reihe nach ausgeführt. Nach jedem Durchlauf wird ''expression'' ausgewertet. Liefert ''expression'' den Wert '''True''', wird die '''repeat'''-Anweisung beendet. Da ''expression'' erst am Ende der ersten Iteration ausgewertet wird, wird die Anweisungsfolge mindestens einmal durchlaufen.

Hier einige Bespiele für '''repeat'''-Anweisungen:
<source lang="delphi">
repeat
K := I mod J;
I := J;
J := K;
until J = 0;

repeat
Write('Enter a value (0..9): ');
Readln(I);
until (I >= 0) and (I <= 9);
</source>

====while-Anweisungen====

Eine '''while'''-Anweisung ähnelt in vielerlei Hinsicht einer '''repeat'''-Anweisung, doch wird die Bedingung bereits vor der ersten Ausführung der Anweisungsfolge ausgewertet. Wenn das Ergebnis der Bedingung False ist, wird die Anweisungsfolge nicht ausgeführt.

Die Syntax einer '''while'''-Anweisung lautet:

'''while''' ''expression'' '''do''' ''statement''

''expression'' gibt einen '''booleschen''' Wert zurück. Bei ''statement'' kann es sich auch um eine Verbundanweisung handeln. Die '''while'''-Anweisung führt ''statement'' wiederholt aus und wertet vor jedem neuen Durchlauf ''expression'' aus. Solange ''expression'' den Wert '''True''' ergibt, wird die Ausführung fortgesetzt.

Hier einige Bespiele für '''while'''-Anweisungen:

<source lang="delphi">
while Data[I] <> X do I := I + 1;

while I > 0 do
begin
if Odd(I) then Z := Z * X;
I := I div 2;
X := Sqr(X);
end;

while not Eof(InputFile) do
begin
Readln(InputFile, Line);
Process(Line);
end;
</source>

====for-Anweisungen====

Im Gegensatz zu '''repeat'''- und '''while'''-Anweisungen wird bei '''for'''-Anweisungen angegeben, wie oft die Schleife durchlaufen werden soll. Die Syntax einer '''for'''-Anweisung lautet:

'''for''' ''counter'' := ''initialValue'' '''to''' ''finalValue'' '''do''' ''statement''

oder:

'''for''' ''counter'' := ''initialValue'' '''downto''' ''finalValue'' '''do''' ''statement''

wobei:

* ''counter'' eine lokale Variable ordinalen Typs ohne Qualifizierer ist. Sie wird in dem Block deklariert, in dem die '''for'''-Anweisung enthalten ist.
* ''initialValue'' und ''finalValue'' sind Ausdrücke, die zu ''counter'' zuweisungskompatibel sind.
* ''statement'' ist eine einfache oder eine strukturierte Anweisung, die den Wert von ''counter'' nicht ändert.

Die '''for'''-Anweisung weist ''counter'' den angegebenen ''initialValue'' zu und führt anschließend wiederholt ''statement'' aus. Abhängig von der verwendeten Syntax wird der Wert von ''counter'' bei jedem Durchlauf inkrementiert ('''for'''...'''to''') oder dekrementiert ('''for'''...'''downto'''). Sobald der Wert von ''counter'' mit dem Wert von ''finalValue'' identisch ist, wird ''statement'' ein letztes Mal ausgeführt und anschließend die '''for'''-Anweisung beendet. ''statement'' wird also einmal für jeden Wert ausgeführt, der im Bereich von ''initialValue'' bis ''finalValue'' liegt. Ist ''initialValue'' mit ''finalValue'' identisch, wird ''statement'' genau einmal ausgeführt. Wenn ''initialValue'' in einer '''for'''...'''to'''-Anweisung größer als ''finalValue'' ist, wird ''statement'' nie ausgeführt. Dasselbe gilt für eine '''for'''...'''downto'''-Anweisung, in der der Anfangswert kleiner als ''finalValue'' ist. Nach der Beendigung der '''for'''-Anweisung ist der Wert von ''counter'' nicht definiert (vorausgesetzt, die Beendigung wurde nicht durch eine Break- oder Exit-Prozedur verursacht).

: {{Warning|Die Iterationsvariable '''counter''' kann innerhalb der Schleife nicht verändert werden. Dies beinhaltet Zuweisungen und die Übergabe der Variable an einen '''var'''-Parameter einer Prozedur. Diese Operationen würden zu einer Compiler-Warnung führen.}}

Die Ausdrücke ''initialValue'' und ''finalValue'' werden zur Steuerung der Schleifenausführung nur einmal ausgewertet, und zwar vor Beginn der Schleife. Daher hat die '''for'''...'''to'''-Anweisung starke Ähnlichkeit mit dem folgenden '''while'''-Konstrukt:
<source lang="delphi">
begin
counter := initialValue;
while counter <= finalValue do
begin
... {statement};
counter := Succ(counter);
end;
end.
</source>
Im Unterschied zur '''for'''...'''to'''-Anweisung wird ''finalValue'' aber in der '''while'''-Schleife vor jedem Durchlauf erneut ausgewertet. Wenn ''finalValue'' ein komplexer Ausdruck ist, kann dies eine Verlangsamung der Ausführungsgeschwindigkeit zur Folge haben. Außerdem können sich von ''statement'' verursachte Änderungen an ''finalValue'' auf die Ausführung der Schleife auswirken.

'''Beispiele für for-Anweisungen'''
<source lang="delphi">
for I := 2 to 63 do
if Data[I] > Max then
Max := Data[I];

for I := ListBox1.Items.Count - 1 downto 0 do
ListBox1.Items[I] := UpperCase(ListBox1.Items[I]);

for I := 1 to 10 do
for J := 1 to 10 do
begin
X := 0;
for K := 1 to 10 do
X := X + Mat1[I,K] * Mat2[K,J];
Mat[I,J] := X;
end;
</source>

for C := Red to Blue do Check(C);

====Iteration durch Container mit for-Anweisungen====

{{Delphi}} unterstützt die for-Element-in-Kollektion-Iteration durch Container. Dabei werden die folgenden Iterationsmuster vom Compiler erkannt:

*for Element in ArrayAusdr do Anw;
*for Element in StringAusdr do Anw;
*for Element in SetAusdr do Anw;
*for Element in KollektionsAusdr do Anw;
*for Element in KollektionsAusdr do Anw;

Der Typ der Iterationsvariable Element muss mit dem Typ im Container übereinstimmen. Bei jedem Schleifendurchlauf enthält die Iterationsvariable das aktuelle Kollektionselement. Wie bei regulären '''for'''-Schleifen muss die Iterationsvariable in demselben Block wie die '''for'''-Anweisung deklariert werden.

: {{Warning| Die Iterationsvariable kann innerhalb der Schleife nicht verändert werden. Dies beinhaltet Zuweisungen und die Übergabe der Variable an einen '''var'''-Parameter einer Prozedur. Diese Operationen würden zu einer Compiler-Warnung führen.}}

Array-Ausdrücke können sich auf ein- oder mehrdimensionale Arrays, Arrays mit fester Länge oder dynamische Arrays beziehen. Das Array wird in aufsteigender Reihenfolge durchlaufen, beginnend mit der unteren Array-Grenze bis zur Array-Größe minus eins. Der folgende Code zeigt Beispiele der Iteration durch eindimensionale, mehrdimensionale und dynamische Arrays:

<source lang="delphi">
type
TIntArray = array[0..9] of Integer;
TGenericIntArray = array of Integer;

var
IArray1: array[0..9] of Integer = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
IArray2: array[1..10] of Integer = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
IArray3: array[1..2] of TIntArray = ((11, 12, 13, 14, 15, 16, 17, 18, 19, 20),
(21, 22, 23, 24, 25, 26, 27, 28, 29, 30));
MultiDimTemp: TIntArray;
DynArray: TGenericIntArray;

I: Integer;

begin
for I in IArray1 do
begin
{ Do something with I... }
end;

{ Indexing begins at lower array bound of 1. }
for I in IArray2 do
begin
{ Do something with I... }
end;

{ Iterating a multidimensional array }
for MultiDimTemp in IArray3 do // Indexing from 1..2
for I in MultiDimTemp do // Indexing from 0..9
begin
{ Do something with I... }
end;

{ Iterating over a dynamic array }
DynArray := TGenericIntArray.Create(1, 2, 3, 4);

for I in DynArray do
begin
{ Do something with I... }
end;
end.
</source>

Das folgende Beispiel zeigt die Iteration durch String-Ausdrücke:

<source lang="delphi">
var
C: Char;
S1, S2: String;
Counter: Integer;

OS1, OS2: ShortString;
AC: AnsiChar;

begin

S1 := 'Now is the time for all good men to come to the aid of their country.';
S2 := ''''''';

for C in S1 do
S2 := S2 + C;

if S1 = S2 then
Writeln('SUCCESS #1')
else
Writeln('FAIL #1');

OS1 := 'When in the course of human events it becomes necessary to dissolve...';
OS2 := ''''''';

for AC in OS1 do
OS2 := OS2 + AC;

if OS1 = OS2 then
Writeln('SUCCESS #2')
else
Writeln('FAIL #2');

end.
</source>
Das folgende Beispiel zeigt die Iteration durch Mengen-Ausdrücke:

<source lang="delphi">
type

TMyThing = (one, two, three);
TMySet = set of TMyThing;
TCharSet = set of Char;

var
MySet: TMySet;
MyThing: TMyThing;

CharSet: TCharSet;
C: Char;

begin

MySet := [one, two, three];
for MyThing in MySet do
begin
// Do something with MyThing...
end;

CharSet := [#0..#255];
for C in CharSet do
begin
// Do something with C...
end;

end.
</source>
Für die Verwendung von '''for'''-'''in'''-Schleifenkonstrukten bei Klassen muss die Klasse oder das Interface ein vorschriftsmäßiges Kollektionsmuster implementieren. Ein Typ, der Kollektionsmuster implementiert, muss die folgenden Attribute haben:

* Die Klasse oder das Interface muss eine als public deklarierte Instanzmethode namens GetEnumerator() enthalten. Die Methode GetEnumerator() muss einen Klassen-, Interface- oder Record-Typ zurückgeben.
* Die von GetEnumerator() zurückgegebene Klasse bzw. das Interface oder der Record muss eine als public deklarierte Instanzmethode namens MoveNext() enthalten. Die Methode MoveNext() muss einen '''booleschen''' Wert zurückgeben. Die '''for-in'''-Schleife ruft zuerst diese Methode auf, um sicherzustellen, dass der Container nicht leer ist.
* Die von GetEnumerator() zurückgegebene Klasse bzw. das Interface oder der Record muss eine als public deklarierte, schreibgeschützte Instanzeigenschaft namens Current enthalten. Der Typ der Eigenschaft Current muss mit dem in der Kollektion enthaltenen Typ übereinstimmen.

Der folgende Code zeigt die Iteration durch einen Container in {{Delphi}}.<source lang="delphi">
type
TMyIntArray = array of Integer;
TMyContainerEnumerator = class;

TMyContainer = class
public
Values: TMyIntArray;
function GetEnumerator: TMyContainerEnumerator;
end;

TMyContainerEnumerator = class
Container : TMyContainer;
Index : Integer;
public
constructor Create(AContainer : TMyContainer);
function GetCurrent: Integer;
function MoveNext: Boolean;
property Current: Integer read GetCurrent;
end;

constructor TMyContainerEnumerator.Create(AContainer : TMyContainer);
begin
inherited Create;
Container := AContainer;
Index := - 1;
end;

function TMyContainerEnumerator.MoveNext: Boolean;
begin
Result := Index < High(Container.Values);
if Result then
Inc(Index);
end;

function TMyContainerEnumerator.GetCurrent: Integer;
begin
Result := Container.Values[Index];
end;

function TMyContainer.GetEnumerator: TMyContainerEnumerator;
begin
Result := TMyContainerEnumerator.Create(Self);
end;

var
MyContainer : TMyContainer;
I : Integer;
Counter : Integer;
begin
MyContainer := TMyContainer.Create;
MyContainer.Values := TMyIntArray.Create(100, 200, 300);

Counter := 0;
for I in MyContainer do
Inc(Counter, I);

Writeln('Counter = ', Counter, ' (should be 600)');
ReadLn;
end.
</source>

Als Teil der Enumeratortypen für Sammlungen definiert RAD Studio den Enumeratorstatus explizit, wenn die Iteration abgeschlossen ist: "Der Enumeratorstatus ist nicht gültig, nachdem MoveNext False zurückgegeben hat und der Enumerator freigegeben oder neu erstellt werden muss, und es sollte nicht mehr darauf zugegriffen werden."

====Iteration durch Datenmengen mit for-Anweisungen====

{{Delphi}} unterstützt die for-in-Syntaxkonstruktion für die Iteration durch Datenmengen. Der Compiler erkennt das folgende Iterationsmuster für Datenmengen:

*for Record in Dataset do Smth;

wobei <code>Record</code> die [[lib_de:Data.DB.TDataSet|TDataSet]]-API repräsentiert. Record kann problemlos mit Datenmenge gleichgesetzt werden.

Im folgenden Codefragment wird durch eine Datenmenge in {{Delphi}} iteriert. Der Beispielcode zeigt, wie die Werte der Spalte "Name" in ein Memo-Steuerelement ausgegeben werden.

<source lang="delphi">

var
ds: TDataSet;
//
FQuery1.SQL.Text := 'SELECT Name FROM Table1';
Memo1.Lines.Clear;
for ds in FDQuery1 do
Memo1.Lines.Add(ds.FieldByName('Name').AsString);

</source>

{{Note| In die Datenmengenaufzählung kann nicht erneut eingetreten werden. Das heißt, dass Sie für jede Datenmenge jeweils nur eine Aufzählung verwenden können. Wenn Sie mehrere <code>for-in</code>-Schleifen für dieselbe Datenmenge gleichzeitig ausführen müssen, verwenden Sie stattdessen die Methode [[lib_de:Data.DB.TDataSet.View|TDataSet.View]] (siehe weiter unten in diesem Thema). In diesem Szenario ist in der <code>for-in</code>-Schleife ein Record nicht unbedingt mit einer Datenmenge identisch.}}

Das folgende Codefragment zeigt, wie die Methode [[lib_de:Data.DB.TDataSet.View|TDataSet.View]] zur Aufzählung einer Datenmenge verwendet wird.

<source lang="delphi">
var
ds: TDataSet;
//...
Memo1.Lines.Clear;
for ds in FDQuery1.View(dmAllowClone) do
Memo1.Lines.Add(ds.FieldByName('name').AsString);
</source>

====Liste der unterstützten Klassen====

Die folgenden Klassen und ihre Nachkommen unterstützen die '''for'''-'''in'''-Syntax:

* [[lib_de:System.Classes.TList|System.Classes.TList]]
* [[lib_de:System.Classes.TCollection|System.Classes.TCollection]]
* [[lib_de:System.Classes.TStrings|System.Classes.TStrings]]
* [[lib_de:System.Classes.TInterfaceList|System.Classes.TInterfaceList]]
* [[lib_de:System.Classes.TComponent|System.Classes.TComponent]] {{f|vcl|
* [[lib_de:Vcl.Menus.TMenuItem|Vcl.Menus.TMenuItem]]
* [[lib_de:Vcl.ActnList.TCustomActionList|Vcl.ActnList.TCustomActionList]]
* [[lib_de:Vcl.ComCtrls.TListItems|Vcl.ComCtrls.TListItems]]
* [[lib_de:Vcl.ComCtrls.TTreeNodes|Vcl.ComCtrls.TTreeNodes]]
* [[lib_de:Vcl.ComCtrls.TToolBar|Vcl.ComCtrls.TToolBar]] }}
* [[lib_de:Data.DB.TFields|Data.DB.TFields]]
* [[lib_de:Data.DB.TDataSet|Data.DB.TDataSet]]

==Blöcke und Gültigkeitsbereich==

Deklarationen und Anweisungen werden in ''Blöcken'' zusammengefasst. Alle in einem Block deklarierten Labels und Bezeichner sind für diesen Block lokal, das heißt, der Block stellt den ''Gültigkeitsbereich'' für diese Labels und Bezeichner dar. Blöcke ermöglichen es, einem Bezeichner (z. B. einem Variablennamen) in den einzelnen Programmabschnitten eine unterschiedliche Bedeutung zu geben. Ein Block ist immer Teil der Deklaration eines Programms, einer Funktion oder einer Prozedur. Umgekehrt verfügt jede Programm-, Funktions- oder Prozedurdeklaration über mindestens einen Block.

===Blockanweisungen===

Ein Block besteht aus Deklarationen und einer Verbundanweisung. Alle Deklarationen müssen zusammen am Anfang des Blocks stehen. Ein Block ist folgendermaßen aufgebaut:

{declarations}
begin
{statements}
end

Der Abschnitt ''declarations'' besteht aus Deklarationen von Variablen, Konstanten (einschließlich Ressourcenstrings), Typen, Prozeduren, Funktionen und Labels. In einem Programmblock können im ''declarations''-Abschnitt auch eine oder mehrere '''exports'''-Klauseln enthalten sein (siehe [[Bibliotheken und Packages (Delphi)|Bibliotheken und Packages (Delphi)]].)

In einer Funktionsdeklaration wie der folgenden:
<source lang="delphi">
function UpperCase(const S: string): string;
var
Ch: Char;
L: Integer;
Source, Dest: PChar;
begin
...
end;
</source>
bildet die erste Zeile den Funktionskopf, die restliche Zeilen stellen den Block dar. Ch, L, Source und Dest sind lokale Variablen. Ihre Deklarationen sind nur im Funktionsblock von UpperCase gültig. Sie setzen in diesem Block (und nur hier) die Deklarationen aller Bezeichner gleichen Namens außer Kraft, die im '''program'''-Block bzw. im '''interface'''- oder '''implementation'''-Abschnitt einer Unit enthalten sind.

===Gültigkeitsbereich===

Ein Bezeichner, z. B. ein Variablen- oder Funktionsname, kann nur innerhalb des Gültigkeitsbereichs seiner Deklaration verwendet werden. Der Gültigkeitsbereich einer Deklaration hängt davon ab, wo die Deklaration stattfindet. Der Gültigkeitsbereich eines Bezeichners, der in der Deklaration eines Programms, einer Funktion oder einer Prozedur deklariert ist, beschränkt sich auf den Block, der die Deklaration enthält. Der Gültigkeitsbereich der im interface-Abschnitt einer Unit deklarierten Bezeichner erstreckt sich über alle Units und Programme, die diese Unit einbinden. Bezeichner mit eingeschränktem Gültigkeitsbereich (besonders solche, die in Funktionen und Prozeduren deklariert sind) werden lokale Bezeichner genannt. Bei Bezeichnern mit größerem Gültigkeitsbereich spricht man von globalen Bezeichnern.

Die folgende Tabelle gibt einen Überblick über die Regeln für den Gültigkeitsbereich von Bezeichnern.

{| border="1" frame="hsides" rules="rows"
|-
! ''' Deklarationsort '''
! ''' Gültigkeitsbereich'''
|-
| style="text-align: left; vertical-align: top;" |
Deklarationsabschnitt eines Programms, einer Funktion oder einer Prozedur
| style="text-align: left; vertical-align: top;" |
Von der Deklaration bis zum Ende des aktuellen Blocks, einschließlich aller verschachtelten Blöcke.
|-
| style="text-align: left; vertical-align: top;" |
interface-Abschnitt einer Unit
| style="text-align: left; vertical-align: top;" |
Von der Deklaration bis zum Ende der Unit sowie in allen anderen Units und Programmen, die diese Unit einbinden (siehe [[Programme und Units|Programme und Units (Delphi)]].)
|-
| style="text-align: left; vertical-align: top;" |
implementation-Abschnitt einer Unit, aber nicht innerhalb des Blocks einer Funktion oder Prozedur
| style="text-align: left; vertical-align: top;" |
Von der Deklaration bis zum Ende der Unit. Der Bezeichner ist für alle Funktionen und Prozeduren in der Unit verfügbar (einschließlich des initialization- und finalization-Abschnitts, falls vorhanden).
|-
| style="text-align: left; vertical-align: top;" |
Definition eines Record-Typs (d. h. der Bezeichner ist der Name eines Record-Feldes)
| style="text-align: left; vertical-align: top;" |
Von der Deklaration bis zum Ende der Definition des Record-Typs (siehe "Records" in [[Strukturierte Typen (Delphi)|Stukturierte Typen (Delphi)]].)
|-
| style="text-align: left; vertical-align: top;" |
Definition einer Klasse (d. h. der Bezeichner ist der Name einer Datenfeldeigenschaft oder Methode der Klasse)
| style="text-align: left; vertical-align: top;" |
Von der Deklaration bis zum Ende der Klassentypdefinition sowie in allen Nachkommen der Klasse und den Blöcken aller in der Klasse definierten Methoden und deren Nachkommen (siehe [[Klassen und Objekte (Delphi)|Klassen und Objekte (Delphi)]].)
|}

===Namenskonflikte===

Ein Block, der einen anderen einschließt, wird als äußerer Block bezeichnet, der eingeschlossene Block als innerer Block. Ein im äußeren Block deklarierter Bezeichner kann in einem inneren Block redeklariert werden. Die innere Deklaration setzt die äußere außer Kraft und bestimmt die Bedeutung, die der Bezeichner im inneren Block hat. Wenn Sie beispielsweise im '''interface'''-Abschnitt einer Unit eine Variable mit dem Namen MaxValue und dann in dieser Unit eine weitere Variable gleichen Namens in einem Funktionsblock deklarieren, beziehen sich alle nicht qualifizierten Vorkommen von MaxValue im Funktionsblock auf die lokale Deklaration. Ähnlich erzeugt eine Funktion, die innerhalb einer anderen Funktion deklariert wird, einen neuen, inneren Gültigkeitsbereich, in dem Bezeichner der äußeren Funktion lokal redeklariert werden können.

Die Verwendung mehrerer Units kompliziert die Definition des Gültigkeitsbereichs. Jede Unit in einer '''uses'''-Klausel ergibt einen neuen Gültigkeitsbereich, der die anderen verwendeten Units und das '''Programm''' oder die '''Unit''' einschließt, die die '''uses'''-Klausel enthält. Die erste Unit in einer '''uses'''-Klausel entspricht dem äußersten, die letzte Unit dem innersten Gültigkeitsbereich. Ist derselbe Bezeichner in den '''interface'''-Abschnitten mehrerer Units deklariert, bezieht sich eine nicht qualifizierte Referenz auf den Bezeichner auf die Deklaration im innersten Gültigkeitsbereich, d. h. auf die Deklaration in der Unit, in der die Referenz selbst auftritt. Ist der Bezeichner nicht in dieser Unit deklariert, bezieht sich die Referenz auf die letzte Unit in der uses-Klausel, die den Bezeichner deklariert.

Die Units System und SysInit werden automatisch von jedem Programm und von jeder Unit verwendet. Für die in System enthaltenen Deklarationen sowie für die vom Compiler automatisch erkannten vordefinierten Typen, Routinen und Konstanten gilt immer der äußerste Gültigkeitsbereich.

Mit qualifizierten Bezeichnern (siehe "Qualifizierte Bezeichner" in [[Grundlegende syntaktische Elemente (Delphi)|Grundlegende syntaktische Elemente (Delphi)]]) oder mit '''with'''-Anweisungen (siehe "with-Anweisungen" weiter oben) können diese Regeln für den Gültigkeitsbereich außer Kraft gesetzt und lokale Deklarationen umgangen werden.

==Siehe auch==

*[[Grundlegende syntaktische Elemente (Delphi)|Grundlegende syntaktische Elemente (Delphi)]]
*[[Ausdrücke (Delphi)|Ausdrücke ({{Delphi}})]]
*[[Überblick über Datentypen (Delphi)|Überblick über Datentypen ({{Delphi}})]]

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

[[en:Declarations and Statements (Delphi)]]
[[fr:Déclarations et instructions (Delphi)]]
[[ja:宣言と文（Delphi）]]

Vorlage:CompilerVersion

2023-11-04T01:12:48Z

Nicolas.rios:

{{ #switch: {{RadstudioVersion|{{{1|{{RadstudioVersion}}}}}}}
| {{Version|Olympus}} = 35
| {{Version|Denali}} = 34
| {{Version|Rio}} = 33
| {{Version|Carnival}} = 33
| {{Version|Tokyo}} = 32
| {{Version|Godzilla}} = 32
| {{Version|London}} = 31
| {{Version|Seattle}} = 30
| {{Version|XE8}} = 29
| {{Version|XE7}} = 28
}}<noinclude>

[[Category:Datenvorlagen]]
[[Category:Durch Hauptversionsänderungen betroffene Vorlagen]]

Vorlage:FireMonkeyVersion

2023-11-04T01:11:38Z

Nicolas.rios:

{{ #switch: {{RadstudioVersion|{{{1|{{RadstudioVersion}}}}}}}
| {{Version|Olympus}} = 280
| {{Version|Denali}} = 270
| {{Version|Rio}} = 260
| {{Version|Godzilla}} = 250
| {{Version|Berlin}} = 24
| {{Version|Seattle}} = 23
}}<noinclude>

[[Category:Datenvorlagen]]
[[Category:Durch Hauptversionsänderungen betroffene Vorlagen]]

Vorlage:PackageVersion

2023-11-04T01:10:28Z

Nicolas.rios:

{{ #switch: {{RadstudioVersion|{{{1|{{RadstudioVersion}}}}}}}
| {{Version|Seattle}} = 230
| {{Version|Berlin}} = 240
| {{Version|Godzilla}} = 250
| {{Version|Rio}} = 260
| {{Version|Denali}} = 270
| {{Version|Olympus}} = 280
}}<noinclude>

See [[rad_en:Compiler Versions]].

[[Category:Datenvorlagen]]
[[Category:Durch Hauptversionsänderungen betroffene Vorlagen]]

Vorlage:RTLVersion

2023-11-04T01:09:42Z

Nicolas.rios:

{{ #switch: {{RadstudioVersion|{{{1|{{RadstudioVersion}}}}}}}
| {{Version|XE7}} = 28
| {{Version|XE8}} = 29
| {{Version|Seattle}} = 30
| {{Version|Berlin}} = 31
| {{Version|Godzilla}} = 32
| {{Version|Tokyo}} = 32
| {{Version|Carnival}} = 33
| {{Version|Rio}} = 33
| {{Version|Denali}} = 34
| {{Version|Olympus}} = 35
}}<noinclude>

[[Category:Datenvorlagen]]
[[Category:Durch Hauptversionsänderungen betroffene Vorlagen]]

Unicode in RAD Studio

2023-10-12T20:10:44Z

Nicolas.rios: RS-119900

__TOC__
{{Parent|Einführung in RAD Studio}}

In {{Product}} werden Unicode-basierte Strings verwendet: der Typ <code>string</code> ist nun ein Unicode-String ([[lib_de:System.UnicodeString|System.UnicodeString]]) anstatt eines ANSI-Strings. Dieses Thema beschreibt die korrekte Behandlung von Strings.

Mit den Typen [[lib_de:System.AnsiStringT|AnsiString]] und [[lib_de:System.WideString|WideString]] werden ANSI- bzw. Wide-Strings verwendet.

{{Product}} ist vollständig Unicode-kompatibel, und für diejenigen Teile Ihres Quelltextes, die die String-Behandlung betreffen, sind einige Änderungen möglicherweise erforderlich. Es wurde aber versucht, diese Änderungen auf ein Minimum zu beschränken. Es wurden zwar neue Datentypen eingeführt, aber vorhandene Datentypen wurden beibehalten und arbeiten genauso wie bisher. Ausgehend von dem mit der Unicode-Konvertierung im eigenen Haus gemachten Erfahrungen, sollten vorhandene Anwendungen ziemlich reibungslos migriert werden können.

'''Weitere Ressourcen:'''

* [https://www.embarcadero.com/images/dm/technical-papers/delphi-unicode-migration.pdf {{Delphi}} Unicode Migration for Mere Mortals: Stories and Advice from the Front Lines von Cary Jensen (EN)]
* [https://www.embarcadero.com/rad-in-action/migration-upgrade-center#unicode Unicode Migration Resources for Delphi, C++Builder and RAD Studio (EN)]

==Vorhandene String-Typen==

Die bereits vorhandenen Datentypen <code>[[lib_de:System.AnsiStringT|AnsiString]]</code> und <code>[[lib_de:System.WideString|System.WideString]]</code> arbeiten genauso wie bisher.

Bei kurzen Strings gibt es hinsichtlich der Funktionalität ebenfalls keine Änderungen. Beachten Sie bitte, dass kurze Strings auf 255 Zeichen beschränkt sind und nur einen Zeichenzähler und Einzelbyte-Zeichendaten enthalten. Sie umfassen keine Codeseiteninformationen. Ein kurzer String kann in Ausnahmenfällen UTF-8-Daten für eine bestimmte Anwendung enthalten.

===<code>AnsiString</code>===

'''string''' war früher ein Alias für [[lib_de:System.AnsiString|AnsiString]]. Die folgende Tabelle zeigt die Position der Felder im früheren Format von <code>AnsiString</code>:

'''Früheres Format des Datentyps <code>AnsiString</code>: '''

{| border="1" frame="hsides" rules="rows"
|-
! '''Referenzzähler '''
! '''Länge '''
! '''String-Daten (auf Byte-Größe) '''
! ''' Nullterminiert'''
|-
| style="text-align: left; vertical-align: top;" |
-8
| style="text-align: left; vertical-align: top;" |
-4
| style="text-align: left; vertical-align: top;" |
0
| style="text-align: left; vertical-align: top;" |
Length
|}

In {{Product}} wurde das Format von [[lib_de:System.AnsiString|AnsiString]] geändert. Zwei neue Felder (<code>CodePage</code> und <code>ElemSize</code>) wurden hinzugefügt. Dadurch ist das Format von [[lib_de:System.AnsiString|AnsiString]] identisch mit dem neuen Typ [[lib_de:System.UnicodeString|UnicodeString]]. (Weitere Informationen zum neuen Format finden Sie unter [[Interne Datenformate (Delphi)#Lange String-Typen|Lange String-Typen]].)

===<code>WideString</code>===

<code>[[lib_de:System.WideString|System.WideString]]</code> wurde früher für Unicode-Zeichendaten verwendet. Das Format von <code>WideString</code> entspricht im Wesentlichen dem von Windows <code>BSTR</code>. <code>WideString</code> sollte weiterhin in COM-Anwendungen verwendet werden.

==Neuer String-Typ: UnicodeString==

Der <code>string</code>-Typ in {{Product}} ist der Typ <code>[[lib_de:System.UnicodeString|UnicodeString]]</code>.

In {{Delphi}} sind <code>Char</code>- und <code>PChar</code>-Typen jetzt <code>WideChar</code>- bzw. <code>PWideChar</code>-Typen.

{{Note|Dies ist ein Unterschied zu Versionen vor 2009. In früheren Versionen war <code>string</code> ein Alias für <code>AnsiString</code>, und die Typen <code>Char</code> und <code>PChar</code> waren <code>AnsiChar</code> bzw. <code>PAnsiChar</code>.}}

In C++ steuert die Option '''[[C++ (Gemeinsame Optionen)|_TCHAR entspricht]]''' die Definition von <code>_TCHAR</code>, das entweder <code>wchar_t</code> oder <code>char</code> sein kann.

[[Frameworks und Bibliotheken|{{Product}} Frameworks und Bibliotheken]] verwenden jetzt den Typ <code>UnicodeString</code> und repräsentiert String-Werte nicht mehr als Einzelbyte- oder MBCS-Strings.

'''Format des Datentyps <code>UnicodeString</code>: '''

{| border="1" frame="hsides" rules="rows"
|-
! '''Codeseite'''
! '''Elementgröße'''
! '''Referenzzähler '''
! '''Länge '''
! '''String-Daten (auf Elementgröße) '''
! ''' Nullterminiert'''
|-
| style="text-align: left; vertical-align: top;" |
-12
| style="text-align: left; vertical-align: top;" |
-10
| style="text-align: left; vertical-align: top;" |
-8
| style="text-align: left; vertical-align: top;" |
-4
| style="text-align: left; vertical-align: top;" |
0
| style="text-align: left; vertical-align: top;" |
Length * elementsize
|}

<code>UnicodeString</code> kann als die folgende {{Delphi}}-Struktur dargestellt werden:

type StrRec = record
CodePage: Word;
ElemSize: Word;
refCount: Integer;
Len: Integer;
case Integer of
1: array[0..0] of AnsiChar;
2: array[0..0] of WideChar;
end;

<code>UnicodeString</code> fügt die Felder für die Codeseite <code>CodePage</code> und die Elementgröße <code>ElemSize</code> hinzu, die den Inhalt des Strings beschreiben. <code>UnicodeString</code> ist zu allen anderen String-Typen zuweisungskompatibel. Zuweisungen zwischen <code>AnsiString</code> und <code>UnicodeString</code> führen aber weiterhin die entsprechenden Auf- oder Abkonvertierungen durch. Bitte beachten Sie, dass eine Zuweisung eines <code>UnicodeString</code>-Typs zu einem <code>AnsiString</code>-Typ nicht empfohlen wird und zu Datenverlusten führen kann.

Beachten Sie, dass <code>AnsiString</code> ebenfalls über die Felder <code>CodePage</code> und <code>ElemSize</code> verfügt.

<code>UnicodeString</code>-Daten sind aus folgenden Gründen in UTF-16 codiert:

* UTF-16 entspricht dem zugrunde liegenden Format des Betriebssystems.
* UTF-16 reduziert zusätzliche explizite/implizite Konvertierungen.
* Es bietet bei Aufrufen der Windows-API eine bessere Performanz.
* Es müssen keine Betriebssystem Konvertierungen mit UTF-16 durchgeführt werden.
* Der Basic Multilingual Plane (BMP) enthält bereits die Schriftzeichen fast aller aktiven Sprachen der Welt und passt in ein einzelnes UTF-16 <code>Char</code> (16 Bits).
* Unicode-Surrogatpaare entsprechen dem Multibyte-Zeichensatz (MBCS), sind aber berechenbarer und Standard.
* <code>UnicodeString</code> kann für das Marshalling von COM-Interfaces verlustlose implizite Konvertierungen in und aus <code>WideString</code> bereitstellen.

Zeichen in UTF-16 können 2 oder 4 Byte groß sein, daher ist die Anzahl der Elemente in einem String nicht notwendigerweise gleich der Anzahl der Zeichen. Wenn der String nur aus BMP-Zeichen besteht, ist die Anzahl der Zeichen und der Elemente identisch.

<code>UnicodeString</code> bietet die folgenden Vorteile:

* UnicodeString verfügt über einen Referenzzähler.
* UnicodeString löst ein Problem von Altanwendungen in {{CBuilder}}.
* Durch die Aufnahme von Codierungsinformationen (Codeseite) in <code>AnsiString</code> wird das Risiko eines möglichen Datenverlustes bei impliziten Typumwandlungen reduziert.
* Der Compiler stellt sicher, dass die Daten korrekt sind, bevor die Daten verändert werden.

<code>WideString</code> verfügt über keinen Referenzzähler, deshalb ist <code>UnicodeString</code> für die meisten Anwendungstypen flexibler und effizienter (<code>WideString</code> eignet sich eher für COM).

===Indizierung===

Instanzen von <code>UnicodeString</code> können Zeichen indizieren. Die Indizierung ist 1-basiert, genau wie bei <code>AnsiString</code>. Sehen Sie sich den folgenden Quelltext an:

var C: Char;
S: string;
begin
...
C := S[1];
...
end;

In einem Fall, wie dem oben dargestellten, muss der Compiler sicher stellen, dass die Daten in <code>S</code> in einem geeigneten Format vorliegen. Der Compiler erzeugt entsprechenden Code, damit Zuweisungen zu String-Elementen den richtigen Typ haben und die Instanz eindeutig ist (d.h., dass sie einen Referenzzähler von 1 hat). Dies geschieht über einen Aufruf der Funktion <code>UniqueString</code>. Für den obigen Quelltext muss der Compiler, weil der String Unicode-Daten enthalten könnte, vor der Indizierung im Zeichen-Array auch die passende <code>UniqueString</code>-Funktion aufrufen.
{{f|vcl|

==={{CBuilder}}===

Die Klasse <code>UnicodeString</code> in {{CBuilder}} ermöglicht eine {{Delphi}}-ähnliche automatische Konvertierungssemantik. Bei vorhandenen VCL-Ereignisbehandlungsroutinen, die <code>AnsiString</code>-Parameter erwarten, ist dies ziemlich transparent, weil Konvertierungen bei Bedarf ausgeführt werden. So können Anwender allmählich, nach ihrem eigenen Zeitplan, zu vollständigem Unicode migrieren.

In manchen Situationen führt diese automatische Konvertierung aber zu unerwünschten Ergebnissen. Der VCL-String-Typ ist jetzt <code>UnicodeString</code> und nicht mehr <code>AnsiString</code>. Aus Gründen der Abwärtskompatibilität gibt die Methode <code>UnicodeString::t_str()</code> 'const char* anstelle von <code>const wchar_t*</code> zurück, indem die Größe der Wide-Daten der <code>UnicodeString</code>-Instanz reduziert wird. Dies kann zu unerwartetem Verhalten führen, weil der Quellcode einen Aufruf von <code>t_str()</code> nicht akzeptieren könnte, da die zugrunde liegenden Daten fehlerhaft werden könnten. Dieses Verhalten wird in Quellcode deutlich, der die zugrunde liegenden Daten in der Benutzeroberfläche, wie z.B. in <code>TListItem</code>, anzeigt.

In dem folgenden Beispiel sind die nach dem Aufruf von <code>t_str()</code> in der letzten Zeile der Methode in <code>TListView</code> angezeigten Daten fehlerhaft:

void ProcessSelectedItem(const char* item);

void __fastcall TForm6::ListView1DblClick(TObject *Sender)
{
int index = ListView1->Selected->Index;
TListItem *ClassItem = ListView1->Items->Item[index];
ProcessSelectedItem(ClassItem->Caption.t_str());
}

}}

==Compilerbedingungen==

In {{Delphi}} als auch in {{CBuilder}} können Sie Bedingungen setzen, um im selben Quelltext Unicode- und Nicht-Unicode-Code zuzulassen.

==={{Delphi}}===

{$IFDEF UNICODE}

==={{CBuilder}}===

#ifdef _DELPHI_STRING_UNICODE

==Überblick über die Änderungen==

* <code>string</code> wird nun <code>UnicodeString</code> und nicht <code>AnsiString</code> zugeordnet.
* <code>Char</code> wird nun <code>WideChar</code> (2 Byte, nicht 1 Byte) zugeordnet und ist ein UTF-16-Zeichen.
* <code>PChar</code> wird nun <code>PWideChar</code> zugeordnet.
* In C++ wird <code>System::String</code> nun der Klasse <code>UnicodeString</code> zugeordnet.

==Überblick über Unverändertes==

* <code>AnsiString</code>.
* <code>WideString</code>.
* <code>AnsiChar</code>, <code>PAnsiChar</code>.
* <code>WideChar</code>, <code>PWideChar</code>
* Implizite Konvertierungen funktionieren weiterhin.
* <code>AnsiString</code> verwendet die aktive Codeseite des Benutzers.

==Von der Zeichengröße unabhängige Quelltextkonstrukte==

Die folgenden Operationen sind von der Zeichengröße unabhängig:

* String-Verkettung:
** <code><string var> + <string var></code>
** <code><string var> + <literal></code>
** <code><literal> + <literal> </code>
** <code>Concat(<string> , <string>)</code>

* Standard-String-Funktionen:
** <code>Length(<string>)</code> gibt die Anzahl der char-Elemente zurück. Diese Anzahl muss nicht unbedingt gleich der Anzahl der Byte sein. Beachten Sie bitte, dass die Funktion <code>SizeOf</code> die Anzahl der Byte zurückgibt, was bedeutet, dass sich der Rückgabewert für <code>SizeOf</code> von <code>Length</code> unterscheiden kann.
** <code>Copy(<String>, <Start>, <Länge>)</code> gibt einen Teilstring in <code>Char</code>-Elementen zurück.
** <code>Pos(<Teilstring>, <String>)</code> gibt den Index des ersten <code>Char</code>-Elements zurück.

* Operatoren:
** <code><String> <Vergleichsoperator> <String> </code>
** <code>CompareStr() </code>
** <code>CompareText() </code>
** <code> ... </code>

*<code>FillChar(<Struktur oder Arbeitsspeicher>)</code>
** <code>FillChar(Rect, SizeOf(Rect), #0)</code>
** <code>FillChar(WndClassEx, SizeOf(TWndClassEx), #0)</code>. Bitte beachten: <code>WndClassEx.cbSize := SizeOf(TWndClassEx);</code>
* Windows-API
** Bei API-Aufrufen werden standardmäßig deren <code>WideString</code>-(“W”)-Versionen verwendet.
** Die <code>PChar(<String>)</code>-Typumwandlung hat eine identische Semantik.

Beispiel für <code>GetModuleFileName</code>:

function ModuleFileName(Handle: HMODULE): string;
var Buffer: array[0..MAX_PATH] of Char;
begin
SetString(Result, Buffer,
GetModuleFileName(Handle, Buffer, Length(Buffer)));
end;

Beispiel für <code>GetWindowText</code>:

function WindowCaption(Handle: HWND): string;
begin
SetLength(Result, 1024);
SetLength(Result,
GetWindowText(Handle, PChar(Result), Length(Result)));
end;

Beispiel für die Zeichenindizierung von Strings:

function StripHotKeys(const S: string): string;
var I, J: Integer;
LastChar: Char;
begin
SetLength(Result, Length(S));
J := 0;
LastChar := #0;
for I := 1 to Length(S) do
begin
if (S[I] <> '&') or (LastChar = '&') then
begin
Inc(J);
Result[J] := S[I];
end;
LastChar := S[I];
end;
SetLength(Result, J);
end;

==Von der Zeichengröße abhängige Quelltextkonstrukte==

Einige Operationen sind von der Zeichengröße abhängig. Die Funktionen und Features in der folgenden Liste enthalten - sofern möglich - auch eine “portierbare” Version. Sie können Ihren Quelltext auch in der portierbaren Version neu schreiben, er funktioniert sowohl mit <code>AnsiString</code>- als auch mit <code>UnicodeString</code>-Variablen.

* <code>SizeOf(<Char-Array>)</code> - portierbare Version: <code>Length(<Char-Array>)</code>.
* <code>Move(<Char-Puffer>... CharCount)</code> - portierbare Version: <code>Move(<Char-Puffer> ... CharCount * SizeOf(Char))</code>.
* Stream Read/Write - portierbare Version: <code>AnsiString</code>, <code>SizeOf(Char)</code> oder die Klasse <code>TEncoding</code>.
* <code>FillChar(<Char-Array>, <Größe>, <AnsiChar>)</code> - verwenden Sie zum Auffüllen mit <code>#0</code><code>*SizeOf(Char)</code> oder die portierbare <code>StringOfChar</code>-Funktion.
* <code>GetProcAddress(<Modul>, <PAnsiChar>)</code> - verwenden Sie die überladene Funktion, die ein <code>PWideChar</code> übernimmt.
* Typumwandlung oder die Verwendung von <code>PChar</code> für die Zeigerarithmetik - fügen Sie am Beginn der Datei <code>{IFDEF PByte = PChar}</code> ein, wenn Sie <code>PChar</code> für die Zeigerarithmetik verwenden. Oder verwenden Sie die {{Delphi}}-Compiler-Direktive <code>{POINTERMATH <ON|OFF>}</code>, um die Zeigerarithmetik für alle typisierten Zeiger zu aktivieren, damit das Inkrementieren/Dekrementieren nach Elementgröße ausgeführt wird.

==Set of Char-Konstrukte==

Sie müssen diese Konstrukte wahrscheinlich ändern.

* <Char> in <set of <code>AnsiChar</code>> - Codeerzeugung ist korrekt (<code>>#255</code>-Zeichen sind nie in der Menge enthalten). Der Compiler gibt die Warnung <code>WideChar in Set-Operationen verkürzt</code> aus. Abhängig von Ihrem Quelltext können Sie die Warnung gefahrlos deaktivieren. Verwenden Sie als Alternative die Funktion <code>CharinSet</code>.
* <Char> in <code>LeadBytes</code> - die globale Menge <code>LeadBytes</code> ist für MBCS-ANSI-Gebietseinstellungen vorgesehen. UTF-16 arbeitet weiterhin mit einem "Führungszeichen" (lead char) (<code>#$D800 - #$DBFF</code> sind hohe Surrogate, <code>#$DC00 - #$DFFF</code> niedrige Surrogate). Verwenden Sie, um dies zu ändern, die überladene Funktion <code>IsLeadChar</code>. Die ANSI-Version prüft auf <code>LeadBytes</code>. Die <code>WideChar</code>-Version prüft, ob es sich um ein hohes/niedriges Surrogat handelt.
* Zeichenklassifikation - verwenden Sie die statische Klasse <code>TCharacter</code>. Die Unit <code>[[lib_de:System.Character|Character]]</code> enthält Funktionen für die Klassifikation von Zeichen: <code>IsDigit</code>, <code>IsLetter</code>, <code>IsLetterOrDigit</code>, <code>IsSymbol</code>, <code>IsWhiteSpace</code>, <code>IsSurrogatePair</code> usw. Diese Funktionen basieren auf Tabellendaten der Unicode.org.

==Achtung bei diesen Konstrukten==

Sie sollten die folgenden problematischen Codekonstrukte untersuchen:

* Typumwandlungen, die den Typ verbergen:
** <code>AnsiString(Pointer(foo))</code>
** Überprüfen Sie, was beabsichtigt war.
* Verdächtige Typumwandlungen erzeugen eine Warnung:
** <code>PChar(<AnsiString var>)</code>
** <code>PAnsiChar(<UnicodeString var>)</code>
* Direktes Erstellen, Manipulieren oder Zugreifen auf interne Strukturen. Einige dieser Strukturen, wie z.B. <code>AnsiString</code>, wurden intern verändert, daher sind diese Aktionen unsicher. Verwenden Sie die Funktionen <code>StringRefCount</code>, <code>StringCodePage</code>, <code>StringElementSize</code> und andere, um String-Informationen zu ermitteln.

==Laufzeitbibliothek==

* Überladungen. Für Funktionen, die <code>PChar</code> übernehmen, gibt es jetzt <code>PAnsiChar</code>- und <code>PWideChar</code>-Versionen, damit die richtige Funktion aufgerufen wird.
*<code>AnsiXXX</code>-Funktionen sind möglich:
**<code>[[lib_de:System.SysUtils|SysUtils.AnsiXXXX]]</code>-Funktionen, wie z.B. <code>[[lib_de:System.SysUtils.AnsiCompareStr|AnsiCompareStr]]</code>:
*** Werden weiterhin mit <code>string</code> deklariert und verwenden <code>[[lib_de:System.UnicodeString|UnicodeString]]</code>.
*** Bieten eine bessere Abwärtskompatibilität (Quelltext muss nicht geändert werden).
** Die <code>AnsiXXXX</code>-Funktionen der Unit <code>[[lib_de:System.AnsiStrings|AnsiStrings]]</code> bieten dieselben Möglichkeiten wie die <code>[[lib_de:System.SysUtils|SysUtils.AnsiXXXX]]</code>-Funktionen, arbeiten aber nur mit <code>AnsiString</code>. Die <code>AnsiStrings.AnsiXXXX</code>-Funktionen bieten auch eine bessere Performanz für einen <code>[[lib_de:System.AnsiStringT|AnsiString]]</code> als die <code>SysUtils.AnsiXXXX</code>-Funktionen, die sowohl mit <code>[[lib_de:System.AnsiStringT|AnsiString]]</code> als auch mit <code>[[lib_de:System.UnicodeString|UnicodeString]]</code> arbeiten, weil keine impliziten Konvertierungen ausgeführt werden.
*<code>[[lib_de:System.Write|Write]]/[[lib_de:System.Writeln|Writeln]]</code> und <code>[[lib_de:System.Read|Read]]/[[lib_de:System.Readln|Readln]]</code>:
** Konvertieren weiterhin in/aus ANSI/OEM-Codeseiten.
** Die Konsole ist meist sowieso ANSI oder OEM.
** Bieten eine bessere Kompatibilität zu Altanwendungen.
** TFDD (Gerätetreiber für Textdateien):
*** <code>[[lib_de:System.TTextRec|TTextRec]]</code> und <code>[[lib_de:System.TFileRec|TFileRec]]</code>.
*** Dateinamen sind <code>WideChar</code>, aber wie oben sind die Daten ANSI/OEM.
** Verwenden Sie <code>[[lib_de:System.SysUtils.TEncoding|TEncoding]]</code> und <code>[[lib_de:System.Classes.TStrings|TStrings]]</code> für die Unicode-Dateieingabe-/ausgabe.

* <code>PByte</code> - deklariert mit <code>[[Zeigermathematik (Delphi)|$POINTERMATH ON]]</code>. Dadurch wird die Array-Indizierung und die Zeigermathematik wie bei <code>PAnsiChar</code> ermöglicht.

* String-Informationsfunktionen:
** <code>[[lib_de:System.StringElementSize|StringElementSize]]</code> gibt die aktuelle Datengröße zurück.
** <code>[[lib_de:System.StringCodePage|StringCodePage]]</code> gibt die Codeseite von String-Daten zurück.
** <code>[[lib_de:System.StringRefCount|System.StringRefCount]]</code> gibt den Referenzzähler zurück.

* Die RTL stellt Hilfsfunktionen bereit, mit denen Anwender explizite Konvertierungen zwischen Codeseiten und Elementgrößenumwandlungen vornehmen können. Wenn Entwickler die Funktion <code>Move</code> für ein Zeichen-Array verwenden, können sie keine Annahme über die Elementgröße machen. Dieses Problem kann reduziert werden, indem sichergestellt wird, dass alle R-Wert-Referenzen korrekte Aufrufe der RTL erzeugen, um korrekte Elementgrößen zu gewährleisten.

==Komponenten und Klassen==

* <code>TStrings</code>: Speichert <code>UnicodeString</code> intern (bleibt als <code>string</code> deklariert).
* <code>TWideStrings</code> (wird eventuell bald nicht mehr unterstützt) ist unverändert. Verwendet <code>WideString</code> (BSTR) intern.
*<code>TStringStream</code>
** Wurde neu geschrieben – hat per Vorgabe die ANSI-Standardcodierung für interne Speicherung.
** Die Codierung kann überschrieben werden.
** Ziehen Sie zum Erstellen eines Strings aus verschiedenen Teilen <code>TStringBuilder</code> anstelle von <code>TStringStream</code> in Betracht.
*<code>[[lib_de:System.SysUtils.TEncoding|TEncoding]]</code>
** Verwendet standardmäßig die aktive Codeseite des Anwenders.
** Unterstützt UTF-8.
** Unterstützt UTF-16, Big und Little Endian.
** Unterstützt Byte Order Mark (BOM).
** Sie können für benutzerspezifische Codierungen abgeleitete Klassen erstellen.

* Komponenten-Streaming (Text-DFM-Dateien):
** Sind vollständig abwärtskompatibel.
** Verwenden für das Streaming nur UTF-8, wenn der Komponententyp, die Eigenschaft oder der Name keine ASCII-7-Zeichen enthält.
** String-Eigenschaftswerte werden weiterhin mit dem “#”-Escaped-Format in den Stream gestellt.
** Lassen auch Werte als UTF-8 zu (noch nicht geklärtes Problem).
** Nur die Änderung im Binärformat ist für UTF-8-Daten für Komponentennamen, Eigenschaften und Typnamen möglich.

==Byte Order Mark==

Das Byte Order Mark (BOM) sollte zur Angabe der Codierung Dateien hinzugefügt werden:

* UTF-8 verwendet <code>EF BB BF</code>.
* UTF-16 Little Endian verwendet <code>FF FE</code>.
* UTF-16 Big Endian verwendet <code>FE FF</code>.

==Schritte zum Aktivieren von Unicode in Anwendungen==

Sie müssen die folgenden Schritte ausführen:

# Überprüfen von Char- und String-bezogenen Funktionen
# Neu erzeugen der Anwendung
# Überprüfen von Surrogatpaaren
# Überprüfen der String-Nutzdaten

Weitere Einzelheiten finden Sie unter [[Anwendungen für Unicode anpassen|Anwendungen für Unicode anpassen]].

==Neue Warnungen des {{Delphi}}-Compilers==

Dem {{Delphi}}-Compiler wurden neue Warnungen hinzugefügt, die sich auf mögliche Fehler bei der Typumwandlung beziehen (z.B. beim Umwandeln eines <code>UnicodeString</code>- oder <code>WideString</code>-Strings in <code>AnsiString</code> oder <code>AnsiChar</code>). Wenn Sie eine Anwendung nach Unicode konvertieren, sollten Sie die Warnungen 1057 und 1058 aktivieren, die Sie beim Auffinden von Problembereichen in Ihrem Quelltext unterstützen.

* '''[[W1050 In Set-Ausdruck WideChar auf Byte-Char verringert (Delphi)|W1050: WideChar in Set-Ausdrücken auf ByteChar verkürzt (Delphi)]]'''. "Set of char" definiert in Win32 eine Menge über den gesamten Bereich des Char-Typs. Da Char in Win32 ein Typ auf Byte-Größe ist, wird dadurch eine Menge mit maximaler Größe und mit 256 Elementen definiert. In .NET ist Char ein Typ auf Word-Größe, dessen Bereich (0..65535) die Kapazität des Mengen-Typs überschreitet.
* '''[[W1057 Implizite String-Umwandlung von '%s' zu '%s' (Delphi)|W1057: Implizite String-Umwandlung von '%s' zu '%s' (IMPLICIT_STRING_CAST)]]''' Wird ausgegeben, wenn der Compiler einen Fall findet, bei dem ein <code>AnsiString</code> (oder ein <code>AnsiChar</code>) in eine Form von Unicode (einen <code>UnicodeString</code> oder einen <code>WideString</code>) implizit konvertiert werden muss. (HINWEIS: Diese Warnung ist eventuell per Vorgabe aktiviert).
* '''[[W1058 Implizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (Delphi)|W1058: Implizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (IMPLICIT_STRING_CAST_LOSS)]]''' Wird ausgegeben, wenn der Compiler einen Fall findet, bei dem eine Form von Unicode (ein <code>UnicodeString</code> oder ein <code>WideString</code>) in einen <code>AnsiString</code> (oder ein <code>AnsiChar</code>) implizit konvertiert werden muss. Dies ist eine potenziell verlustreiche Umwandlung, weil es Zeichen in dem String geben kann, die auf der Codeseite, in die der String umgewandelt wird, nicht repräsentiert werden können. (HINWEIS: Diese Warnung ist eventuell per Vorgabe aktiviert).
* '''[[W1059 Explizite String-Umwandlung von '%s' zu '%s' (Delphi)|W1059: Explizite String-Umwandlung von '%s' zu '%s' (EXPLICIT_STRING_CAST)]]''' Wird ausgegeben, wenn der Compiler auf einen Fall trifft, bei dem der Programmierer explizit einen <code>AnsiString</code> (oder ein <code>AnsiChar</code>) in eine Form von Unicode (<code>UnicodeString</code> oder <code>WideString</code>) umwandelt. (HINWEIS: Diese Warnung ist standardmäßig deaktiviert und sollte nur zum Auffinden eventueller Probleme verwendet werden.)
* '''[[W1060 Explizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (Delphi)|W1060: Explizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (EXPLICIT_STRING_CAST_LOSS)]]''' Wird ausgegeben, wenn der Compiler einen Fall findet, bei dem der Programmierer explizit eine Form von Unicode (<code>UnicodeString</code> oder <code>WideString</code>) in einen <code>AnsiString</code> (oder ein <code>AnsiChar</code>) konvertiert. Dies ist eine potenziell verlustreiche Umwandlung, weil es Zeichen in dem String geben kann, die auf der Codeseite, in die der String umgewandelt wird, nicht repräsentiert werden können. (HINWEIS: Diese Warnung ist standardmäßig deaktiviert und sollte nur zum Auffinden eventueller Probleme verwendet werden.)

==Empfehlungen==

* Belassen Sie die Quelltextdaten im UTF-8-Format:
** Dateien können im ANSI-Format bleiben, wenn der Quelltext mit der korrekten Codeseite compiliert wird. Wählen Sie ({{Menu|Projekt > Optionen > C++-Compiler > [[C++-Compiler Erweitert|Erweitert]]}} und verwenden Sie die Option "Codeseite" unter '''Weitere Optionen''', um die korrekte Codeseite festzulegen.
** Schreiben Sie in die Quelltextdatei ein UTF-8 BOM. Stellen Sie sicher, dass Ihr Versionsverwaltungssystem diese Dateien unterstützt.
* Führen Sie in der IDE ein Refactoring durch, wenn der Quelltext <code>AnsiString</code> oder <code>AnsiChar</code> sein muss (der Quelltext ist weiterhin portierbar).
* Statische Überprüfung des Quelltextes:
** Gibt der Quelltext Daten nur weiter?
** Führt der Quelltext eine einfache Zeichenindizierung durch?
* Beachten Sie alle Warnungen (es könnten Fehler daraus werden):
** Verdächtige Zeigerumwandlungen.
** Implizite/explizite Umwandlungen.
* Bestimmen Sie den Zweck des Quelltextes.
** Verwendet der Quelltext einen String (<code>AnsiString</code>) als ein dynamisches Byte-Array? Wenn ja, dann setzen Sie stattdessen den portierbaren Typ <code>TBytes</code> (<code>Byte</code>-Array) ein.
** Wird mit einer <code>PChar</code>-Umwandlung die Zeigerarithmetik aktiviert? Wenn ja, wandeln Sie stattdessen in <code>PByte</code> um, und aktivieren Sie <code>$POINTERMATH ON</code>.

==Siehe auch==

* [[UTF-8-Konvertierungsroutinen|UTF-8-Konvertierungsroutinen]]
* [http://www.embarcadero.com/images/dm/technical-papers/delphi-unicode-migration.pdf {{Delphi}} Unicode Migration for Mere Mortals: Stories and Advice from the Front Lines von Cary Jensen (EN)]
* [http://edn.embarcadero.com/article/38437 {{Delphi}} in a Unicode World Part I: What is Unicode, Why do you need it, and How do you work with it in {{Delphi}}? (EN)]
* [http://edn.embarcadero.com/article/38498 {{Delphi}} in a Unicode World Part II: New RTL Features and Classes to Support Unicode (EN)]
* [http://www.embarcadero.com/rad-studio-2010-migration-center {{Product}} 2010 Migration Center (EN)]
* [[Anwendungen für Unicode anpassen|Anwendungen für Unicode anpassen]]
* [[C++-Anwendungen für Unicode anpassen|C++-Anwendungen für Unicode anpassen]]
* [[TCHAR-Zuordnung|_TCHAR-Zuordnung (C++)]]
* [[Verwendung von Unicode in der Befehlskonsole|Verwendung von Unicode in der Befehlskonsole]] {{f|vcl|
* [[Verwendung von TEncoding für Unicode-Dateien|Verwendung von TEncoding für Unicode-Dateien]] }}
* [[Behandlung der AnsiString-Codeseitenspezifikation in C++|Behandlung der AnsiString-Codeseitenspezifikation in C++]]
* [[lib_de:System.UnicodeString|System.UnicodeString]]
* [[lib_de:System.AnsiString|System.AnsiString]][[Category:Mit RAD Studio arbeiten]]
[[Category:AMMigrate]]

[[en:Unicode in RAD Studio]]
[[fr:Unicode dans RAD Studio]]
[[ja:RAD Studio における Unicode]]

Unicode in RAD Studio

2023-10-12T19:13:05Z

Nicolas.rios: RS-119900

__TOC__
{{Parent|Einführung in RAD Studio}}

In {{Product}} werden Unicode-basierte Strings verwendet: der Typ <code>string</code> ist nun ein Unicode-String ([[lib_de:System.UnicodeString|System.UnicodeString]]) anstatt eines ANSI-Strings. Dieses Thema beschreibt die korrekte Behandlung von Strings.

Mit den Typen [[lib_de:System.AnsiStringT|AnsiString]] und [[lib_de:System.WideString|WideString]] werden ANSI- bzw. Wide-Strings verwendet.

{{Product}} ist vollständig Unicode-kompatibel, und für diejenigen Teile Ihres Quelltextes, die die String-Behandlung betreffen, sind einige Änderungen möglicherweise erforderlich. Es wurde aber versucht, diese Änderungen auf ein Minimum zu beschränken. Es wurden zwar neue Datentypen eingeführt, aber vorhandene Datentypen wurden beibehalten und arbeiten genauso wie bisher. Ausgehend von dem mit der Unicode-Konvertierung im eigenen Haus gemachten Erfahrungen, sollten vorhandene Anwendungen ziemlich reibungslos migriert werden können.

'''Weitere Ressourcen:'''

* [https://www.embarcadero.com/images/dm/technical-papers/delphi-unicode-migration.pdf {{Delphi}} Unicode Migration for Mere Mortals: Stories and Advice from the Front Lines von Cary Jensen (EN)]
* [https://www.embarcadero.com/rad-in-action/migration-upgrade-center#unicode Unicode Migration Resources for Delphi, C++Builder and RAD Studio (EN)]

==Vorhandene String-Typen==

Die bereits vorhandenen Datentypen <code>[[lib_de:System.AnsiStringT|AnsiString]]</code> und <code>[[lib_de:System.WideString|System.WideString]]</code> arbeiten genauso wie bisher.

Bei kurzen Strings gibt es hinsichtlich der Funktionalität ebenfalls keine Änderungen. Beachten Sie bitte, dass kurze Strings auf 255 Zeichen beschränkt sind und nur einen Zeichenzähler und Einzelbyte-Zeichendaten enthalten. Sie umfassen keine Codeseiteninformationen. Ein kurzer String kann in Ausnahmenfällen UTF-8-Daten für eine bestimmte Anwendung enthalten.

===<code>AnsiString</code>===

'''string''' war früher ein Alias für [[lib_de:System.AnsiString|AnsiString]]. Die folgende Tabelle zeigt die Position der Felder im früheren Format von <code>AnsiString</code>:

'''Früheres Format des Datentyps <code>AnsiString</code>: '''

{| border="1" frame="hsides" rules="rows"
|-
! '''Referenzzähler '''
! '''Länge '''
! '''String-Daten (auf Byte-Größe) '''
! ''' Nullterminiert'''
|-
| style="text-align: left; vertical-align: top;" |
-8
| style="text-align: left; vertical-align: top;" |
-4
| style="text-align: left; vertical-align: top;" |
0
| style="text-align: left; vertical-align: top;" |
Length
|}

In {{Product}} wurde das Format von [[lib_de:System.AnsiString|AnsiString]] geändert. Zwei neue Felder (<code>CodePage</code> und <code>ElemSize</code>) wurden hinzugefügt. Dadurch ist das Format von [[lib_de:System.AnsiString|AnsiString]] identisch mit dem neuen Typ [[lib_de:System.UnicodeString|UnicodeString]]. (Weitere Informationen zum neuen Format finden Sie unter [[Interne Datenformate (Delphi)#Lange String-Typen|Lange String-Typen]].)

===<code>WideString</code>===

<code>[[lib_de:System.WideString|System.WideString]]</code> wurde früher für Unicode-Zeichendaten verwendet. Das Format von <code>WideString</code> entspricht im Wesentlichen dem von Windows <code>BSTR</code>. <code>WideString</code> sollte weiterhin in COM-Anwendungen verwendet werden.

==Neuer String-Typ: UnicodeString==

Der <code>string</code>-Typ in {{Product}} ist der Typ <code>[[lib_de:System.UnicodeString|UnicodeString]]</code>.

In {{Delphi}} sind <code>Char</code>- und <code>PChar</code>-Typen jetzt <code>WideChar</code>- bzw. <code>PWideChar</code>-Typen.

<blockquote>'''Hinweis: '''Dies ist ein Unterschied zu Versionen vor 2009. In früheren Versionen war <code>string</code> ein Alias für <code>AnsiString</code>, und die Typen <code>Char</code> und <code>PChar</code> waren <code>AnsiChar</code> bzw. <code>PAnsiChar</code>.</blockquote>

In C++ steuert die Option '''[[C++ (Gemeinsame Optionen)|_TCHAR entspricht]]''' die Definition von <code>_TCHAR</code>, das entweder <code>wchar_t</code> oder <code>char</code> sein kann.

[[Frameworks und Bibliotheken|{{Product}} Frameworks und Bibliotheken]] verwenden jetzt den Typ <code>UnicodeString</code> und repräsentiert String-Werte nicht mehr als Einzelbyte- oder MBCS-Strings.

'''Format des Datentyps <code>UnicodeString</code>: '''

{| border="1" frame="hsides" rules="rows"
|-
! '''Codeseite'''
! '''Elementgröße'''
! '''Referenzzähler '''
! '''Länge '''
! '''String-Daten (auf Elementgröße) '''
! ''' Nullterminiert'''
|-
| style="text-align: left; vertical-align: top;" |
-12
| style="text-align: left; vertical-align: top;" |
-10
| style="text-align: left; vertical-align: top;" |
-8
| style="text-align: left; vertical-align: top;" |
-4
| style="text-align: left; vertical-align: top;" |
0
| style="text-align: left; vertical-align: top;" |
Length * elementsize
|}

<code>UnicodeString</code> kann als die folgende {{Delphi}}-Struktur dargestellt werden:

type StrRec = record
CodePage: Word;
ElemSize: Word;
refCount: Integer;
Len: Integer;
case Integer of
1: array[0..0] of AnsiChar;
2: array[0..0] of WideChar;
end;

<code>UnicodeString</code> fügt die Felder für die Codeseite <code>CodePage</code> und die Elementgröße <code>ElemSize</code> hinzu, die den Inhalt des Strings beschreiben. <code>UnicodeString</code> ist zu allen anderen String-Typen zuweisungskompatibel. Zuweisungen zwischen <code>AnsiString</code> und <code>UnicodeString</code> führen aber weiterhin die entsprechenden Auf- oder Abkonvertierungen durch. Bitte beachten Sie, dass eine Zuweisung eines <code>UnicodeString</code>-Typs zu einem <code>AnsiString</code>-Typ nicht empfohlen wird und zu Datenverlusten führen kann.

Beachten Sie, dass <code>AnsiString</code> ebenfalls über die Felder <code>CodePage</code> und <code>ElemSize</code> verfügt.

<code>UnicodeString</code>-Daten sind aus folgenden Gründen in UTF-16 codiert:

* UTF-16 entspricht dem zugrunde liegenden Format des Betriebssystems.
* UTF-16 reduziert zusätzliche explizite/implizite Konvertierungen.
* Es bietet bei Aufrufen der Windows-API eine bessere Performanz.
* Es müssen keine Betriebssystem Konvertierungen mit UTF-16 durchgeführt werden.
* Der Basic Multilingual Plane (BMP) enthält bereits die Schriftzeichen fast aller aktiven Sprachen der Welt und passt in ein einzelnes UTF-16 <code>Char</code> (16 Bits).
* Unicode-Surrogatpaare entsprechen dem Multibyte-Zeichensatz (MBCS), sind aber berechenbarer und Standard.
* <code>UnicodeString</code> kann für das Marshalling von COM-Interfaces verlustlose implizite Konvertierungen in und aus <code>WideString</code> bereitstellen.

Zeichen in UTF-16 können 2 oder 4 Byte groß sein, daher ist die Anzahl der Elemente in einem String nicht notwendigerweise gleich der Anzahl der Zeichen. Wenn der String nur aus BMP-Zeichen besteht, ist die Anzahl der Zeichen und der Elemente identisch.

<code>UnicodeString</code> bietet die folgenden Vorteile:

* UnicodeString verfügt über einen Referenzzähler.
* UnicodeString löst ein Problem von Altanwendungen in {{CBuilder}}.
* Durch die Aufnahme von Codierungsinformationen (Codeseite) in <code>AnsiString</code> wird das Risiko eines möglichen Datenverlustes bei impliziten Typumwandlungen reduziert.
* Der Compiler stellt sicher, dass die Daten korrekt sind, bevor die Daten verändert werden.

<code>WideString</code> verfügt über keinen Referenzzähler, deshalb ist <code>UnicodeString</code> für die meisten Anwendungstypen flexibler und effizienter (<code>WideString</code> eignet sich eher für COM).

===Indizierung===

Instanzen von <code>UnicodeString</code> können Zeichen indizieren. Die Indizierung ist 1-basiert, genau wie bei <code>AnsiString</code>. Sehen Sie sich den folgenden Quelltext an:

var C: Char;
S: string;
begin
...
C := S[1];
...
end;

In einem Fall, wie dem oben dargestellten, muss der Compiler sicher stellen, dass die Daten in <code>S</code> in einem geeigneten Format vorliegen. Der Compiler erzeugt entsprechenden Code, damit Zuweisungen zu String-Elementen den richtigen Typ haben und die Instanz eindeutig ist (d.h., dass sie einen Referenzzähler von 1 hat). Dies geschieht über einen Aufruf der Funktion <code>UniqueString</code>. Für den obigen Quelltext muss der Compiler, weil der String Unicode-Daten enthalten könnte, vor der Indizierung im Zeichen-Array auch die passende <code>UniqueString</code>-Funktion aufrufen.
{{f|vcl|

==={{CBuilder}}===

Die Klasse <code>UnicodeString</code> in {{CBuilder}} ermöglicht eine {{Delphi}}-ähnliche automatische Konvertierungssemantik. Bei vorhandenen VCL-Ereignisbehandlungsroutinen, die <code>AnsiString</code>-Parameter erwarten, ist dies ziemlich transparent, weil Konvertierungen bei Bedarf ausgeführt werden. So können Anwender allmählich, nach ihrem eigenen Zeitplan, zu vollständigem Unicode migrieren.

In manchen Situationen führt diese automatische Konvertierung aber zu unerwünschten Ergebnissen. Der VCL-String-Typ ist jetzt <code>UnicodeString</code> und nicht mehr <code>AnsiString</code>. Aus Gründen der Abwärtskompatibilität gibt die Methode <code>UnicodeString::t_str()</code> 'const char* anstelle von <code>const wchar_t*</code> zurück, indem die Größe der Wide-Daten der <code>UnicodeString</code>-Instanz reduziert wird. Dies kann zu unerwartetem Verhalten führen, weil der Quellcode einen Aufruf von <code>t_str()</code> nicht akzeptieren könnte, da die zugrunde liegenden Daten fehlerhaft werden könnten. Dieses Verhalten wird in Quellcode deutlich, der die zugrunde liegenden Daten in der Benutzeroberfläche, wie z.B. in <code>TListItem</code>, anzeigt.

In dem folgenden Beispiel sind die nach dem Aufruf von <code>t_str()</code> in der letzten Zeile der Methode in <code>TListView</code> angezeigten Daten fehlerhaft:

void ProcessSelectedItem(const char* item);

void __fastcall TForm6::ListView1DblClick(TObject *Sender)
{
int index = ListView1->Selected->Index;
TListItem *ClassItem = ListView1->Items->Item[index];
ProcessSelectedItem(ClassItem->Caption.t_str());
}

}}

==Compilerbedingungen==

In {{Delphi}} als auch in {{CBuilder}} können Sie Bedingungen setzen, um im selben Quelltext Unicode- und Nicht-Unicode-Code zuzulassen.

==={{Delphi}}===

{$IFDEF UNICODE}

==={{CBuilder}}===

#ifdef _DELPHI_STRING_UNICODE

==Überblick über die Änderungen==

* <code>string</code> wird nun <code>UnicodeString</code> und nicht <code>AnsiString</code> zugeordnet.
* <code>Char</code> wird nun <code>WideChar</code> (2 Byte, nicht 1 Byte) zugeordnet und ist ein UTF-16-Zeichen.
* <code>PChar</code> wird nun <code>PWideChar</code> zugeordnet.
* In C++ wird <code>System::String</code> nun der Klasse <code>UnicodeString</code> zugeordnet.

==Überblick über Unverändertes==

* <code>AnsiString</code>.
* <code>WideString</code>.
* <code>AnsiChar</code>, <code>PAnsiChar</code>.
* <code>WideChar</code>, <code>PWideChar</code>
* Implizite Konvertierungen funktionieren weiterhin.
* <code>AnsiString</code> verwendet die aktive Codeseite des Benutzers.

==Von der Zeichengröße unabhängige Quelltextkonstrukte==

Die folgenden Operationen sind von der Zeichengröße unabhängig:

* String-Verkettung:
** <code><string var> + <string var></code>
** <code><string var> + <literal></code>
** <code><literal> + <literal> </code>
** <code>Concat(<string> , <string>)</code>

* Standard-String-Funktionen:
** <code>Length(<string>)</code> gibt die Anzahl der char-Elemente zurück. Diese Anzahl muss nicht unbedingt gleich der Anzahl der Byte sein. Beachten Sie bitte, dass die Funktion <code>SizeOf</code> die Anzahl der Byte zurückgibt, was bedeutet, dass sich der Rückgabewert für <code>SizeOf</code> von <code>Length</code> unterscheiden kann.
** <code>Copy(<String>, <Start>, <Länge>)</code> gibt einen Teilstring in <code>Char</code>-Elementen zurück.
** <code>Pos(<Teilstring>, <String>)</code> gibt den Index des ersten <code>Char</code>-Elements zurück.

* Operatoren:
** <code><String> <Vergleichsoperator> <String> </code>
** <code>CompareStr() </code>
** <code>CompareText() </code>
** <code> ... </code>

*<code>FillChar(<Struktur oder Arbeitsspeicher>)</code>
** <code>FillChar(Rect, SizeOf(Rect), #0)</code>
** <code>FillChar(WndClassEx, SizeOf(TWndClassEx), #0)</code>. Bitte beachten: <code>WndClassEx.cbSize := SizeOf(TWndClassEx);</code>
* Windows-API
** Bei API-Aufrufen werden standardmäßig deren <code>WideString</code>-(“W”)-Versionen verwendet.
** Die <code>PChar(<String>)</code>-Typumwandlung hat eine identische Semantik.

Beispiel für <code>GetModuleFileName</code>:

function ModuleFileName(Handle: HMODULE): string;
var Buffer: array[0..MAX_PATH] of Char;
begin
SetString(Result, Buffer,
GetModuleFileName(Handle, Buffer, Length(Buffer)));
end;

Beispiel für <code>GetWindowText</code>:

function WindowCaption(Handle: HWND): string;
begin
SetLength(Result, 1024);
SetLength(Result,
GetWindowText(Handle, PChar(Result), Length(Result)));
end;

Beispiel für die Zeichenindizierung von Strings:

function StripHotKeys(const S: string): string;
var I, J: Integer;
LastChar: Char;
begin
SetLength(Result, Length(S));
J := 0;
LastChar := #0;
for I := 1 to Length(S) do
begin
if (S[I] <> '&') or (LastChar = '&') then
begin
Inc(J);
Result[J] := S[I];
end;
LastChar := S[I];
end;
SetLength(Result, J);
end;

==Von der Zeichengröße abhängige Quelltextkonstrukte==

Einige Operationen sind von der Zeichengröße abhängig. Die Funktionen und Features in der folgenden Liste enthalten - sofern möglich - auch eine “portierbare” Version. Sie können Ihren Quelltext auch in der portierbaren Version neu schreiben, er funktioniert sowohl mit <code>AnsiString</code>- als auch mit <code>UnicodeString</code>-Variablen.

* <code>SizeOf(<Char-Array>)</code> - portierbare Version: <code>Length(<Char-Array>)</code>.
* <code>Move(<Char-Puffer>... CharCount)</code> - portierbare Version: <code>Move(<Char-Puffer> ... CharCount * SizeOf(Char))</code>.
* Stream Read/Write - portierbare Version: <code>AnsiString</code>, <code>SizeOf(Char)</code> oder die Klasse <code>TEncoding</code>.
* <code>FillChar(<Char-Array>, <Größe>, <AnsiChar>)</code> - verwenden Sie zum Auffüllen mit <code>#0</code><code>*SizeOf(Char)</code> oder die portierbare <code>StringOfChar</code>-Funktion.
* <code>GetProcAddress(<Modul>, <PAnsiChar>)</code> - verwenden Sie die überladene Funktion, die ein <code>PWideChar</code> übernimmt.
* Typumwandlung oder die Verwendung von <code>PChar</code> für die Zeigerarithmetik - fügen Sie am Beginn der Datei <code>{IFDEF PByte = PChar}</code> ein, wenn Sie <code>PChar</code> für die Zeigerarithmetik verwenden. Oder verwenden Sie die {{Delphi}}-Compiler-Direktive <code>{POINTERMATH <ON|OFF>}</code>, um die Zeigerarithmetik für alle typisierten Zeiger zu aktivieren, damit das Inkrementieren/Dekrementieren nach Elementgröße ausgeführt wird.

==Set of Char-Konstrukte==

Sie müssen diese Konstrukte wahrscheinlich ändern.

* <Char> in <set of <code>AnsiChar</code>> - Codeerzeugung ist korrekt (<code>>#255</code>-Zeichen sind nie in der Menge enthalten). Der Compiler gibt die Warnung <code>WideChar in Set-Operationen verkürzt</code> aus. Abhängig von Ihrem Quelltext können Sie die Warnung gefahrlos deaktivieren. Verwenden Sie als Alternative die Funktion <code>CharinSet</code>.
* <Char> in <code>LeadBytes</code> - die globale Menge <code>LeadBytes</code> ist für MBCS-ANSI-Gebietseinstellungen vorgesehen. UTF-16 arbeitet weiterhin mit einem "Führungszeichen" (lead char) (<code>#$D800 - #$DBFF</code> sind hohe Surrogate, <code>#$DC00 - #$DFFF</code> niedrige Surrogate). Verwenden Sie, um dies zu ändern, die überladene Funktion <code>IsLeadChar</code>. Die ANSI-Version prüft auf <code>LeadBytes</code>. Die <code>WideChar</code>-Version prüft, ob es sich um ein hohes/niedriges Surrogat handelt.
* Zeichenklassifikation - verwenden Sie die statische Klasse <code>TCharacter</code>. Die Unit <code>[[lib_de:System.Character|Character]]</code> enthält Funktionen für die Klassifikation von Zeichen: <code>IsDigit</code>, <code>IsLetter</code>, <code>IsLetterOrDigit</code>, <code>IsSymbol</code>, <code>IsWhiteSpace</code>, <code>IsSurrogatePair</code> usw. Diese Funktionen basieren auf Tabellendaten der Unicode.org.

==Achtung bei diesen Konstrukten==

Sie sollten die folgenden problematischen Codekonstrukte untersuchen:

* Typumwandlungen, die den Typ verbergen:
** <code>AnsiString(Pointer(foo))</code>
** Überprüfen Sie, was beabsichtigt war.
* Verdächtige Typumwandlungen erzeugen eine Warnung:
** <code>PChar(<AnsiString var>)</code>
** <code>PAnsiChar(<UnicodeString var>)</code>
* Direktes Erstellen, Manipulieren oder Zugreifen auf interne Strukturen. Einige dieser Strukturen, wie z.B. <code>AnsiString</code>, wurden intern verändert, daher sind diese Aktionen unsicher. Verwenden Sie die Funktionen <code>StringRefCount</code>, <code>StringCodePage</code>, <code>StringElementSize</code> und andere, um String-Informationen zu ermitteln.

==Laufzeitbibliothek==

* Überladungen. Für Funktionen, die <code>PChar</code> übernehmen, gibt es jetzt <code>PAnsiChar</code>- und <code>PWideChar</code>-Versionen, damit die richtige Funktion aufgerufen wird.
*<code>AnsiXXX</code>-Funktionen sind möglich:
**<code>[[lib_de:System.SysUtils|SysUtils.AnsiXXXX]]</code>-Funktionen, wie z.B. <code>[[lib_de:System.SysUtils.AnsiCompareStr|AnsiCompareStr]]</code>:
*** Werden weiterhin mit <code>string</code> deklariert und verwenden <code>[[lib_de:System.UnicodeString|UnicodeString]]</code>.
*** Bieten eine bessere Abwärtskompatibilität (Quelltext muss nicht geändert werden).
** Die <code>AnsiXXXX</code>-Funktionen der Unit <code>[[lib_de:System.AnsiStrings|AnsiStrings]]</code> bieten dieselben Möglichkeiten wie die <code>[[lib_de:System.SysUtils|SysUtils.AnsiXXXX]]</code>-Funktionen, arbeiten aber nur mit <code>AnsiString</code>. Die <code>AnsiStrings.AnsiXXXX</code>-Funktionen bieten auch eine bessere Performanz für einen <code>[[lib_de:System.AnsiStringT|AnsiString]]</code> als die <code>SysUtils.AnsiXXXX</code>-Funktionen, die sowohl mit <code>[[lib_de:System.AnsiStringT|AnsiString]]</code> als auch mit <code>[[lib_de:System.UnicodeString|UnicodeString]]</code> arbeiten, weil keine impliziten Konvertierungen ausgeführt werden.
*<code>[[lib_de:System.Write|Write]]/[[lib_de:System.Writeln|Writeln]]</code> und <code>[[lib_de:System.Read|Read]]/[[lib_de:System.Readln|Readln]]</code>:
** Konvertieren weiterhin in/aus ANSI/OEM-Codeseiten.
** Die Konsole ist meist sowieso ANSI oder OEM.
** Bieten eine bessere Kompatibilität zu Altanwendungen.
** TFDD (Gerätetreiber für Textdateien):
*** <code>[[lib_de:System.TTextRec|TTextRec]]</code> und <code>[[lib_de:System.TFileRec|TFileRec]]</code>.
*** Dateinamen sind <code>WideChar</code>, aber wie oben sind die Daten ANSI/OEM.
** Verwenden Sie <code>[[lib_de:System.SysUtils.TEncoding|TEncoding]]</code> und <code>[[lib_de:System.Classes.TStrings|TStrings]]</code> für die Unicode-Dateieingabe-/ausgabe.

* <code>PByte</code> - deklariert mit <code>[[Zeigermathematik (Delphi)|$POINTERMATH ON]]</code>. Dadurch wird die Array-Indizierung und die Zeigermathematik wie bei <code>PAnsiChar</code> ermöglicht.

* String-Informationsfunktionen:
** <code>[[lib_de:System.StringElementSize|StringElementSize]]</code> gibt die aktuelle Datengröße zurück.
** <code>[[lib_de:System.StringCodePage|StringCodePage]]</code> gibt die Codeseite von String-Daten zurück.
** <code>[[lib_de:System.StringRefCount|System.StringRefCount]]</code> gibt den Referenzzähler zurück.

* Die RTL stellt Hilfsfunktionen bereit, mit denen Anwender explizite Konvertierungen zwischen Codeseiten und Elementgrößenumwandlungen vornehmen können. Wenn Entwickler die Funktion <code>Move</code> für ein Zeichen-Array verwenden, können sie keine Annahme über die Elementgröße machen. Dieses Problem kann reduziert werden, indem sichergestellt wird, dass alle R-Wert-Referenzen korrekte Aufrufe der RTL erzeugen, um korrekte Elementgrößen zu gewährleisten.

==Komponenten und Klassen==

* <code>TStrings</code>: Speichert <code>UnicodeString</code> intern (bleibt als <code>string</code> deklariert).
* <code>TWideStrings</code> (wird eventuell bald nicht mehr unterstützt) ist unverändert. Verwendet <code>WideString</code> (BSTR) intern.
*<code>TStringStream</code>
** Wurde neu geschrieben – hat per Vorgabe die ANSI-Standardcodierung für interne Speicherung.
** Die Codierung kann überschrieben werden.
** Ziehen Sie zum Erstellen eines Strings aus verschiedenen Teilen <code>TStringBuilder</code> anstelle von <code>TStringStream</code> in Betracht.
*<code>[[lib_de:System.SysUtils.TEncoding|TEncoding]]</code>
** Verwendet standardmäßig die aktive Codeseite des Anwenders.
** Unterstützt UTF-8.
** Unterstützt UTF-16, Big und Little Endian.
** Unterstützt Byte Order Mark (BOM).
** Sie können für benutzerspezifische Codierungen abgeleitete Klassen erstellen.

* Komponenten-Streaming (Text-DFM-Dateien):
** Sind vollständig abwärtskompatibel.
** Verwenden für das Streaming nur UTF-8, wenn der Komponententyp, die Eigenschaft oder der Name keine ASCII-7-Zeichen enthält.
** String-Eigenschaftswerte werden weiterhin mit dem “#”-Escaped-Format in den Stream gestellt.
** Lassen auch Werte als UTF-8 zu (noch nicht geklärtes Problem).
** Nur die Änderung im Binärformat ist für UTF-8-Daten für Komponentennamen, Eigenschaften und Typnamen möglich.

==Byte Order Mark==

Das Byte Order Mark (BOM) sollte zur Angabe der Codierung Dateien hinzugefügt werden:

* UTF-8 verwendet <code>EF BB BF</code>.
* UTF-16 Little Endian verwendet <code>FF FE</code>.
* UTF-16 Big Endian verwendet <code>FE FF</code>.

==Schritte zum Aktivieren von Unicode in Anwendungen==

Sie müssen die folgenden Schritte ausführen:

# Überprüfen von Char- und String-bezogenen Funktionen
# Neu erzeugen der Anwendung
# Überprüfen von Surrogatpaaren
# Überprüfen der String-Nutzdaten

Weitere Einzelheiten finden Sie unter [[Anwendungen für Unicode anpassen|Anwendungen für Unicode anpassen]].

==Neue Warnungen des {{Delphi}}-Compilers==

Dem {{Delphi}}-Compiler wurden neue Warnungen hinzugefügt, die sich auf mögliche Fehler bei der Typumwandlung beziehen (z.B. beim Umwandeln eines <code>UnicodeString</code>- oder <code>WideString</code>-Strings in <code>AnsiString</code> oder <code>AnsiChar</code>). Wenn Sie eine Anwendung nach Unicode konvertieren, sollten Sie die Warnungen 1057 und 1058 aktivieren, die Sie beim Auffinden von Problembereichen in Ihrem Quelltext unterstützen.

* '''[[W1050 In Set-Ausdruck WideChar auf Byte-Char verringert (Delphi)|W1050: WideChar in Set-Ausdrücken auf ByteChar verkürzt (Delphi)]]'''. "Set of char" definiert in Win32 eine Menge über den gesamten Bereich des Char-Typs. Da Char in Win32 ein Typ auf Byte-Größe ist, wird dadurch eine Menge mit maximaler Größe und mit 256 Elementen definiert. In .NET ist Char ein Typ auf Word-Größe, dessen Bereich (0..65535) die Kapazität des Mengen-Typs überschreitet.
* '''[[W1057 Implizite String-Umwandlung von '%s' zu '%s' (Delphi)|W1057: Implizite String-Umwandlung von '%s' zu '%s' (IMPLICIT_STRING_CAST)]]''' Wird ausgegeben, wenn der Compiler einen Fall findet, bei dem ein <code>AnsiString</code> (oder ein <code>AnsiChar</code>) in eine Form von Unicode (einen <code>UnicodeString</code> oder einen <code>WideString</code>) implizit konvertiert werden muss. (HINWEIS: Diese Warnung ist eventuell per Vorgabe aktiviert).
* '''[[W1058 Implizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (Delphi)|W1058: Implizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (IMPLICIT_STRING_CAST_LOSS)]]''' Wird ausgegeben, wenn der Compiler einen Fall findet, bei dem eine Form von Unicode (ein <code>UnicodeString</code> oder ein <code>WideString</code>) in einen <code>AnsiString</code> (oder ein <code>AnsiChar</code>) implizit konvertiert werden muss. Dies ist eine potenziell verlustreiche Umwandlung, weil es Zeichen in dem String geben kann, die auf der Codeseite, in die der String umgewandelt wird, nicht repräsentiert werden können. (HINWEIS: Diese Warnung ist eventuell per Vorgabe aktiviert).
* '''[[W1059 Explizite String-Umwandlung von '%s' zu '%s' (Delphi)|W1059: Explizite String-Umwandlung von '%s' zu '%s' (EXPLICIT_STRING_CAST)]]''' Wird ausgegeben, wenn der Compiler auf einen Fall trifft, bei dem der Programmierer explizit einen <code>AnsiString</code> (oder ein <code>AnsiChar</code>) in eine Form von Unicode (<code>UnicodeString</code> oder <code>WideString</code>) umwandelt. (HINWEIS: Diese Warnung ist standardmäßig deaktiviert und sollte nur zum Auffinden eventueller Probleme verwendet werden.)
* '''[[W1060 Explizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (Delphi)|W1060: Explizite String-Umwandlung mit potenziellem Datenverlust von '%s' zu '%s' (EXPLICIT_STRING_CAST_LOSS)]]''' Wird ausgegeben, wenn der Compiler einen Fall findet, bei dem der Programmierer explizit eine Form von Unicode (<code>UnicodeString</code> oder <code>WideString</code>) in einen <code>AnsiString</code> (oder ein <code>AnsiChar</code>) konvertiert. Dies ist eine potenziell verlustreiche Umwandlung, weil es Zeichen in dem String geben kann, die auf der Codeseite, in die der String umgewandelt wird, nicht repräsentiert werden können. (HINWEIS: Diese Warnung ist standardmäßig deaktiviert und sollte nur zum Auffinden eventueller Probleme verwendet werden.)

==Empfehlungen==

* Belassen Sie die Quelltextdaten im UTF-8-Format:
** Dateien können im ANSI-Format bleiben, wenn der Quelltext mit der korrekten Codeseite compiliert wird. Wählen Sie ({{Menu|Projekt > Optionen > C++-Compiler > [[C++-Compiler Erweitert|Erweitert]]}} und verwenden Sie die Option "Codeseite" unter '''Weitere Optionen''', um die korrekte Codeseite festzulegen.
** Schreiben Sie in die Quelltextdatei ein UTF-8 BOM. Stellen Sie sicher, dass Ihr Versionsverwaltungssystem diese Dateien unterstützt.
* Führen Sie in der IDE ein Refactoring durch, wenn der Quelltext <code>AnsiString</code> oder <code>AnsiChar</code> sein muss (der Quelltext ist weiterhin portierbar).
* Statische Überprüfung des Quelltextes:
** Gibt der Quelltext Daten nur weiter?
** Führt der Quelltext eine einfache Zeichenindizierung durch?
* Beachten Sie alle Warnungen (es könnten Fehler daraus werden):
** Verdächtige Zeigerumwandlungen.
** Implizite/explizite Umwandlungen.
* Bestimmen Sie den Zweck des Quelltextes.
** Verwendet der Quelltext einen String (<code>AnsiString</code>) als ein dynamisches Byte-Array? Wenn ja, dann setzen Sie stattdessen den portierbaren Typ <code>TBytes</code> (<code>Byte</code>-Array) ein.
** Wird mit einer <code>PChar</code>-Umwandlung die Zeigerarithmetik aktiviert? Wenn ja, wandeln Sie stattdessen in <code>PByte</code> um, und aktivieren Sie <code>$POINTERMATH ON</code>.

==Siehe auch==

* [[UTF-8-Konvertierungsroutinen|UTF-8-Konvertierungsroutinen]]
* [http://www.embarcadero.com/images/dm/technical-papers/delphi-unicode-migration.pdf {{Delphi}} Unicode Migration for Mere Mortals: Stories and Advice from the Front Lines von Cary Jensen (EN)]
* [http://edn.embarcadero.com/article/38437 {{Delphi}} in a Unicode World Part I: What is Unicode, Why do you need it, and How do you work with it in {{Delphi}}? (EN)]
* [http://edn.embarcadero.com/article/38498 {{Delphi}} in a Unicode World Part II: New RTL Features and Classes to Support Unicode (EN)]
* [http://www.embarcadero.com/rad-studio-2010-migration-center {{Product}} 2010 Migration Center (EN)]
* [[Anwendungen für Unicode anpassen|Anwendungen für Unicode anpassen]]
* [[C++-Anwendungen für Unicode anpassen|C++-Anwendungen für Unicode anpassen]]
* [[TCHAR-Zuordnung|_TCHAR-Zuordnung (C++)]]
* [[Verwendung von Unicode in der Befehlskonsole|Verwendung von Unicode in der Befehlskonsole]] {{f|vcl|
* [[Verwendung von TEncoding für Unicode-Dateien|Verwendung von TEncoding für Unicode-Dateien]] }}
* [[Behandlung der AnsiString-Codeseitenspezifikation in C++|Behandlung der AnsiString-Codeseitenspezifikation in C++]]
* [[lib_de:System.UnicodeString|System.UnicodeString]]
* [[lib_de:System.AnsiString|System.AnsiString]][[Category:Mit RAD Studio arbeiten]]
[[Category:AMMigrate]]

[[en:Unicode in RAD Studio]]
[[fr:Unicode dans RAD Studio]]
[[ja:RAD Studio における Unicode]]

Drucken aus FireMonkey-Anwendungen

2023-09-27T13:07:48Z

Nicolas.rios: RS-111641

{{Parent|FireMonkey-Anwendungshandbuch}}

Sie können auf '''Windows''' oder '''macOS''' aus einer {{FM}}-Anwendung drucken.

=={{FM}}-API zum Drucken==

Das Objekt [[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] kapselt die Funktionalität für den Zugriff auf einen Drucker und das Drucken auf einem Drucker, der an einem Computer für Windows oder macOS angeschlossen ist. Mit dem Objekt [[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] können Sie alle Druckoperationen einer Anwendung verwalten. Durch Aufruf der globalen Funktion [[lib_de:FMX.Printer.Printer|FMX.Printer.Printer]] können Sie eine Instanz von [[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] abrufen.

[[lib_de:FMX.Printer.TPrinter|FMX.Printer.TPrinter]] enthält eine Liste der [[lib_de:FMX.Printer.TPrinterDevice|TPrinterDevice]]-Objekte, die jeweils einen Drucker repräsentieren. Jeder Drucker enthält eine eigene Liste mit Druckauflösungen DPI (Dots Per Inch, Punkte pro Zoll). In der Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.DPICount|DPICount]] ist die Anzahl der Auflösungen enthalten, die von dem Drucker unterstützt werden. Die indizierte Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.DPI|DPI]] kann zum Ermitteln der tatsächlichen Auflösungen durchlaufen werden. [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] ist ein nullbasierter Index für die indizierte Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.DPI|DPI]], die die Druckauflösung auf dem Drucker darstellt.

==Aktivieren der Druckfunktion in {{FM}}-Anwendungen==

In den folgenden Schritten wird gezeigt, wie das Drucken aus einer {{FM}}-Anwendung durchgeführt wird.
<ol>
<li>
Beziehen Sie [[lib_de:FMX.Printer|FMX.Printer]] in das Formular ein, in dem der Druckauftrag verwendet werden soll.

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
uses FMX.Printer;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
#include "FMX.Printer.hpp"
</source>
<l e="cpp"/>
</li>
<li>
Verwenden Sie immer die [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche des Druckers]] oder die Zeichenfläche einer grafischen Komponente (z.B. die Zeichenfläche eines Bildes) anstelle der Zeichenfläche des Formulars. Beginnen Sie den Druckvorgang immer mit [[lib_de:FMX.Graphics.TCanvas.BeginScene|BeginScene]] und beenden Sie den Druckauftrag mit [[lib_de:FMX.Graphics.TCanvas.EndScene|EndScene]], wenn Sie die [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche des Druckers]] nicht verwenden.
</li>
<li>
Setzen Sie zuerst zur vollständigen Kontrolle über die Druckqualität (Auflösung der und Portabilität der [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche]]) [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] durch Zuweisen eines Wertes oder durch Aufruf der Methode [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] (empfohlenes Vorgehen).

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.ActivePrinter.SelectDPI(1200, 1200); { one way }
Printer.ActivePrinter.ActiveDPIIndex := 1; { another way }

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

'''C++:
<source lang="cpp">
Printer->ActivePrinter->SelectDPI(1200, 1200); /* one way */
Printer->ActivePrinter->ActiveDPIIndex = 1; /* another way */
</source>
<l e="cpp"/>
</li>
<li>
Starten Sie den eigentlichen Druckauftrag mit [[lib_de:FMX.Printer.TPrinter.BeginDoc|BeginDoc]].

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.BeginDoc;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Printer->BeginDoc();
</source>
<l e="cpp"/>
</li>
<li>
Beenden Sie den eigentlichen Druckauftrag mit [[lib_de:FMX.Printer.TPrinter.EndDoc|EndDoc]].

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.EndDoc;
</source>

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

'''C++:
<source lang="cpp">
Printer->EndDoc();
</source>
<l e="cpp"/>
</li>
<li>
Ändern Sie während eines Druckauftrags nie die Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]].
</li>
</ol>

==DPI- und Treiberunterstützung==

Die Treiberunterstützung für Drucker ist auf verschiedenen Plattformen (Windows, macOS) unterschiedlich. Deshalb sollten Sie sich nicht darauf verlassen, dass die Anzahl oder die Reihenfolge der unterstützten Auflösungen im Array [[lib_de:FMX.Printer.TPrinterDevice.DPI|DPI]] unter Windows und macOS identisch sind. Unter macOS gibt es beispielsweise für den HP-Laserdrucker 3 unterstützte Auflösungen, für Windows hingegen 7. Bei Anwendungen mit Druckfunktionen für Windows und macOS müssen Sie zusätzlichen Code hinzufügen (hauptsächlich zur Angabe der DPI), damit die Druckausgabe auf beiden Plattformen annähernd gleich ist.

Als '''bestes Verfahren''' hat sich erwiesen, die DPI immer durch Setzen der Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] oder durch Aufruf der Methode [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] vor dem Drucken, wie oben erwähnt, festzulegen.

[[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] wird für einen gegebenen Drucker '''nicht''' auf die Standard-DPI gesetzt. Ein [[lib_de:FMX.Printer.TPrinterDevice|TPrinterDevice]]-Objekt unterstützt keine Standard-DPI, insbesondere weil die Standard-DPI von einigen macOS-Druckertreibern nicht angegeben wird. Deshalb wird beim Start der Anwendung [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] für alle [[lib_de:FMX.Printer.TPrinterDevice|TPrinterDevice]]-Objekte auf -1 gesetzt. Der Wert -1 bedeutet, dass entweder die letzte Druck-DPI oder die Standard-DPI verwendet wird. Die Standard-DPI ist nur nach dem Start der Anwendung verfügbar, wenn Sie [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] nicht in einen anderen Indexwert geändert und [[lib_de:FMX.Printer.TPrinter.BeginDoc|BeginDoc]] nicht aufgerufen haben.

Andererseits können Sie [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] auf -1 setzen, und die letzte DPI des zuvor festgelegten Druckers wird von der Anwendung verwendet. Denken Sie immer daran, einen Wert für [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] zu setzen, bevor Sie [[lib_de:FMX.Printer.TPrinter.BeginDoc|BeginDoc]] aufrufen, wenn Sie dieselbe Größe der [[lib_de:FMX.Printer.TPrinter.Canvas|Zeichenfläche]] für Windows und macOS verwenden möchten.

Mit der Methode [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] kann durch ein [[lib_de:FMX.Printer.TPrinter|TPrinter]]-Objekt sehr einfach die Ihrem Drucker ähnlichste Auflösung auf Basis der an [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] übergebenen Parameter ausgewählt werden. Es ist einfacher festzulegen; anstatt die Eigenschaft [[lib_de:FMX.Printer.TPrinterDevice.ActiveDPIIndex|ActiveDPIIndex]] direkt zu setzen, können Sie beispielsweise den Wert zur Laufzeit ändern:

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Printer.ActivePrinter.Select(600, 600);
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Printer->ActivePrinter->Select(600, 600);
</source>
<l e="cpp"/>

In Anbetracht der Tatsache, dass unter Windows die Anzahl der vom Treiber angegebenen Druckerauflösungen von denen, die der macOS-Druckertreiber liefert, abweicht, könnte der Index nicht verfügbar sein.

Zusammengefasst stellt die Verwendung von [[lib_de:FMX.Printer.TPrinterDevice.SelectDPI|SelectDPI]] zum Setzen der Druck-DPI die '''weitaus praktischere Methode''' dar.

==Druckerzeichenfläche==

Es gibt einige Unterschiede bei der Verwendung einer '''Druckerzeichenfläche''' im Vergleich zu einer '''Bildschirm- oder Fenster-(Formular-)Zeichenfläche''':
<ol>
<li>
* Für Druckerzeichenflächen müssen Sie die Farb- und Fülleinstellungen mit [[lib_de:FMX.Graphics.TCanvas.Fill|Canvas.Fill]] festlegen:

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Canvas.Fill.Color := claXXX;
Canvas.Fill.Kind := TBrushKind.Solid;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Canvas->Fill->Color = claXXX;
Canvas->Fill->Kind = TBrushKind.Solid;
</source>
<l e="cpp"/>
</li>
<li>

* Für Bildschirm- oder Fensterzeichenflächen müssen Sie die Farb- und Fülleinstellungen mit [[lib_de:FMX.Graphics.TCanvas.Stroke|Canvas.Stroke]] festlegen.

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
Canvas.Stroke.Color := claXXX;
Canvas.Stroke.Kind := TBrushKind.Solid;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++:
<source lang="cpp">
Canvas->Stroke->Color = claXXX;
Canvas->Stroke->Kind = TBrushKind.Solid;
</source>
<l e="cpp"/>
</li>
</ol>

Beachten Sie, dass:
* Sie beim Drucken von Text, dessen Farbe Sie ändern möchten, [[lib_de:FMX.Graphics.TCanvas.Fill|Canvas.Fill]] verwenden müssen.
* Sie beim Drucken anderer Elemente – außer Text – [[lib_de:FMX.Graphics.TCanvas.Stroke|Canvas.Stroke]] verwenden müssen.

Der Parameter <code>Opacity</code> übernimmt bei allen Routinen, die diesen Parameter unterstützen (wie [[lib_de:FMX.Graphics.TCanvas.FillRect|FMX.Graphics.TCanvas.FillRect]]) Gleitkommawerte im Bereich von <code>0..1</code> (0 ist transparent und 1 ist undurchsichtig). Verwenden Sie keine Werte außerhalb dieses Bereichs.

==Beispiel für programmgesteuertes Drucken==

Im folgenden Beispiel wird ein Bild und eine Schaltfläche verwendet. Bei jedem Klicken auf die Schaltfläche wird das Bild auf dem Drucker ausgegeben.

<l s="delphi"/>

'''{{Delphi}}:
<source lang="delphi">
var
SrcRect, DestRect: TRectF;
begin
{ Set the default DPI for the printer. The SelectDPI routine defaults
to the closest available resolution as reported by the driver. }
Printer.ActivePrinter.SelectDPI(1200, 1200);
{ Start printing. }
Printer.BeginDoc;

if Printer.Canvas.BeginScene then
try
{ Set canvas filling style. }
Printer.Canvas.Fill.Color := claBlack;
Printer.Canvas.Fill.Kind := TBrushKind.Solid;

{ Set the Source and Destination TRects. }
SrcRect := Image1.LocalRect;
DestRect := TRectF.Create(0, 0, Printer.PageWidth, Printer.PageHeight);

{ Print the picture on all the surfaces of the page and all opaque. }
Printer.Canvas.DrawBitmap(Image1.Bitmap, SrcRect, DestRect, 1);
finally
Printer.Canvas.EndScene;
end;

{ Finish printing job. }
Printer.EndDoc;
end;
</source>
<l e="delphi"/>
<l s="cpp"/>

'''C++''':
<source lang="cpp">
TRectF SrcRect, DestRect;
TPrinter *Printer = Printer;

/* Set the default DPI for the printer. The SelectDPI routine defaults
to the closest available resolution as reported by the driver. */
Printer->ActivePrinter->SelectDPI(1200, 1200);

/* Start printing. */
Printer->BeginDoc();

if (Printer->Canvas->BeginScene()) {
try
{
/* Set canvas filling style. */
Printer->Canvas->Fill->Color = claBlack;
Printer->Canvas->Fill->Kind = TBrushKind(1);

/* Set the Source and Destination TRects. */
SrcRect = Image1->LocalRect;
DestRect = TRectF(0, 0, Printer->PageWidth, Printer->PageHeight);

/* Print the picture on all the surface of the page and all opaque. */
Printer->Canvas->DrawBitmap(Image1->Bitmap, SrcRect, DestRect, 1);
}
__finally
{
Printer->Canvas->EndScene();
}
}

/* Finish the printing job. */
Printer->EndDoc();
</source>
<l e="cpp"/>

Weitere Informationen bezüglich der Druck-API finden Sie in der API-Dokumentation in der [[lib_de:FMX.Printer|Unit FMX.Printer]].

==Siehe auch==

* [[lib_de:FMX.Printer|FMX.Printer (Unit)]]

==Codebeispiele==

<l s="delphi"/>
* [[samp_en:FMXPrinting_({{Delphi}})|Drucken aus {{FM}} ({{Delphi}})]]
<l e="delphi"/>
<l s="cpp"/>
* [[samp_en:FMXPrinting_(C++)|Drucken aus {{FM}} (C++)]]
<l e="cpp"/>

[[Category:XE2]]
[[Category:FMX]]
[[Category:AMMigrate]]

[[en:Printing from a FireMonkey Application]]
[[fr:Impression depuis une application FireMonkey]]
[[ja:FireMonkey アプリケーションからの印刷]]

Symboldeklarationen und Querverweise (Delphi)

2023-09-21T21:11:17Z

Nicolas.rios: {{Note|

{{Parent|Liste der Delphi-Compiler-Direktiven - Index}}
<ideTag id="FHXR21630"></ideTag>
<ideTag id="SymbolDeclarationAndCrossReferenceInformation"></ideTag>
<ideTag id="CompilerDirectivesTopics"></ideTag>
<ideTag id="$Y"></ideTag>
<ideTag id="$REFERENCEINFO"></ideTag>
<ideTag id="$DEFINITIONINFO"></ideTag>
<ideTag id="Y"></ideTag>
<ideTag id="REFERENCEINFO"></ideTag>
<ideTag id="DEFINITIONINFO"></ideTag>
{| border="1" frame="hsides" rules="rows"
| align="left" valign="top" |
'''Typ'''
| align="left" valign="top" |
Option
|-
| align="left" valign="top" |
'''Syntax'''
| align="left" valign="top" |
{$Y+}, {$Y-}, oder {$YD}; {$REFERENCEINFO ON}, {DEFINITIONINFO OFF} oder {$REFERENCEINFO OFF}, oder {DEFINITIONINFO ON}
|-
| align="left" valign="top" |
'''Vorgabe'''
| align="left" valign="top" |
{$YD} {$DEFINITIONINFO ON}
|-
| align="left" valign="top" |
'''Bereich'''
| align="left" valign="top" |
Global
|}

'''Bemerkungen'''

Die Direktive $Y steuert die Generierung von Symbolinformationen, die von der Projektverwaltung, vom Code-Explorer und vom Quelltext-Editor verwendet werden. Diese Informationen bestehen aus Tabellen, in denen die Zeilennummern des Quelltextes für alle Deklarationen der Bezeichner und (im Status {$Y+} ) auch für alle Verweise auf die Bezeichner in einem Modul enthalten sind. Bei Units sind die Informationen zusammen mit dem Objektquelltext der Unit in der .dcu-Datei enthalten. Symbolinformationen vergrößern die .dcu-Dateien, haben aber keine Auswirkungen auf die Größe oder Schnelligkeit des ausführbaren Programms.

Wenn ein Programm oder eine Unit im Standardstatus {$YD} (oder {DEFINITIONINFO ON}) compiliert wird, so zeichnet der Compiler Informationen über die Stelle auf, an der die einzelnen Bezeichner definiert sind. Bei den meisten Bezeichnern (Variablen, Konstanten, Klassen usw.) zeichnet der Compiler die Stelle auf, an der die jeweilige Deklaration steht. Bei Prozeduren, Funktionen und Methoden wird die Stelle aufgezeichnet, an der sich die Implementierung befindet. Dies ermöglicht das Suchen im Quelltext.

Wird ein Programm oder eine Unit im Status {$Y+} (oder {REFERENCEINFO ON}) compiliert, so zeichnet der Compiler Informationen darüber auf, wo die einzelnen Bezeichner verwendet werden und wo sie definiert sind. Dies ermöglicht die Verwendung der Seite Referenz im Projekt-Browser.

Wenn ein Programm oder eine Unit im Status {$Y-} (oder {DEFINITIONINFO OFF} bzw. {REFERENCEINFO OFF}) compiliert wird, so werden keine Symbolinformationen aufgezeichnet. Damit ist es nicht möglich, im Quelltext zu suchen oder auf die Seite Referenz des Projekt-Browsers zuzugreifen.

Der Schalter $Y wird normalerweise zusammen mit den Schaltern $D und $L eingesetzt, die die Generierung von Debug-Informationen bzw. von lokalen Symbolinformationen steuern. Die Direktive $Y wirkt sich nur aus, wenn die Schalter $D und $L aktiviert sind.

{{Note| Die Generierung von Kreuzreferenz-Informationen ({$Y+}) kann die Compilier- und Linkzeiten beträchtlich erhöhen. Sie sollten diese Option daher nur aktivieren, wenn Sie die Seite '''Referenz''' der Projektverwaltung benötigen.}}
[[Category:{{Delphi}}]]

[[en:Symbol declaration and cross-reference information (Delphi)]]
[[fr:Déclaration de symboles et informations de référence croisée (Delphi)]]
[[ja:シンボルの宣言とクロスリファレンスの情報（Delphi）]]

Konsolenanwendungen

2023-09-15T20:13:37Z

Nicolas.rios: {{Note|

{{Parent|Anwendungen erstellen}}
Konsolenanwendungen sind 32-Bit-Programme, die in einem Konsolenfenster ohne grafische Oberfläche auf einer [[Übersicht über Zielplattformen|Zielplattform]] ausgeführt werden. Diese Anwendungen benötigen in der Regel wenig Benutzereingaben und verfügen über einen begrenzten Funktionsumfang. Obwohl in Konsolenanwendungen keine visuellen Komponenten angezeigt werden können, sind alle Typen und Funktionen der RTL (Laufzeitbibliothek) in einer Konsolenanwendung einsetzbar.

<l s="delphi" />
Alle Anwendungen, die den folgenden Code enthält, öffnen ein eigenes Konsolenfenster:
<source lang="delphi">{$APPTYPE CONSOLE}</source><l e="delphi" />

<l s="delphi" />

===So erstellen Sie eine neue {{Delphi}}-Konsolenanwendung:===

# Klicken Sie auf '''Datei > Neu > Weitere > {{Delphi}}-Projekte'''.
# Doppelklicken Sie auf '''Konsolenanwendung'''.

Die IDE erstellt eine Projektdatei für diesen Quelldateityp und zeigt den '''[[Quelltext-Editor|Quelltext-Editor]]''' an.
<l e="delphi" />
<l s="cpp" />

===So erstellen Sie eine neue C++-Konsolenanwendung:===

# Klicken Sie auf '''Datei > Neu > Weitere > {{CBuilder}}-Projekte''', und doppelklicken Sie auf '''Konsolenanwendung'''. Das Dialogfeld [[Neue Konsolenanwendung (C++)|Neue Konsolenanwendung (C++)]] wird geöffnet.
# Wählen Sie den Quelltyp (C oder C++) für das Hauptmodul des Projekts aus, oder aktivieren Sie '''Angabe der Projektquelle''', und geben Sie die bereits vorhandene Datei an, die eine <code>main</code>- oder <code>winmain</code>-Funktion enthält.
# Geben Sie für C++ in der Gruppe '''Ziel-Framework''' den Anwendungstyp an, wenn Ihre Anwendung visuelle Komponenten anzeigen soll:
# Geben Sie für C++ in der Gruppe "Ziel-Framework" den Anwendungstyp an, wenn Ihre Anwendung visuelle Komponenten anzeigen soll:
#* '''FireMonkey''': Zum Erstellen einer FireMonkey-Anwendung
#* '''VCL''': Zum Erstellen einer VCL-Anwendung
#* '''Keine''': Ein Standard-Framework
#: '' {{Note| Obwohl in Konsolenanwendungen keine visuellen Komponenten angezeigt werden können, kann eine Konsolenanwendung visuelle Dateien einer Bibliothek (z. B. Symbole, Bitmaps, Video usw.) verarbeiten. Falls Sie beispielsweise im Experten nicht angeben, dass Sie die VCL verwenden möchten, können Sie keine VCL-Klassen in der Anwendung verwenden. Wenn Sie dies dennoch versuchen, werden Linker-Fehler produziert.}}
#: [[File:Console application.png|Neue Konsolenanwendung]]
# Klicken Sie auf '''OK'''.

Die IDE erstellt eine Projektdatei für diesen Quelldateityp und zeigt den '''[[Quelltext-Editor|Quelltext-Editor]]''' an.

<l e="cpp" />

==Konsolenanwendungen müssen alle Exceptions behandeln==

Bei Konsolenanwendungen müssen Sie sicherstellen, dass keine Exceptions außerhalb des Gültigkeitsbereichs des Programms auftreten. Ansonsten öffnet das Betriebssystem bei Programmende ein Dialogfeld mit Exception-Informationen.

<l s="cpp" />
C++-Konsolenanwendungen sollten alle Exceptions behandeln, damit die Zielplattform nicht versucht, ein Dialogfeld bei der Ausführung der Konsolenanwendung anzuzeigen. Weitere Informationen finden Sie unter [[Exception-Behandlung in C++Builder|Exception-Behandlung in C++Builder]].
<l e="cpp" />

<l s="delphi" />
Beispielsweise sollte Ihre {{Delphi}}-Anwendung eine Exception-Behandlung wie im nachfolgenden Beispiel beinhalten:

<source lang="delphi">
program ConsoleExceptionHandling;
{$APPTYPE CONSOLE}

uses
SysUtils;

procedure ExecuteProgram;
begin
// Program does something
raise Exception.Create('Unforeseen exception');
end;

begin
try
ExecuteProgram;
except
// Handle error condition
WriteLn('Program terminated due to an exception');
// Set ExitCode <> 0 to flag error condition (by convention)
ExitCode := 1;
end;

end.
</source><l e="delphi" />

==Beenden der Konsolenanwendung==

Konsolenanwendungen können folgendermaßen beendet werden:

* Durch Klicken auf die Schaltfläche '''X (Schließen)'''.
* Mit der Tastenkombination <code>Strg+C</code>.
* Mit der Tastenkombination <code>Strg+Pause</code>.
* Durch Abmelden.

Verwenden Sie zur Behandlung der Beendigungsanforderung durch den Benutzer die Windows-API-Funktion ''[http://msdn.microsoft.com/en-us/library/ms686016(v=vs.85).aspx SetConsoleCtrlHandler]''. Je nach gewählter Methode wird die Anwendung evtl. erfolgreich geschlossen, der Prozess nicht sauber beendet und der finalization-Abschnitt nicht ausgeführt.

==Siehe auch==

* [[Service-Anwendungen|Service-Anwendungen]]
* [[lib_de:Vcl.Forms.TApplication|Vcl.Forms.TApplication]]
* [http://msdn.microsoft.com/en-us/library/ms686016(v=vs.85).aspx SetConsoleCtrlHandler]
* [[Exception-Behandlung in C++Builder|Exception-Behandlung in C++Builder]]
* [[Neue Konsolenanwendung (C++)|Neue Konsolenanwendung (C++)]]

[[Category:Windows-Entwicklerhandbuch]]
[[Category:Delphi]]
[[Category:C++]]
[[Category:FMX]]

[[en:Console Applications]]
[[fr:Applications console]]
[[ja:コンソールアプリケーション]]

Neue Datensätze hinzufügen

2023-08-22T14:23:40Z

Nicolas.rios: {{Note|

{{Parent|Daten ändern}}

Damit eine Anwendung Datensätze hinzufügen kann, muss sich die Datenmenge im Modus ''dsInsert'' befinden. Sie können im Quelltext die Methoden [[lib_de:Data.DB.TDataSet.Insert|Insert]] oder [[lib_de:Data.DB.TDataSet.Append|Append]] verwenden, um eine Datenmenge in den Status ''dsInsert'' zu versetzen, falls die Nur-Lesen-Eigenschaft [[lib_de:Data.DB.TDataSet.CanModify|CanModify]] der Datenmenge den Wert ''True'' hat.

Beim Übergang einer Datenmenge in den Modus ''dsInsert'' empfängt diese ein Ereignis vom Typ ''BeforeInsert''. Nachdem dieser Übergang erfolgreich abgeschlossen wurde, empfängt die Datenmenge zunächst ein Ereignis vom Typ ''OnNewRecord'' und danach eines vom Typ ''AfterInsert''. Diese Ereignisse können z.B. zum Eintragen von Anfangswerten in neu eingefügte Datensätze verwendet werden:

<source lang="delphi">
procedure TForm1.OrdersTableNewRecord(DataSet: TDataSet);
begin
DataSet.FieldByName('OrderDate').AsDateTime := Date;
end;
</source>

<source lang="cpp">
void __fastcall TForm1::OrdersTableNewRecord(TDataSet *DataSet)
{
DataSet->FieldByName("OrderDate")->AsDateTime = Date();
}
</source>

In Formularen einer Anwendung können datensensitive Gitter- und Navigator-Steuerelemente eine Datenmenge unter folgenden Voraussetzungen in den Status ''dsInsert'' versetzen:

* Die Eigenschaft ''ReadOnly'' des Steuerelements ist auf ''False'' gesetzt (Voreinstellung);
* ''CanModify'' hat für die Datenmenge den Wert ''True''.

{{Note| Selbst wenn sich eine Datenmenge im Status ''dsInsert'' befindet, kann das Hinzufügen von Datensätzen bei SQL-Datenbanken dennoch scheitern, wenn der Benutzer der Anwendung nicht über die geeigneten SQL-Zugriffsberechtigungen verfügt.}}

Wenn sich eine Datenmenge im Modus ''dsInsert'' befindet, kann ein Benutzer oder eine Anwendung Werte in die Felder des neuen Datensatzes eingeben. Außer bei Gittern und Navigatoren gibt es für den Benutzer keinen sichtbaren Unterschied zwischen ''Insert'' und ''Append''. Bei einem Aufruf von ''Insert'' erscheint im Gitter über dem vorher aktuellen Datensatz eine leere Zeile. Ein Aufruf von ''Append'' hat einen Bildlauf zum letzten Datensatz im Gitter zur Folge. Am unteren Ende des Gitters wird eine leere Zeile eingefügt, und in allen mit der Datenmenge verbundenen Navigator-Komponenten werden die Schaltflächen [[lib_de:Data.DB.TDataSet.Next|Next]] und [[lib_de:Data.DB.TDataSet.Last|Last]] deaktiviert.

Im Einfügemodus rufen datensensitive Steuerelemente automatisch die Methode [[lib_de:Data.DB.TDataSet.Post|Post]] auf, wenn ein Benutzer eine Aktion ausführt, die den aktuellen Datensatz wechselt. Dies ist z.B. der Fall, wenn eine Bewegung zu einem anderen Datensatz im Gitter erfolgt. Ansonsten muss zum Eintragen der Änderungen ''Post'' aufgerufen werden.

''Post'' schreibt den neuen Datensatz in die Datenbank. Wenn die aktualisierten Datensätze in einem Cache zwischengespeichert werden, werden die Änderungen zunächst in einen temporären Puffer geschrieben. Rufen Sie die Methode ''ApplyUpdates'' auf, um im Cache zwischengespeicherte eingefügte und angehängte Datensätze in die Datenbank zu schreiben.

==Datensätze einfügen==

Die Methode [[lib_de:Data.DB.TDataSet.Insert|Insert]] öffnet vor dem aktuellen Datensatz einen neuen, leeren Datensatz. Dieser neue Datensatz wird gleichzeitig zum aktuellen Datensatz, so dass die Eingabe von Feldwerten durch den Benutzer oder die Anwendung möglich ist.

Wenn eine Anwendung die Methode [[lib_de:Data.DB.TDataSet.Post|Post]] (bzw. ''ApplyUpdates'', wenn die Aktualisierungen im Cache zwischengespeichert werden) aufruft, wird ein neu eingefügter Datensatz auf folgende Weise in die Datenbank geschrieben:

* Bei indizierten Paradox- und dBASE-Tabellen wird der Datensatz an der Position in die Datenmenge eingefügt, die sich anhand seines Index ergibt.
* Bei nicht indizierten Paradox- und dBASE-Tabellen wird der Datensatz an seiner aktuellen Position in die Datenmenge eingefügt.
* Bei SQL-Datenbanken ist die Einfügeposition von der Implementierung abhängig. Wenn die Tabelle indiziert ist, wird der Index mit der neuen Datensatzinformation aktualisiert.

==Datensätze anhängen==

Die Methode [[lib_de:Data.DB.TDataSet.Append|Append]] öffnet am Ende der Datenmenge einen neuen leeren Datensatz und macht ihn zum aktuellen Datensatz. Der Benutzer oder eine Anwendung können dann Feldwerte in diesen Datensatz eingeben.

Wenn eine Anwendung die Methode [[lib_de:Data.DB.TDataSet.Post|Post]] (bzw. ''ApplyUpdates'', wenn die Aktualisierungen im Cache zwischengespeichert werden) aufruft, wird ein an die Datenmenge angehängter Datensatz auf folgende Weise in die Datenbank geschrieben:

* Bei indizierten Paradox- und dBASE-Tabellen wird der Datensatz an der Position in die Datenmenge eingefügt, die sich anhand seines Index ergibt.
* Bei nicht indizierten Paradox- und dBASE-Tabellen wird der Datensatz am Ende der Datenmenge hinzugefügt.
* Bei SQL-Datenbanken ist die physikalische Position des Datensatzes von der jeweiligen Implementierung abhängig. Wenn die Tabelle indiziert ist, wird der Index mit der neuen Datensatzinformation aktualisiert.

==Siehe auch==

* [[Datensätze bearbeiten|Datensätze bearbeiten]]
* [[Datensätze löschen|Datensätze löschen]]
* [[Geänderte Daten in die Datenbank zurückschreiben|Geänderte Daten in die Datenbank zurückschreiben]]
* [[Änderungen abbrechen|Änderungen abbrechen]]
* [[Komplette Datensätze bearbeiten|Komplette Datensätze bearbeiten]]

==Codebeispiele==

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

{{DEFAULTSORT:Neue Datensatze hinzufugen}}
[[Category:Windows-Entwicklerhandbuch]]
[[Category:Delphi]]
[[Category:C++]]

[[en:Adding New Records]]
[[fr:Ajout de nouveaux enregistrements]]
[[ja:新規レコードの追加]]