Konstruktorzy (F#)
W tym temacie opisano sposób definiowania i użyć konstruktorów do tworzenia i zainicjować obiekty klasy i struktury.
Budowa obiektów klasy
Obiekty typu klasy ma konstruktorów.Istnieją dwa rodzaje konstruktorów.Jednym z nich jest konstruktora podstawowy, którego parametry pojawiają się w nawiasach po prostu po nazwie typu.Określ inne, opcjonalne dodatkowe konstruktory za pomocą new słowa kluczowego.Takie dodatkowe konstruktory należy wywołać konstruktora podstawowego.
Zawiera podstawowe konstruktora let i do powiązania, które pojawiają się na początku definicji klasy.A let wiązania deklaruje prywatnych pól i metod klasy; do wiązania wykonuje kod.Aby uzyskać więcej informacji o let wiązania w konstruktorów klas, zobacz Powiązania let w klasach (F#).Aby uzyskać więcej informacji o do wiązania w konstruktory, zobacz do — Powiązania w klasach (F#).
Niezależnie od tego, czy konstruktora chcesz wywołać konstruktora podstawowy lub dodatkowy konstruktora, można utworzyć obiektów za pomocą new wyrażenie, z lub bez opcjonalna new słowa kluczowego.Obiekty wraz z argumentów konstruktora przez listę argumentów w celu zainicjowania i oddzielone przecinkami i ujęta w nawiasy lub za pomocą nazwanych argumentów i wartości w nawiasach.Można również ustawić właściwości obiektu podczas budowy obiektu przy użyciu nazw właściwości i przypisywanie wartości, tak jak za pomocą nazwanych argumentów konstruktora.
Poniższy kod ilustruje klasy, która ma on konstruktora i różne sposoby tworzenia obiektów.
// 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()
Wprowadza dane wyjściowe.
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)
Budowa struktur
Struktury należy wykonać wszystkie reguły z klas.W związku z tym, może mieć konstruktora podstawowego i wprowadzić dodatkowe konstruktory za pomocą new.Istnieje jednak istotna różnica pomiędzy struktur i klas: struktur może mieć domyślnego konstruktora (tzn. jeden z argumentów nie), nawet jeśli nie podstawowego konstruktora jest zdefiniowane.Konstruktor domyślny inicjalizuje wszystkie pola na wartość domyślną dla tego typu, zazwyczaj zero lub jego odpowiednik.Konstruktory, wszelkie zdefiniowane dla struktur musi mieć co najmniej jeden argument, czyli nie wchodzą w konflikt z domyślnego konstruktora.
Ponadto struktur często mają pola, które są tworzone za pomocą val słowa kluczowego; klasy można także korzystać z tych pól.Struktury i klasami, które zdefiniowano przy użyciu pól val słowa kluczowego mogą również być inicjowane w dodatkowe konstruktory przy użyciu wyrażeń rekordu, jak pokazano w poniższym kodzie.
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)
Aby uzyskać więcej informacji, zobacz Pola jawne: val — Słowo kluczowe (F#).
Wykonywanie efekty uboczne w konstruktory
Podstawowy konstruktora klasy można wykonywać kod w do powiązania.Jednak co zrobić, jeśli trzeba wykonać kod w dodatkowe konstruktora bez do wiążące?Aby to zrobić, użyj then słowa kluczowego.
// 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()
Efekty uboczne podstawowego konstruktora nadal wykonywać.W związku z tym produkcja jest w następujący sposób.
Created a person object.
Created a person object.
Created an invalid person object.
Self identyfikatorów konstruktory
Innych członków należy podać nazwę bieżącego obiektu w definicji każdego członka.Identyfikator self można również umieścić w pierwszym wierszu definicji klasy, za pomocą as słowa kluczowego, niezwłocznie po parametry konstruktora.Poniższy przykład ilustruje tej składni.
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
W konstruktory dodatkowe można zdefiniować własny identyfikator, umieszczając as klauzuli zaraz po parametry konstruktora.Poniższy przykład ilustruje tej składni.
type MyClass2(x : int) =
member this.X = x
new() as this = MyClass2(0) then printfn "Initializing with X = %d" this.X
Podczas próby użycia obiektu, zanim została ona zdefiniowana w pełni, mogą wystąpić problemy.W związku z tym używa identyfikatora self może spowodować kompilator emitują komunikat ostrzegawczy i wstawić dodatkowe kontrole, aby upewnić się, że członkowie obiektu nie są dostępne, zanim obiekt jest zainicjowany.Należy używać tylko self identyfikator w do wiązania konstruktora podstawowego lub po then słowa kluczowego w dodatkowe konstruktorów.
Nazwa identyfikatora self nie musi być this.Może to być dowolny poprawny identyfikator.
Przypisywanie wartości do właściwości w czasie inicjowania
Można przypisać wartości do właściwości obiektu klasy w kodzie inicjalizacji przez dołączanie listy przypisań formularza property = value do listy argumentów dla konstruktora.To jest pokazane w następującym przykładzie kodu.
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)
Następująca wersja poprzedniego kodu ilustruje kombinacji zwykłych argumenty, argumentów opcjonalnych i ustawienia właściwości w wywołaniu konstruktora jednej.
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")
Konstruktory statyczne lub konstruktory typu
Oprócz określenia kodu do tworzenia obiektów statycznych let i do wiązania może być utworzony w typy klas, których wykonanie przed typu najpierw jest używany do wykonywania inicjalizacji na poziomie typu.Aby uzyskać więcej informacji, zobacz Powiązania let w klasach (F#) i do — Powiązania w klasach (F#).