Proprietà (F#)
Le proprietà sono membri che rappresentano valori associati a un oggetto.
// Property that has both get and set defined.
[ attributes ]
[ static ] member [accessibility-modifier] [self-identifier.]PropertyName
with [accessibility-modifier] get() =
get-function-body
and [accessibility-modifier] set parameter =
set-function-body
// Alternative syntax for a property that has get and set.
[ attributes-for-get ]
[ static ] member [accessibility-modifier-for-get] [self-identifier.]PropertyName =
get-function-body
[ attributes-for-set ]
[ static ] member [accessibility-modifier-for-set] [self-identifier.]PropertyName
with 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.
[ attributes ]
[ static ] member [accessibility-modifier] [self-identifier.]PropertyName
with get() =
get-function-body
// Property that has set only.
[ attributes ]
[ static ] member [accessibility-modifier] [self-identifier.]PropertyName
with set parameter =
set-function-body
Note
Le proprietà rappresentano la relazione "ha" nella programmazione orientata a oggetti, rappresentando i dati associati alle istanze degli oggetti oppure, per le proprietà statiche, al tipo.
Per dichiarare le proprietà si utilizzano la parola chiave member, l'autoidentificatore che rappresenta l'istanza corrente e il nome della proprietà. Questa sintassi dichiarativa viene seguita dalla sintassi che specifica i metodi get e set, detti anche funzioni di accesso. Le diverse forme della sintassi illustrate vengono utilizzate per proprietà di lettura/scrittura, di sola lettura e di sola scrittura. Per le proprietà di sola lettura, si definisce solo un metodo get. Per le proprietà di sola scrittura, si definisce solo un metodo set. Si noti che quando una proprietà dispone di entrambe le funzioni di accesso get e set, la sintassi alternativa consente di specificare attributi e modificatori di accessibilità diversi per ogni funzione di accesso, come illustrato nel codice seguente.
// 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
I valori privati che contengono i dati per le proprietà sono detti archivi di backup. A differenza di altri linguaggi, F# non fornisce un meccanismo per la creazione di un archivio di backup implicito per una proprietà, ma è necessario definire l'archivio di backup in modo esplicito, in genere utilizzando un'associazione let modificabile, come illustrato di seguito.
type MyClass(x : string) =
let mutable myInternalValue = x
member this.MyProperty
with get() = myInternalValue
and set(value) = myInternalValue <- value
Per le proprietà di lettura/scrittura, che dispongono di entrambi i metodi get e set, è possibile invertire l'ordine di get e set. In alternativa, è possibile fornire la sintassi illustrata solo per get e la sintassi illustrata solo per set, anziché utilizzare la sintassi combinata. Questa operazione è più semplice rispetto a impostare come commento il singolo metodo get o set, qualora ciò sia necessario. Questa alternativa all'utilizzo della sintassi combinata è illustrata nel codice seguente.
member this.MyReadWriteProperty with get () = myInternalValue
member this.MyReadWriteProperty with set (value) = myInternalValue <- value
Le proprietà possono essere membri di classi, strutture, unioni discriminate, record, interfacce ed estensioni di tipo e possono anche essere definite nelle espressioni di oggetto.
Alle proprietà possono essere applicati attributi. Per applicare un attributo a una proprietà, scrivere l'attributo in una riga separata prima della proprietà. Per ulteriori informazioni, vedere Attributi (F#).
Per impostazione predefinita, le proprietà sono pubbliche. Alle proprietà possono essere applicati anche modificatori di accessibilità. Per applicare un modificatore di accessibilità, aggiungerlo immediatamente prima del nome della proprietà, se deve essere applicato a entrambi i metodi get e set. Aggiungerlo prima delle parole chiave get e set se è richiesto un tipo diverso di accessibilità per ogni funzione di accesso. Il valore di accessibility-modifier può essere public, private o internal. Per ulteriori informazioni, vedere Controllo di accesso (F#).
Le implementazioni delle proprietà vengono eseguite ogni volta che si effettua l'accesso a una proprietà.
Proprietà statiche e di istanza
Le proprietà possono essere statiche o di istanza. Le proprietà statiche possono essere richiamate senza un'istanza e vengono utilizzate per valori associati al tipo, non a singoli oggetti. Per le proprietà statiche, omettere l'autoidentificatore. L'autoidentificatore è necessario per le proprietà di istanza.
La definizione di proprietà statica seguente è basata su uno scenario in cui è presente un campo statico myStaticValue che è l'archivio di backup per la proprietà.
static member MyStaticProperty
with get() = myStaticValue
and set(value) = myStaticValue <- value
Le proprietà possono anche essere simili a matrici e in questo caso vengono dette proprietà indicizzate. Per ulteriori informazioni, vedere Proprietà indicizzate (F#).
Annotazioni di tipo per le proprietà
In molti casi, il compilatore dispone di informazioni sufficienti per derivare il tipo di una proprietà dal tipo dell'archivio di backup, ma è possibile impostare il tipo in modo esplicito aggiungendo un'annotazione di tipo.
// 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
Utilizzo delle funzioni di accesso set delle proprietà
È possibile impostare proprietà che forniscono funzioni di accesso set utilizzando l'operatore <-.
// 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)
L'output è 20.
Proprietà astratte
Le proprietà possono essere astratte. Come nel caso dei metodi, il termine astratto significa semplicemente che alla proprietà è associato un invio virtuale. Le proprietà astratte possono essere effettivamente astratte, ovvero senza una definizione nella stessa classe. La classe che contiene una proprietà di questo tipo è pertanto una classe astratta. In alternativa, il termine astratto può significare semplicemente che una proprietà è virtuale e in tal caso deve essere presente una definizione nella stessa classe. Si noti che le che proprietà astratte non devono essere private e se una funzione di accesso è astratta, anche l'altra deve esserlo. Per ulteriori informazioni sulle classi astratte, vedere Classi astratte (F#).
// 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