Annotation des types et des membres de types
Remonter à Attributs (RTTI)
Cette rubrique décrit la syntaxe et les règles appropriées lors de l'annotation d'un type ou d'un membre avec un attribut.
Syntaxe générale
Pour annoter un type ou un membre Delphi, par exemple une classe ou un membre de classe, vous devez faire précéder la déclaration de ce type du nom de la classe d'attribut entre crochets :
[CustomAttribute]
TMyClass = class;
Si le nom de la classe d'attribut se termine par "Attribute", vous pouvez également omettre le suffixe "Attribute" :
[Custom]
procedure DoSomething;
L'ajout de parenthèses après le nom de la classe d'attribut est également une syntaxe valide :
[Custom()]
TMyRecord = record;
Certains attributs acceptent des paramètres. Pour transmettre des arguments à votre attribut, utilisez la même syntaxe que celle utilisée pour les appels de méthode :
[Custom(Argument1, Argument2, …)]
TSimpleType = set of (stOne, stTwo, stThree);
Pour annoter un type simple avec plusieurs attributs, vous pouvez utiliser plusieurs ensembles de crochets :
[Custom1]
[Custom2(MyArgument)]
FString: String;
Ou utiliser des attributs séparés par des virgules entre un ensemble de crochets :
[Custom1, Custom2(MyArgument)]
function IsReady: Boolean;
Vous pouvez seulement utiliser des expressions constantes comme paramètres d'attribut
Un attribut qui est annoté sur un type ou un membre est inséré dans le bloc d'informations RTTI dans le binaire généré. Les informations émises incluent :
- Le type de classe de l'attribut.
- Le pointeur vers le constructeur sélectionné.
- Une liste de constantes qui sont par la suite transmises au constructeur d'attributs.
Les valeurs transmises au constructeur de l'attribut doivent être des expressions constantes. Puisque ces valeurs doivent être directement incorporées dans le binaire résultant, il est impossible de transmettre une expression qui nécessite une évaluation à l'exécution. Cela entraîne quelques limitations pour les informations transmises à l'attribut à la compilation :
- Vous pouvez seulement utiliser des expressions constantes, y compris des ensembles, des chaînes et des expressions ordinales.
- Vous pouvez utiliser TypeInfo() pour transmettre les informations sur le type car les adresses des blocs RTTI sont connues au moment de la compilation.
- Vous pouvez utiliser des références de classe car les adresses de métaclasse sont connues au moment de la compilation.
- Vous ne pouvez pas utiliser des paramètres out ou var car ils nécessitent une évaluation des adresses des paramètres transmis à l'exécution.
- Vous ne pouvez pas utiliser Addr() ou @.
Le code suivant illustre le cas dans lequel le compilateur ne compile pas l'annotation :
var
a, b: Integer;
type
[SomeAttribute(a + b)]
TSomeType = record
// …
end;
Dans l'exemple précédent, le constructeur de SomeAttribute nécessite une valeur entière. L'expression transmise nécessite une évaluation à l'exécution de a + b. Le compilateur émet une erreur à la compilation car il attend une expression constante.
Le code ci-dessous montre une expression acceptée :
const
a = 10;
b = 20;
type
[SomeAttribute(a + b)]
TSomeType = record
// …
end;
Les valeurs de a et b sont connues à la compilation. Ainsi, l'expression constante est évaluée directement.