Propriedades (F#)
Propriedades são os membros que representam os valores associados a um objeto.
// 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
Comentários
Propriedades representam o "tem um" relacionamento na programação orientada a objeto, que representa os dados que está associados com instâncias de objeto ou, para propriedades estáticas, com o tipo.
Você declara propriedades usando o member palavra-chave, o valor do identificador de auto-que representa a instância atual e o nome da propriedade. Essa sintaxe declarativa é seguido pela sintaxe que especifica o get e set métodos, também denominados acessadores. As várias formas de sintaxe mostradas são usadas para propriedades de leitura/gravação somente para leitura e somente para gravação. As propriedades somente leitura, defina apenas um get método; as propriedades somente para gravação, definir apenas uma set método. Observe que, quando uma propriedade tem ambos get e set acessadores, a sintaxe alternativa permite especificar os atributos e os modificadores de acessibilidade que são diferentes para cada acessador é mostrado no código a seguir.
// 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
Private que mantenha os dados para propriedades que são chamados de valores fazendo armazenamentos. Ao contrário de outras linguagens, F# não fornecem um mecanismo para criar um armazenamento de backup implícita para uma propriedade; Você deve definir os armazenamentos de backup explicitamente, normalmente usando um mutável let a ligação, como segue:
type MyClass(x : string) =
let mutable myInternalValue = x
member this.MyProperty
with get() = myInternalValue
and set(value) = myInternalValue <- value
As propriedades de leitura/gravação, que têm ambos um get e set método, a ordem de get e set pode ser revertido. Como alternativa, você pode fornecer a sintaxe mostrada para get somente e a sintaxe mostrada para set somente em vez de usar a sintaxe combinada. Isso facilita a comentar o indivíduo get ou set método, se isso é algo que talvez você precise fazer. Essa alternativa usando a sintaxe combinada é mostrada no código a seguir.
member this.MyReadWriteProperty with get () = myInternalValue
member this.MyReadWriteProperty with set (value) = myInternalValue <- value
Propriedades podem ser membros de classes, estruturas, uniões discriminadas, registros, interfaces e extensões de tipo e também podem ser definidas em expressões de objeto.
Atributos podem ser aplicados às propriedades. Para aplicar um atributo a uma propriedade, grave o atributo em uma linha separada antes da propriedade. Para obter mais informações, consulte Atributos (F#).
Por padrão, as propriedades são públicas. Modificadores de acessibilidade também podem ser aplicadas às propriedades. Para aplicar um modificador de acessibilidade, adicioná-lo imediatamente antes do nome da propriedade se ele é destinado a aplicar a ambas as get e set métodos; adicioná-lo antes de get e set as palavras-chave, se a acessibilidade diferente é necessária para cada acessador. O accessibility-modifier pode ser uma das seguintes opções: public, private, internal. Para obter mais informações, consulte Controle de acesso (F#).
Implementações de propriedade são executadas cada vez que uma propriedade é acessada.
Estático e as propriedades da instância
Propriedades podem ser estáticos ou propriedades da ocorrência. Propriedades estáticas podem ser chamadas sem uma instância e são usadas para valores associados ao tipo, não com objetos individuais. Propriedades estáticas, omita o identificador de self. O identificador de auto-é necessário para as propriedades da instância.
A seguinte definição da propriedade estática se baseia em um cenário em que você tem um campo estático myStaticValue isto é o armazenamento de backup para a propriedade.
static member MyStaticProperty
with get() = myStaticValue
and set(value) = myStaticValue <- value
Propriedades também podem ser semelhante ao array, caso em que eles são chamados de indexado propriedades. Para obter mais informações, consulte Propriedades indexadas (F#).
Anotação de tipo para propriedades
Em muitos casos, o compilador não tem informações suficientes para inferir o tipo de uma propriedade do tipo de armazenamento de backup, mas você pode definir explicitamente o tipo, adicionando uma anotação de 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
Usando a propriedade definir acessadores
Você pode definir propriedades que fornecem set acessadores usando o <- operador.
// 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 saída é 20.
Propriedades abstratas
Propriedades podem ser abstract. Como ocorre com os métodos, abstrata apenas significa que há um despacho virtual associado com a propriedade. Propriedades abstratas podem ser verdadeiramente abstratas, ou seja, sem uma definição na mesma classe. Portanto, a classe que contém essa propriedade é uma classe abstrata. Como alternativa, o resumo apenas pode significar que uma propriedade é virtual e, nesse caso, uma definição deve estar presente na mesma classe. Observe que propriedades abstratas não devem ser privadas e, se um acessador é abstrato, o outro também deve ser abstrato. Para obter mais informações sobre classes abstratas, consulte Classes abstratas (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