Constructeurs
Cet article décrit comment définir et utiliser des constructeurs pour créer et initialiser des objets de classe et de structure.
Construction d’objets de classe
Les objets de types de classe ont des constructeurs. Il existe deux sortes de constructeurs. Le premier est le constructeur principal, dont les paramètres apparaissent entre parenthèses juste après le nom du type. Vous spécifiez d’autres constructeurs supplémentaires facultatifs à l’aide du mot clé new. Ces constructeurs supplémentaires doivent appeler le constructeur principal.
Le constructeur principal contient des liaisons let et do qui apparaissent au début de la définition de classe. Une liaison let déclare des champs privés et des méthodes de la classe, une liaison do exécute du code. Pour plus d’informations sur les liaisons let dans les constructeurs de classe, consultez Liaisons let dans les classes. Pour plus d’informations sur les liaisons do dans les constructeurs de classe, consultez Liaisons do dans les classes.
Que le constructeur que vous souhaitez appeler soit un constructeur principal ou un constructeur supplémentaire, vous pouvez créer des objets à l’aide d’une expression new, avec ou sans le mot clé new facultatif. Vous initialisez vos objets avec des arguments de constructeur, soit en répertoriant les arguments dans l’ordre et séparés par des virgules et placés entre parenthèses, soit en utilisant des arguments nommés et des valeurs entre parenthèses. Vous pouvez également définir des propriétés sur un objet pendant la construction de l’objet en utilisant les noms de propriété et en affectant des valeurs tout comme vous utilisez des arguments de constructeur nommé.
Le code suivant illustre une classe qui a un constructeur et différentes façons de créer des objets :
// This class has a primary constructor that takes three arguments
// and an additional constructor that calls the primary constructor.
type MyClass(x0, y0, z0) =
let mutable x = x0
let mutable y = y0
let mutable z = z0
do
printfn "Initialized object that has coordinates (%d, %d, %d)" x y z
member this.X with get() = x and set(value) = x <- value
member this.Y with get() = y and set(value) = y <- value
member this.Z with get() = z and set(value) = z <- value
new() = MyClass(0, 0, 0)
// Create by using the new keyword.
let myObject1 = new MyClass(1, 2, 3)
// Create without using the new keyword.
let myObject2 = MyClass(4, 5, 6)
// Create by using named arguments.
let myObject3 = MyClass(x0 = 7, y0 = 8, z0 = 9)
// Create by using the additional constructor.
let myObject4 = MyClass()
La sortie se présente comme suit :
Initialized object that has coordinates (1, 2, 3)
Initialized object that has coordinates (4, 5, 6)
Initialized object that has coordinates (7, 8, 9)
Initialized object that has coordinates (0, 0, 0)
Construction de structures
Les structures suivent toutes les règles des classes. Par conséquent, vous pouvez avoir un constructeur principal et vous pouvez fournir des constructeurs supplémentaires à l’aide de new. Toutefois, il existe une différence importante entre les structures et les classes : les structures peuvent avoir un constructeur sans paramètre (c’est-à-dire sans arguments) même si aucun constructeur principal n’est défini. Le constructeur sans paramètre initialise tous les champs à la valeur par défaut de ce type, généralement zéro ou son équivalent. Tous les constructeurs que vous définissez pour les structures doivent avoir au moins un argument afin qu’ils n’entrent pas en conflit avec le constructeur sans paramètre.
En outre, les structures ont souvent des champs qui sont créés à l’aide du mot clé val, les classes peuvent également avoir ces champs. Les structures et les classes qui ont des champs définis à l’aide du mot clé val peuvent également être initialisées dans des constructeurs supplémentaires à l’aide d’expressions d’enregistrement, comme indiqué dans le code suivant.
type MyStruct =
struct
val X : int
val Y : int
val Z : int
new(x, y, z) = { X = x; Y = y; Z = z }
end
let myStructure1 = new MyStruct(1, 2, 3)
Pour plus d’informations, consultez Champs explicites : mot clé val.
Exécution d’effets secondaires dans les constructeurs
Un constructeur principal d’une classe peut exécuter du code dans une liaison do. Toutefois, que se passe-t-il si vous devez exécuter du code dans un constructeur supplémentaire, sans liaison do ? Pour ce faire, utilisez le mot clé then.
// Executing side effects in the primary constructor and
// additional constructors.
type Person(nameIn : string, idIn : int) =
let mutable name = nameIn
let mutable id = idIn
do printfn "Created a person object."
member this.Name with get() = name and set(v) = name <- v
member this.ID with get() = id and set(v) = id <- v
new() =
Person("Invalid Name", -1)
then
printfn "Created an invalid person object."
let person1 = new Person("Humberto Acevedo", 123458734)
let person2 = new Person()
Les effets secondaires du constructeur principal s’exécutent toujours. La sortie est donc la suivante :
Created a person object.
Created a person object.
Created an invalid person object.
La raison pour laquelle then est obligatoire au lieu d’un autre do est que le mot clé do a sa signification standard de limiter une expression unit-returning lorsqu’elle est présente dans le corps d’un constructeur supplémentaire. Il a uniquement une signification particulière dans le contexte des constructeurs principaux.
Auto-identificateurs dans les constructeurs
Dans les autres membres, vous fournissez un nom pour l’objet actuel dans la définition de chaque membre. Vous pouvez également placer l’auto-identificateur sur la première ligne de la définition de classe à l’aide du mot clé as immédiatement après les paramètres du constructeur. L’exemple de code suivant illustre cette syntaxe.
type MyClass1(x) as this =
// This use of the self identifier produces a warning - avoid.
let x1 = this.X
// This use of the self identifier is acceptable.
do printfn "Initializing object with X =%d" this.X
member this.X = x
Dans d’autres constructeurs, vous pouvez également définir un auto-identificateur en plaçant la clause as juste après les paramètres du constructeur. L’exemple de code suivant illustre cette syntaxe :
type MyClass2(x : int) =
member this.X = x
new() as this = MyClass2(0) then printfn "Initializing with X = %d" this.X
Des problèmes peuvent survenir lorsque vous essayez d’utiliser un objet avant qu’il ne soit entièrement défini. Par conséquent, les utilisations de l’auto-identificateur peuvent amener le compilateur à émettre un avertissement et à insérer des vérifications supplémentaires pour s’assurer que les membres d’un objet ne sont pas accessibles avant l’initialisation de l’objet. Vous devez utiliser l’auto-identificateur uniquement dans les liaisons do du constructeur principal, ou après le mot clé then dans les constructeurs supplémentaires.
Le nom de l’auto-identificateur ne doit pas être this. Il peut s’agir de n’importe quel identificateur valide.
Assignation de valeurs aux propriétés lors de l’initialisation
Vous pouvez attribuer des valeurs aux propriétés d’un objet de classe dans le code d’initialisation en ajoutant une liste d’affectations du formulaire property = value à la liste d’arguments d’un constructeur. Cela est illustré par l'exemple de code suivant :
type Account() =
let mutable balance = 0.0
let mutable number = 0
let mutable firstName = ""
let mutable lastName = ""
member this.AccountNumber
with get() = number
and set(value) = number <- value
member this.FirstName
with get() = firstName
and set(value) = firstName <- value
member this.LastName
with get() = lastName
and set(value) = lastName <- value
member this.Balance
with get() = balance
and set(value) = balance <- value
member this.Deposit(amount: float) = this.Balance <- this.Balance + amount
member this.Withdraw(amount: float) = this.Balance <- this.Balance - amount
let account1 = new Account(AccountNumber=8782108,
FirstName="Darren", LastName="Parker",
Balance=1543.33)
La version suivante du code précédent illustre la combinaison d’arguments ordinaires, d’arguments facultatifs et de paramètres de propriété dans un appel de constructeur :
type Account(accountNumber : int, ?first: string, ?last: string, ?bal : float) =
let mutable balance = defaultArg bal 0.0
let mutable number = accountNumber
let mutable firstName = defaultArg first ""
let mutable lastName = defaultArg last ""
member this.AccountNumber
with get() = number
and set(value) = number <- value
member this.FirstName
with get() = firstName
and set(value) = firstName <- value
member this.LastName
with get() = lastName
and set(value) = lastName <- value
member this.Balance
with get() = balance
and set(value) = balance <- value
member this.Deposit(amount: float) = this.Balance <- this.Balance + amount
member this.Withdraw(amount: float) = this.Balance <- this.Balance - amount
let account1 = new Account(8782108, bal = 543.33,
FirstName="Raman", LastName="Iyer")
Constructeurs dans la classe héritée
Lorsque vous héritez d’une classe de base qui a un constructeur, vous devez spécifier ses arguments dans la clause hériter. Pour plus d’informations, consultez Constructeurs et héritage.
Constructeurs statiques ou constructeurs de types
En plus de spécifier du code pour la création d’objets, les liaisons statiques let et do peuvent être créées dans des types de classes qui s’exécutent avant que le type ne soit utilisé pour effectuer l’initialisation au niveau du type. Pour plus d’informations, consultez Liaisons let dans les classes et Liaisons do dans les classes.
Voir aussi
- Members (Membres)
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour