Oluşturucular

Bu makalede, sınıf ve yapı nesneleri oluşturmak ve başlatmak için oluşturucuların nasıl tanımlanacağı ve kullanılacağı açıklanmaktadır.

Sınıf nesnelerinin oluşturulması

Sınıf türlerinin nesnelerinin oluşturucuları vardır. İki tür oluşturucu vardır. Biri, parametreleri tür adından hemen sonra parantez içinde görünen birincil oluşturucudur. Anahtar sözcüğünü new kullanarak diğer isteğe bağlı ek oluşturucuları belirtirsiniz. Bu tür ek oluşturucuların birincil oluşturucuyu çağırması gerekir.

Birincil oluşturucu, sınıf tanımının başında görünen ve do bağlamalarını içerirlet. Bağlama let , sınıfın özel alanlarını ve yöntemlerini bildirir; bağlama do kodu yürütür. Sınıf oluşturucularındaki bağlamalar hakkında let daha fazla bilgi için bkz let . Sınıflardaki Bağlamalar. Oluşturuculardaki bağlamalar hakkında do daha fazla bilgi için bkz do . Sınıflardaki Bağlamalar.

Çağırmak istediğiniz oluşturucunun birincil oluşturucu veya ek bir oluşturucu olmasına bakılmaksızın, isteğe bağlı new anahtar sözcükle veya anahtar sözcük olmadan bir new ifade kullanarak nesneler oluşturabilirsiniz. Bağımsız değişkenleri sıralı ve virgülle ayırıp parantez içine alarak ya da parantez içinde adlandırılmış bağımsız değişkenler ve değerler kullanarak nesnelerinizi oluşturucu bağımsız değişkenleriyle birlikte başlatırsınız. Ayrıca, nesnenin oluşturulması sırasında özellik adlarını kullanarak ve adlandırılmış oluşturucu bağımsız değişkenlerini kullandığınız gibi değerler atayarak nesnenin özelliklerini ayarlayabilirsiniz.

Aşağıdaki kod, oluşturucuya sahip bir sınıfı ve nesneleri oluşturmanın çeşitli yollarını gösterir:

// 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()

Çıktı aşağıdaki şekilde olacaktır:

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)

Yapıların inşası

Yapılar sınıfların tüm kurallarını izler. Bu nedenle, bir birincil oluşturucunuz olabilir ve kullanarak newek oluşturucular sağlayabilirsiniz. Ancak, yapılar ve sınıflar arasında önemli bir fark vardır: birincil oluşturucu tanımlanmasa bile yapıların parametresiz bir oluşturucu (bağımsız değişken içermeyen bir oluşturucu) olabilir. Parametresiz oluşturucu, tüm alanları bu tür için varsayılan değere (genellikle sıfır veya eşdeğeri) başlatır. Yapılar için tanımladığınız tüm oluşturucuların parametresiz oluşturucuyla çakışmaması için en az bir bağımsız değişkeni olmalıdır.

Ayrıca, yapıların genellikle anahtar sözcüğü kullanılarak val oluşturulan alanları vardır; sınıflar da bu alanlara sahip olabilir. Aşağıdaki kodda gösterildiği gibi, anahtar sözcüğü kullanılarak val tanımlanan alanları olan yapılar ve sınıflar, kayıt ifadeleri kullanılarak ek oluşturucularda da başlatılabilir.

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)

Daha fazla bilgi için bkz . Açık Alanlar: Anahtar val Sözcük.

Oluşturucularda yan etkileri yürütme

Bir sınıftaki birincil oluşturucu bağlamada do kod yürütebilir. Ancak, bağlama olmadan do ek bir oluşturucuda kod yürütmeniz gerekiyorsa ne olur? Bunu yapmak için anahtar sözcüğünü then kullanırsınız.

 // 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()

Birincil oluşturucunun yan etkileri yine yürütülür. Bu nedenle, çıkış aşağıdaki gibidir:

Created a person object.
Created a person object.
Created an invalid person object.

Başka bir do yerine gerekli olmasının nedenithen, anahtar sözcüğün do ek bir oluşturucunun gövdesinde mevcut olduğunda bir unit-dönüş ifadesini sınırlandırmak için standart anlamı olmasıdır. Yalnızca birincil oluşturucular bağlamında özel bir anlamı vardır.

Oluşturucularda kendi kendine tanımlayıcılar

Diğer üyelerde, her üyenin tanımında geçerli nesne için bir ad sağlarsınız. Oluşturucu parametrelerinin hemen ardından anahtar sözcüğünü kullanarak kendi kendine tanımlayıcıyı as sınıf tanımının ilk satırına da yerleştirebilirsiniz. Aşağıdaki örnekte bu söz dizimi gösterilmektedir.

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

Ek oluşturucularda, yan tümcesini oluşturucu parametrelerinin as hemen arkasına koyarak bir self tanımlayıcı da tanımlayabilirsiniz. Aşağıdaki örnekte bu söz dizimi gösterilmektedir:

type MyClass2(x : int) =
    member this.X = x
    new() as this = MyClass2(0) then printfn "Initializing with X = %d" this.X

Bir nesneyi tam olarak tanımlanmadan önce kullanmayı denediğinizde sorunlar oluşabilir. Bu nedenle, kendi tanımlayıcısının kullanımları derleyicinin bir uyarı yaymasına ve nesne başlatılmadan önce bir nesnenin üyelerine erişilmediğinden emin olmak için ek denetimler eklemesine neden olabilir. Kendi tanımlayıcısını yalnızca birincil oluşturucunun do bağlamalarında veya ek oluşturucularda anahtar sözcüğünden then sonra kullanmanız gerekir.

Kendi tanımlayıcısının adı olması thisgerekmez. Herhangi bir geçerli tanımlayıcı olabilir.

Başlatma sırasında özelliklere değer atama

Bir oluşturucunun bağımsız değişken listesine formun property = value atamalarının listesini ekleyerek başlatma kodundaki bir sınıf nesnesinin özelliklerine değerler atayabilirsiniz. Bu, aşağıdaki kod örneğinde gösterilmiştir:

 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)

Önceki kodun aşağıdaki sürümü, bir oluşturucu çağrısında normal bağımsız değişkenlerin, isteğe bağlı bağımsız değişkenlerin ve özellik ayarlarının birleşimini gösterir:

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")

Devralınan sınıftaki oluşturucular

Oluşturucuya sahip bir temel sınıftan devralırken, inherit yan tümcesinde bağımsız değişkenlerini belirtmeniz gerekir. Daha fazla bilgi için bkz . Oluşturucular ve devralma.

Statik oluşturucular veya tür oluşturucuları

Nesne oluşturmak için kod belirtmeye ek olarak, tür ilk kez tür düzeyinde başlatma gerçekleştirmek için kullanılmadan önce yürütülen sınıf türlerinde statik let ve do bağlamalar yazılabilir. Daha fazla bilgi için bkzlet. Sınıflardaki Bağlamalar vedoSınıflardaki Bağlamalar.

Ayrıca bkz.

• Üyeler