Constructors
In dit artikel wordt beschreven hoe u constructors definieert en gebruikt om klasse- en structuurobjecten te maken en te initialiseren.
Bouw van klasseobjecten
Objecten van klassetypen hebben constructors. Er zijn twee soorten constructors. Een is de primaire constructor, waarvan de parameters tussen haakjes worden weergegeven vlak na de typenaam. U geeft andere, optionele extra constructors op met behulp van het new trefwoord. Dergelijke extra constructors moeten de primaire constructor aanroepen.
De primaire constructor bevat let en do bindingen die aan het begin van de klassedefinitie worden weergegeven. Een let binding declareert privévelden en -methoden van de klasse; een do binding voert code uit. Zie Bindingen in klassen voor meer informatie over let bindingen in klasseconstructorslet. Zie Bindingen in klassen voor meer informatie over do bindingen in constructorsdo.
Ongeacht of de constructor die u wilt aanroepen een primaire constructor of een extra constructor is, kunt u objecten maken met behulp van een new expressie, met of zonder het optionele new trefwoord. U initialiseert uw objecten samen met constructorargumenten door de argumenten in volgorde weer te geven en gescheiden door komma's en tussen haakjes te plaatsen, of door benoemde argumenten en waarden tussen haakjes te gebruiken. U kunt ook eigenschappen instellen voor een object tijdens de constructie van het object door de eigenschapsnamen te gebruiken en waarden toe te wijzen, net zoals u benoemde constructorargumenten gebruikt.
De volgende code illustreert een klasse met een constructor en verschillende manieren om objecten te maken:
// 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()
De uitvoer is als volgt:
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)
Bouw van structuren
Structuren volgen alle regels van klassen. Daarom kunt u een primaire constructor hebben en u kunt aanvullende constructors opgeven met behulp van new. Er is echter een belangrijk verschil tussen structuren en klassen: structuren kunnen een parameterloze constructor (dat wil gezegd, één zonder argumenten) hebben, zelfs als er geen primaire constructor is gedefinieerd. De constructor zonder parameter initialiseert alle velden naar de standaardwaarde voor dat type, meestal nul of het equivalent ervan. Constructors die u voor structuren definieert, moeten ten minste één argument hebben, zodat ze niet conflicteren met de parameterloze constructor.
Structuren bevatten vaak velden die zijn gemaakt met behulp van het val trefwoord; klassen kunnen deze velden ook hebben. Structuren en klassen met velden die zijn gedefinieerd met behulp van het val trefwoord, kunnen ook worden geïnitialiseerd in extra constructors met behulp van recordexpressies, zoals wordt weergegeven in de volgende code.
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)
Zie Expliciete velden: Het val trefwoord voor meer informatie.
Neveneffecten uitvoeren in constructors
Een primaire constructor in een klasse kan code in een do binding uitvoeren. Wat moet u echter doen als u code moet uitvoeren in een extra constructor, zonder een do binding? Hiervoor gebruikt u het then trefwoord.
// 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()
De bijwerkingen van de primaire constructor worden nog steeds uitgevoerd. Daarom is de uitvoer als volgt:
Created a person object.
Created a person object.
Created an invalid person object.
De reden waarom then is vereist in plaats van een andere do is dat het do trefwoord de standaard betekenis heeft van het scheiden van een unit-retourexpressie wanneer deze aanwezig is in de hoofdtekst van een extra constructor. Het heeft alleen speciale betekenis in de context van primaire constructors.
Zelf-id's in constructors
In andere leden geeft u een naam op voor het huidige object in de definitie van elk lid. U kunt de self-id ook op de eerste regel van de klassedefinitie plaatsen met behulp van het as trefwoord direct na de constructorparameters. In het volgende voorbeeld ziet u deze syntaxis.
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
In aanvullende constructors kunt u ook een self-id definiëren door de as component direct na de constructorparameters te plaatsen. In het volgende voorbeeld ziet u deze syntaxis:
type MyClass2(x : int) =
member this.X = x
new() as this = MyClass2(0) then printfn "Initializing with X = %d" this.X
Er kunnen problemen optreden wanneer u een object probeert te gebruiken voordat het volledig is gedefinieerd. Daarom kan het gebruik van de self-id ertoe leiden dat de compiler een waarschuwing verzendt en extra controles invoegt om ervoor te zorgen dat de leden van een object niet worden geopend voordat het object wordt geïnitialiseerd. Gebruik alleen de self-id in de do bindingen van de primaire constructor of na het then trefwoord in extra constructors.
De naam van de self-id hoeft niet te zijn this. Dit kan elke geldige id zijn.
Waarden toewijzen aan eigenschappen bij initialisatie
U kunt waarden toewijzen aan de eigenschappen van een klasseobject in de initialisatiecode door een lijst met toewijzingen van het formulier property = value toe te voegen aan de lijst met argumenten voor een constructor. Dit wordt weergegeven in het volgende codevoorbeeld:
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)
De volgende versie van de vorige code illustreert de combinatie van gewone argumenten, optionele argumenten en eigenschapsinstellingen in één constructor-aanroep:
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")
Constructors in overgenomen klasse
Wanneer u een basisklasse overneemt die een constructor heeft, moet u de argumenten opgeven in de component overname. Zie Constructors en overname voor meer informatie.
Statische constructors of typeconstructors
Naast het opgeven van code voor het maken van objecten, kunnen statische let en do bindingen worden gemaakt in klassetypen die worden uitgevoerd voordat het type voor het eerst wordt gebruikt om initialisatie uit te voeren op typeniveau. Zie let Bindingen in klassen en do bindingen in klassen voor meer informatie.
