Eigenschaften (F#)

Eigenschaften sind Elemente, die Werte darstellen, die einem Objekt zugeordnet sind.

Syntax

// 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 ]

Bemerkungen

Eigenschaften stellen die Beziehung "hat" in der objektorientierten Programmierung dar, die Daten darstellt, die Objektinstanzen zugeordnet sind, oder für statische Eigenschaften mit dem Typ.

Sie können Eigenschaften auf zwei Arten deklarieren, je nachdem, ob Sie explizit den zugrunde liegenden Wert (auch als Sicherungsspeicher bezeichnet) für die Eigenschaft angeben möchten, oder ob Sie dem Compiler erlauben möchten, den Sicherungsspeicher automatisch für Sie zu generieren. Im Allgemeinen sollten Sie die explizitere Methode verwenden, wenn die Eigenschaft über eine nicht triviale Implementierung und die automatische Methode verfügt, wenn die Eigenschaft nur ein einfacher Wrapper für einen Wert oder eine Variable ist. Verwenden Sie das member Schlüsselwort, um eine Eigenschaft explizit zu deklarieren. Auf diese deklarative Syntax folgt die Syntax, die auch getset benannte Accessoren angibt. Die verschiedenen Formen der expliziten Syntax im Syntaxabschnitt werden für Schreib-,Schreib-, Schreib- und Schreibschutzeigenschaften verwendet. Bei schreibgeschützten Eigenschaften definieren Sie nur eine get Methode; für schreibgeschützte Eigenschaften definieren Sie nur eine set Methode. Beachten Sie, dass die alternative Syntax, wenn eine Eigenschaft über beide get und set Accessoren verfügt, Attribute und Barrierefreiheitsmodifizierer angeben können, die für jeden Accessor unterschiedlich sind, wie im folgenden Code dargestellt.

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

Bei Lese-/Schreibeigenschaften, die sowohl eine als get auch eine set Methode aufweisen, kann die Reihenfolge von get und set umgekehrt werden. Alternativ können Sie die nur angezeigte get Syntax und die nur für set die Verwendung der kombinierten Syntax angezeigte Syntax angeben. Dies erleichtert das Kommentieren der Einzelnen get oder set Methoden, wenn dies etwas ist, das Sie möglicherweise tun müssen. Diese Alternative zur Verwendung der kombinierten Syntax wird im folgenden Code gezeigt.

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

Private Werte, die die Daten für Eigenschaften enthalten, werden als Sicherungsspeicher bezeichnet. Damit der Compiler den Sicherungsspeicher automatisch erstellt, verwenden Sie die Schlüsselwörter member val, lassen Sie den Selbstbezeichner aus, und geben Sie dann einen Ausdruck zum Initialisieren der Eigenschaft an. Wenn die Eigenschaft änderbar sein soll, schließen Sie ein with get, set. Der folgende Klassentyp enthält beispielsweise zwei automatisch implementierte Eigenschaften. Property1 ist schreibgeschützt und wird für das Argument initialisiert, das für den primären Konstruktor bereitgestellt wird, und Property2 eine settable-Eigenschaft, die in eine leere Zeichenfolge initialisiert wird:

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

Automatisch implementierte Eigenschaften sind Teil der Initialisierung eines Typs, daher müssen sie vor allen anderen Memberdefinitionen eingeschlossen werden, genau wie let Bindungen und do Bindungen in einer Typdefinition. Beachten Sie, dass der Ausdruck, der eine automatisch implementierte Eigenschaft initialisiert, nur bei der Initialisierung ausgewertet wird und nicht bei jedem Zugriff auf die Eigenschaft. Dieses Verhalten steht im Gegensatz zum Verhalten einer explizit implementierten Eigenschaft. Dies bedeutet effektiv, dass der Code zum Initialisieren dieser Eigenschaften dem Konstruktor einer Klasse hinzugefügt wird. Beachten Sie den folgenden Code, der diesen Unterschied zeigt:

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

Output

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

Die Ausgabe des vorherigen Codes zeigt, dass der Wert unverändert AutoProperty bleibt, wenn er wiederholt aufgerufen wird, während die ExplicitProperty Änderungen bei jedem Aufruf vorgenommen werden. Dies zeigt, dass der Ausdruck für eine automatisch implementierte Eigenschaft nicht jedes Mal ausgewertet wird, wie die Getter-Methode für die explizite Eigenschaft.

Warnung

Es gibt einige Bibliotheken, z. B. das Entity Framework (System.Data.Entity), die benutzerdefinierte Vorgänge in Basisklassenkonstruktoren ausführen, die nicht gut mit der Initialisierung automatisch implementierter Eigenschaften funktionieren. Versuchen Sie in diesen Fällen, explizite Eigenschaften zu verwenden.

Eigenschaften können Elemente von Klassen, Strukturen, diskriminierten Vereinigungen, Datensätzen, Schnittstellen und Typerweiterungen sein und auch in Objektausdrücken definiert werden.

Attribute können auf Eigenschaften angewendet werden. Wenn Sie ein Attribut auf eine Eigenschaft anwenden möchten, schreiben Sie das Attribut in einer separaten Zeile vor der Eigenschaft. Weitere Informationen finden Sie unter Attribute.

Standardmäßig sind Eigenschaften öffentlich. Modifizierer für Barrierefreiheit können auch auf Eigenschaften angewendet werden. Wenn Sie einen Modifizierer für Barrierefreiheit anwenden möchten, fügen Sie ihn unmittelbar vor dem Namen der Eigenschaft hinzu, wenn sie sowohl auf die Methoden get als auch auf die set Methoden angewendet werden soll. Fügen Sie ihn vor den get Schlüsselwörtern hinzuset, wenn für jeden Accessor unterschiedliche Barrierefreiheit erforderlich ist. Der Modifizierer für Barrierefreiheit kann eine der folgenden Sein: public, , privateinternal. Weitere Informationen finden Sie unter Access Control.

Eigenschaftenimplementierungen werden jedes Mal ausgeführt, wenn auf eine Eigenschaft zugegriffen wird.

Statische Eigenschaften und Instanzeigenschaften

Eigenschaften können statisch oder Instanzeigenschaften sein. Statische Eigenschaften können ohne Eine Instanz aufgerufen werden und werden für Werte verwendet, die dem Typ zugeordnet sind, nicht mit einzelnen Objekten. Bei statischen Eigenschaften lassen Sie den Selbstbezeichner weg. Der Selbstbezeichner ist für Instanzeigenschaften erforderlich.

Die folgende definition statische Eigenschaft basiert auf einem Szenario, in dem Sie über ein statisches Feld myStaticValue verfügen, das der Sicherungsspeicher für die Eigenschaft ist.

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

Eigenschaften können auch arrayähnliche Eigenschaften sein, in diesem Fall werden sie als indizierte Eigenschaften bezeichnet. Weitere Informationen finden Sie unter "Indizierte Eigenschaften".

Typanmerkung für Eigenschaften

In vielen Fällen verfügt der Compiler über genügend Informationen, um den Typ einer Eigenschaft vom Typ des Sicherungsspeichers abzuleiten, Aber Sie können den Typ explizit festlegen, indem Sie eine Typanmerkung hinzufügen.

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

Verwenden von Eigenschaftensatz-Accessoren

Sie können Eigenschaften festlegen, die Accessoren bereitstellen set , indem Sie den <- Operator verwenden.

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

Die Ausgabe ist 20.

Abstrakte Eigenschaften

Eigenschaften können abstrakt sein. Wie bei Methoden bedeutet dies nur, abstract dass der Eigenschaft ein virtueller Verteiler zugeordnet ist. Abstrakte Eigenschaften können wirklich abstrakt sein, d. h. ohne Definition in derselben Klasse. Die Klasse, die eine solche Eigenschaft enthält, ist daher eine abstrakte Klasse. Alternativ kann abstrakt einfach bedeuten, dass eine Eigenschaft virtuell ist, und in diesem Fall muss eine Definition in derselben Klasse vorhanden sein. Beachten Sie, dass abstrakte Eigenschaften nicht privat sein dürfen, und wenn ein Accessor abstrakt ist, muss die andere auch abstrakt sein. Weitere Informationen zu abstrakten Klassen finden Sie unter Abstrakte Klassen.

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

Siehe auch

• Mitglieder
• Methodik