Açık Alanlar: val Anahtar Sözcüğü

anahtar val sözcüğü, bir değeri başlatmadan bir sınıf veya yapı türünde depolamak üzere bir konum bildirmek için kullanılır. Bu şekilde bildirilen depolama konumları açık alanlar olarak adlandırılır. Anahtar sözcüğün val başka bir kullanımı, otomatik olarak uygulanan bir özelliği bildirmek için anahtar sözcükle member birlikte kullanılır. Otomatik olarak uygulanan özellikler hakkında daha fazla bilgi için bkz . Özellikler.

Sözdizimi

val [ mutable ] [ access-modifier ] field-name : type-name

Açıklamalar

Bir sınıf veya yapı türündeki alanları tanımlamanın normal yolu bağlama let kullanmaktır. Bununla birlikte, let bağlamalar her zaman mümkün, gerekli veya arzu edilmeyen sınıf oluşturucusunun bir parçası olarak başlatılmalıdır. Başlatılmamış bir alan istediğinizde anahtar sözcüğünü kullanabilirsiniz val .

Açık alanlar statik veya statik olmayabilir. Erişim değiştirici , privateveya internalolabilirpublic. Varsayılan olarak, açık alanlar geneldir. Bu, her zaman özel olan sınıflardaki bağlamalardan let farklıdır.

DefaultValue özniteliği, birincil oluşturucuya sahip sınıf türlerindeki açık alanlarda gereklidir. Bu öznitelik, alanın sıfıra başlatıldığını belirtir. Alanın türü sıfır başlatmayı desteklemelidir. Bir tür, aşağıdakilerden biriyse sıfır başlatmayı destekler:

• Sıfır değerine sahip ilkel bir tür.
• Normal bir değer olarak, anormal bir değer olarak veya bir değerin gösterimi olarak null değeri destekleyen bir tür. Bu sınıflar, tanımlama kümeleri, kayıtlar, işlevler, arabirimler, .NET başvuru türleri, unit türü ve ayrımcı birleşim türlerini içerir.
• .NET değer türü.
• Tüm alanları varsayılan sıfır değerini destekleyen bir yapı.

Örneğin, adlı someField sabit bir alanın .NET derlenmiş gösteriminde adıyla someField@bir yedekleme alanı vardır ve adlı someFieldbir özelliği kullanarak depolanan değere erişebilirsiniz.

Değiştirilebilir bir alan için .NET derlenmiş gösterimi bir .NET alanıdır.

Aşağıdaki kod, açık alanların ve karşılaştırma let için birincil oluşturucuya sahip bir sınıftaki bağlamanın kullanımını gösterir. İlişkili letalanın myInt1 özel olduğunu unutmayın. letBir üye yönteminden -bound alanına myInt1 başvurulduğunda, kendi tanımlayıcısı this gerekli değildir. Ancak ve açık alanlarına myInt2 myStringbaşvururken kendi tanımlayıcısı gereklidir.

type MyType() =
    let mutable myInt1 = 10
    [<DefaultValue>] val mutable myInt2 : int
    [<DefaultValue>] val mutable myString : string
    member this.SetValsAndPrint( i: int, str: string) =
       myInt1 <- i
       this.myInt2 <- i + 1
       this.myString <- str
       printfn "%d %d %s" myInt1 (this.myInt2) (this.myString)

let myObject = new MyType()
myObject.SetValsAndPrint(11, "abc")
// The following line is not allowed because let bindings are private.
// myObject.myInt1 <- 20
myObject.myInt2 <- 30
myObject.myString <- "def"

printfn "%d %s" (myObject.myInt2) (myObject.myString)

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

11 12 abc
30 def

Aşağıdaki kod, birincil oluşturucuya sahip olmayan bir sınıfta açık alanların kullanımını gösterir. Bu durumda, DefaultValue özniteliği gerekli değildir, ancak türü için tanımlanan oluşturucularda tüm alanların başlatılması gerekir.

type MyClass =
    val a : int
    val b : int
    // The following version of the constructor is an error
    // because b is not initialized.
    // new (a0, b0) = { a = a0; }
    // The following version is acceptable because all fields are initialized.
    new(a0, b0) = { a = a0; b = b0; }

let myClassObj = new MyClass(35, 22)
printfn "%d %d" (myClassObj.a) (myClassObj.b)

Çıkış 35 22 olur.

Aşağıdaki kod, bir yapıda açık alanların kullanımını gösterir. Yapı bir değer türü olduğundan, otomatik olarak alanlarının değerlerini sıfır olarak ayarlayan parametresiz bir oluşturucuya sahiptir. Bu nedenle, DefaultValue özniteliği gerekli değildir.

type MyStruct =
    struct
        val mutable myInt : int
        val mutable myString : string
    end

let mutable myStructObj = new MyStruct()
myStructObj.myInt <- 11
myStructObj.myString <- "xyz"

printfn "%d %s" (myStructObj.myInt) (myStructObj.myString)

Çıkış 11 xyz olur.

Yapınızı anahtar sözcük kullanmadan mutable alanlarla mutable başlatacaksanız, atamalarınız atamadan hemen sonra atılacak bir yapı kopyası üzerinde çalışır. Bu nedenle yapınız değişmez.

[<Struct>]
type Foo =
    val mutable bar: string
    member self.ChangeBar bar = self.bar <- bar
    new (bar) = {bar = bar}

let foo = Foo "1"
foo.ChangeBar "2" //make implicit copy of Foo, changes the copy, discards the copy, foo remains unchanged
printfn "%s" foo.bar //prints 1

let mutable foo' = Foo "1"
foo'.ChangeBar "2" //changes foo'
printfn "%s" foo'.bar //prints 2

Açık alanlar rutin kullanım için tasarlanmamıştır. Genel olarak, mümkün olduğunda açık bir let alan yerine bir sınıfta bağlama kullanmanız gerekir. Açık alanlar, platform çağrısında kullanılacak bir yapıyı tanımlamanız gerektiğinde yerel API'ye veya COM birlikte çalışma senaryolarında olduğu gibi bazı birlikte çalışabilirlik senaryolarında kullanışlıdır. Daha fazla bilgi için bkz . Dış İşlevler. Açık bir alanın gerekli olabileceği bir diğer durum da, birincil oluşturucu olmadan sınıfları yayan bir F# kod oluşturucu ile çalıştığınız durumlardır. Açık alanlar, iş parçacığı statik değişkenleri veya benzer yapılar için de yararlıdır. Daha fazla bilgi için bkz. System.ThreadStaticAttribute.

Anahtar sözcükler member val bir tür tanımında birlikte görüntülendiğinde, otomatik olarak uygulanan özelliğin tanımıdır. Daha fazla bilgi için bkz . Özellikler.

Ayrıca bkz.

• Veri Erişimi
• Üyeler
• let Sınıflardaki Bağlamalar