Tulajdonságok (F#)

A tulajdonságok olyan tagok, amelyek egy objektumhoz társított értékeket jelölnek.

Szemantika

// Property that has both get and set defined.
[ attributes ]
[ static ] member [accessibility-modifier] [self-identifier.]PropertyName
with [ attributes-for-get ] [accessibility-modifier] get() =
    get-function-body
and [ attributes-for-set ] [accessibility-modifier] set parameter =
    set-function-body

// Alternative syntax for a property that has get and set.
[ static ] member [accessibility-modifier-for-get] [self-identifier.]PropertyName
with [ attributes-for-get ] get() =
    get-function-body
[ static ] member [accessibility-modifier-for-set] [self-identifier.]PropertyName
with [ attributes-for-set ] set parameter =
    set-function-body

// Property that has get only.
[ attributes ]
[ static ] member [accessibility-modifier] [self-identifier.]PropertyName =
    get-function-body

// Alternative syntax for property that has get only.
[ static ] member [accessibility-modifier] [self-identifier.]PropertyName
with [ attributes ] get() =
    get-function-body

// Property that has set only.
[ static ] member [accessibility-modifier] [self-identifier.]PropertyName
with [ attributes ] set parameter =
    set-function-body

// Automatically implemented properties.
[ attributes ]
[ static ] member val [accessibility-modifier] PropertyName = initialization-expression [ with get, set ]

Megjegyzések

A tulajdonságok az objektumorientált programozásban a "van" kapcsolatot jelölik, amely az objektumpéldányokhoz vagy statikus tulajdonságokhoz társított adatokat jelöli a típussal.

A tulajdonságokat kétféleképpen deklarálhatja attól függően, hogy explicit módon meg szeretné-e adni a tulajdonság mögöttes értékét (más néven háttértárat), vagy engedélyezni szeretné, hogy a fordító automatikusan létrehozza a háttértárat. Általában a explicitebb módszert kell használnia, ha a tulajdonság nem triviális implementációval rendelkezik, és ha a tulajdonság csak egy egyszerű burkoló egy értékhez vagy változóhoz. Ha explicit módon szeretne deklarálni egy tulajdonságot, használja a kulcsszót member . Ezt a deklaratív szintaxist követi a függvényeket és get metódusokat set meghatározó szintaxis, más néven tartozék. A szintaxis szakaszban látható explicit szintaxis különböző formái olvasási/írási, írási és írási tulajdonságokhoz használhatók. Írásvédett tulajdonságok esetén csak egy metódust get definiálhat, írásvédett tulajdonságok esetén pedig csak egy metódust set . Vegye figyelembe, hogy ha egy tulajdonság mindkettővel get és set tartozékokkal is rendelkezik, az alternatív szintaxis lehetővé teszi, hogy az egyes tartozékokhoz különböző attribútumokat és akadálymentességi módosítókat adjon meg, ahogyan az az alábbi kódban is látható.

// A read-only property.
member this.MyReadOnlyProperty = myInternalValue
// A write-only property.
member this.MyWriteOnlyProperty with set (value) = myInternalValue <- value
// A read-write property.
member this.MyReadWriteProperty
    with get () = myInternalValue
    and set (value) = myInternalValue <- value

Olyan olvasási/írási tulajdonságok esetében, amelyek mind a mind a getset metódussal rendelkeznek, a sorrendje get és set megfordítható. Azt is megteheti, hogy a kombinált szintaxis használata helyett csak az adott szintaxist get és a megjelenített szintaxist set adja meg. Ezzel egyszerűbben megjegyzést fűzhet az egyénhez get vagy set a metódushoz, ha ezt esetleg meg kell tennie. A kombinált szintaxis helyett ez a alternatíva az alábbi kódban jelenik meg.

member this.MyReadWriteProperty with get () = myInternalValue
member this.MyReadWriteProperty with set (value) = myInternalValue <- value

A tulajdonságok adatait tároló privát értékeket háttértáraknak nevezzük. Ha azt szeretné, hogy a fordító automatikusan hozza létre a háttértárat, használja a kulcsszavakat member val, hagyja ki az önazonosítót, majd adjon meg egy kifejezést a tulajdonság inicializálásához. Ha a tulajdonságnak változékonynak kell lennie, akkor a következőket kell tartalmaznia with get, set: . Az alábbi osztálytípus például két automatikusan implementált tulajdonságot tartalmaz. Property1 írásvédett, és inicializálva van az elsődleges konstruktorhoz megadott argumentumhoz, és Property2 egy üres sztringre inicializált settable tulajdonság:

type MyClass(property1 : int) =
    member val Property1 = property1
    member val Property2 = "" with get, set

Az automatikusan implementált tulajdonságok egy típus inicializálásának részei, ezért a típusdefiníciók kötéseihez és let kötéseihez hasonlóan do minden más tagdefiníció elé kell őket foglalni. Vegye figyelembe, hogy az automatikusan implementált tulajdonságot inicializáló kifejezés csak inicializáláskor lesz kiértékelve, és a tulajdonság minden elérésekor nem. Ez a viselkedés ellentétben áll egy explicit módon implementált tulajdonság viselkedésével. Ez gyakorlatilag azt jelenti, hogy az ezeket a tulajdonságokat inicializáló kód hozzáadódik egy osztály konstruktorához. Vegye figyelembe a következő kódot, amely ezt a különbséget mutatja:

type MyClass() =
    let random  = new System.Random()
    member val AutoProperty = random.Next() with get, set
    member this.ExplicitProperty = random.Next()

let class1 = new MyClass()

printfn $"class1.AutoProperty = %d{class1.AutoProperty}"
printfn $"class1.ExplicitProperty = %d{class1.ExplicitProperty}"

Kimenet

class1.AutoProperty = 1853799794
class1.AutoProperty = 1853799794
class1.ExplicitProperty = 978922705
class1.ExplicitProperty = 1131210765

Az előző kód kimenete azt mutatja, hogy az érték AutoProperty többszöri meghíváskor változatlan, míg a ExplicitProperty hívás minden alkalommal változik. Ez azt mutatja, hogy az automatikusan implementált tulajdonság kifejezése nem minden alkalommal lesz kiértékelve, ahogyan az explicit tulajdonság getter metódusa is.

Figyelmeztetés

Vannak olyan kódtárak, mint például az Entity Framework (System.Data.Entity), amelyek egyéni műveleteket hajtanak végre az alaposztály konstruktoraiban, amelyek nem működnek megfelelően az automatikusan implementált tulajdonságok inicializálásával. Ezekben az esetekben próbáljon explicit tulajdonságokat használni.

A tulajdonságok lehetnek osztályok, struktúrák, diszkriminált uniók, rekordok, interfészek és típuskiterjesztések tagjai, és definiálhatók objektumkifejezésekben is.

Tulajdonságokra attribútumok alkalmazhatók. Ha attribútumot szeretne alkalmazni egy tulajdonságra, írja az attribútumot egy külön sorba a tulajdonság előtt. További információ: Attribútumok.

Alapértelmezés szerint a tulajdonságok nyilvánosak. Az akadálymentességi módosítók tulajdonságokra is alkalmazhatók. Az akadálymentesség-módosító alkalmazásához közvetlenül a tulajdonság neve előtt adja hozzá, ha mind a getset metódusokra, mind a metódusokra vonatkozik; adja hozzá a hozzá tartozó és a getset kulcsszavak elé, ha minden tartozékhoz más akadálymentesség szükséges. Az akadálymentesség-módosító a következők egyike lehet: public, private, internal. További információ: Hozzáférés-vezérlés.

A tulajdonságmegvalósítások minden alkalommal végrehajtásra kerülnek, amikor egy tulajdonságot elérnek.

Statikus és példánytulajdonságok

A tulajdonságok lehetnek statikus vagy példánytulajdonságok. A statikus tulajdonságok példány nélkül hívhatók meg, és a típushoz társított értékekhez használhatók, nem pedig az egyes objektumokhoz. Statikus tulajdonságok esetén hagyja ki az önazonosítót. Az önazonosító szükséges a példány tulajdonságaihoz.

Az alábbi statikus tulajdonságdefiníció egy olyan forgatókönyvön alapul, amelyben egy statikus mező myStaticValue van, amely a tulajdonság háttértárolója.

static member MyStaticProperty
    with get() = myStaticValue
    and set(value) = myStaticValue <- value

A tulajdonságok tömbszerűek is lehetnek, ebben az esetben indexelt tulajdonságoknak nevezzük őket. További információ: Indexelt tulajdonságok.

Gépelje be a tulajdonságokhoz tartozó széljegyzetet

A fordító sok esetben elegendő információval rendelkezik ahhoz, hogy a háttértár típusából következtetsen egy tulajdonság típusára, de a típust explicit módon is beállíthatja egy típusjegyzet hozzáadásával.

// To apply a type annotation to a property that does not have an explicit
// get or set, apply the type annotation directly to the property.
member this.MyProperty1 : int = myInternalValue
// If there is a get or set, apply the type annotation to the get or set method.
member this.MyProperty2 with get() : int = myInternalValue

Tulajdonságkészlet tartozékainak használata

A tartozékokat biztosító set tulajdonságokat az <- operátorral állíthatja be.

// Assume that the constructor argument sets the initial value of the
// internal backing store.
let mutable myObject = new MyType(10)
myObject.MyProperty <- 20
printfn "%d" (myObject.MyProperty)

A kimenet 20.

Absztrakt tulajdonságok

A tulajdonságok absztraktak lehetnek. A metódusokhoz hasonlóan ez is azt jelenti, abstract hogy a tulajdonsághoz tartozik egy virtuális küldés. Az absztrakt tulajdonságok valóban absztrakciósak lehetnek, vagyis definíció nélkül ugyanabban az osztályban. Az ilyen tulajdonságot tartalmazó osztály ezért absztrakt osztály. Az absztrakció azt is jelentheti, hogy egy tulajdonság virtuális, és ebben az esetben egy definíciónak ugyanabban az osztályban kell lennie. Vegye figyelembe, hogy az absztrakt tulajdonságok nem lehetnek privátak, és ha az egyik tartozék absztrakt, a másiknak absztraktnak is kell lennie. Az absztrakt osztályokról további információt az Absztrakt osztályok című témakörben talál.

// Abstract property in abstract class.
// The property is an int type that has a get and
// set method
[<AbstractClass>]
type AbstractBase() =
    abstract Property1: int with get, set

// Implementation of the abstract property
type Derived1() =
    inherit AbstractBase()
    let mutable value = 10

    override this.Property1
        with get () = value
        and set (v: int) = value <- v

// A type with a "virtual" property.
type Base1() =
    let mutable value = 10
    abstract Property1: int with get, set

    default this.Property1
        with get () = value
        and set (v: int) = value <- v

// A derived type that overrides the virtual property
type Derived2() =
    inherit Base1()
    let mutable value2 = 11

    override this.Property1
        with get () = value2
        and set (v) = value2 <- v

Lásd még

• Tagok
• Módszerek