Structures (F#)
Une structure est un type d'objet compact qui peut se révéler plus efficace qu'une classe pour les types ayant une petite quantité de données et un comportement simple.
[ attributes ] type [accessibility-modifier] type-name = struct type-definition-elements end // or [ attributes ] [<StructAttribute>] type [accessibility-modifier] type-name = type-definition-elements
Notes
Les structures sont des types valeur, ce qui signifie qu'elles sont stockées directement sur la pile, ou intégrées (« inline ») dans le parent du type quand elles sont utilisées en tant que champs ou éléments de tableau. Contrairement aux classes et aux enregistrements, les structures ont une sémantique de passage par valeur. Cela signifie qu'elles sont principalement utilisées pour les petits volumes de données qui sont fréquemment sollicités et copiés.
Dans la syntaxe précédente, deux formes sont présentes. La première n'est pas la syntaxe simplifiée, mais elle est néanmoins fréquemment utilisée, car quand vous employez les mots clés struct et end, vous pouvez omettre l'attribut StructAttribute qui apparaît dans la seconde forme. Vous pouvez abréger StructAttribute en Struct.
type-definition-elements dans la syntaxe précédente représente les définitions et les déclarations de membre. Les structures peuvent avoir des constructeurs et des champs modifiables et non modifiables, et peuvent déclarer des membres et des implémentations d'interface. Pour plus d'informations, consultez Membres (F#).
Les structures ne peuvent pas participer à l'héritage, ne peuvent pas contenir les liaisons let ou do, et ne peuvent pas comporter de manière récursive les champs de leur propre type (bien qu'elles puissent contenir des cellules de référence qui référencent leur propre type).
Étant donné que les structures n'autorisent pas les liaisons let, vous devez déclarer leurs champs à l'aide du mot clé val. Le mot clé val définit un champ et son type, mais n'autorise pas l'initialisation. À la place, les déclarations val sont initialisées à la valeur zéro ou null. Pour cette raison, les structures ayant un constructeur implicite (c'est-à-dire les paramètres qui sont fournis immédiatement après le nom de la structure dans la déclaration) requièrent que les déclarations val soient annotées avec l'attribut DefaultValue. Les structures ayant un constructeur défini prennent toujours en charge l'initialisation à zéro. Par conséquent, l'attribut DefaultValue est une déclaration selon laquelle une telle valeur égale à zéro est valide pour le champ. Les constructeurs implicites pour les structures n'exécutent aucune action, car les liaisons let et do ne sont pas autorisées sur le type, mais les valeurs de paramètre de constructeur implicite passées sont disponibles en tant que champs privés.
Les constructeurs explicites peuvent impliquer l'initialisation des valeurs de champ. Quand une structure a un constructeur explicite, elle prend toujours en charge l'initialisation à zéro ; toutefois, vous n'utilisez pas l'attribut DefaultValue sur les déclarations val, car il est en conflit avec le constructeur explicite. Pour plus d'informations sur les déclarations val, consultez Champs explicites : mot clé val (F#).
Les attributs et les modificateurs d'accessibilité sont autorisés sur les structures et suivent les mêmes règles que celles des autres types. Pour plus d’informations, consultez Attributs (F#) et Contrôle d'accès (F#).
Les exemples de code suivants illustrent des définitions de structure.
// In Point3D, three immutable values are defined.
// x, y, and z will be initialized to 0.0.
type Point3D =
struct
val x: float
val y: float
val z: float
end
// In Point2D, two immutable values are defined.
// Point2D has an explicit constructor.
// You can create zero-initialized instances of Point2D, or you can
// pass in arguments to initialize the values.
type Point2D =
struct
val X: float
val Y: float
new(x: float, y: float) = { X = x; Y = y }
end