Structures (F#)
Une structure est un type d'objet compact qui peut être plus efficace qu'une classe pour les types qui ont 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, lorsqu'elles sont utilisées en tant que champs ou éléments de tableau, inline dans le type parent.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 agrégats de données qui sont fréquemment sollicités et copiés.
Dans la syntaxe précédente, deux formes sont indiquées.La première n'est pas la syntaxe simplifiée, mais elle est néanmoins fréquemment utilisée, car lorsque vous utilisez les mots clés end et struct, vous pouvez omettre l'attribut StructAttribute qui apparaît dans la deuxième forme.Vous pouvez abréger StructAttribute enStruct.
Dans la syntaxe précédente, type-definition-elements représente des déclarations et des définitions de membre.Les structures peuvent avoir des constructeurs et des champs mutables et immuables ; ils peuvent aussi 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 de liaisons let ou do, et ne peuvent pas contenir de manière récursive des 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 de liaisons let, vous devez déclarer des champs dans les structures à l'aide du mot clé val.Le mot clé val définit un champ et son type, mais il n'autorise pas l'initialisation.À la place, les déclarations val sont initialisées à zéro ou Null.Pour cette raison, les structures qui ont un constructeur implicite (c'est-à-dire les paramètres donnés 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 qui ont un constructeur défini prennent encore en charge l'initialisation à zéro.Par conséquent, l'attribut DefaultValue est une déclaration qui indique qu'une telle valeur zéro est valide pour le champ.Les constructeurs implicites pour les structures n'exécutent pas d'actions, car les liaisons let et do sont autorisées sur le type, mais les valeurs de paramètre des constructeurs implicites qui sont passées sont disponibles en tant que champs privés.
Les constructeurs explicites peuvent impliquer l'initialisation de valeurs de champ.Lorsque vous avez une structure qui a un constructeur explicite, elle prend encore en charge l'initialisation à zéro ; toutefois, n'utilisez pas l'attribut DefaultValue sur les déclarations val, car il entre 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 d'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