Propiedades (F#)
Las propiedades son miembros que representan valores asociados a un 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
Comentarios
Las propiedades representan la relación "tiene" en la programación orientada a objetos, para representar datos asociados a instancias de objeto o, en el caso de las propiedades estáticas, al tipo.
Las propiedades se declaran mediante la palabra clave member, el valor del autoidentificador que representa la instancia actual y el nombre de la propiedad. Esta sintaxis declarativa va seguida de la sintaxis que especifica los métodos get y set, también denominados descriptores de acceso. Las diversas formas de la sintaxis mostradas se utilizan para propiedades de lectura y escritura, de solo lectura y de solo escritura. Para las propiedades de solo lectura, se define únicamente un método get; para las de solo escritura, solamente se define un método set. Cabe destacar que cuando una propiedad tiene los descriptores de acceso get y set, la sintaxis alternativa permite especificar atributos y modificadores de accesibilidad que son diferentes para cada descriptor de acceso, como se muestra en el código siguiente.
// 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
Los valores privados que contienen los datos para las propiedades se denominan dispositivos de copia de seguridad. A diferencia de otros idiomas, F# no proporciona un mecanismo para crear un dispositivo de copia de seguridad implícito para una propiedad, sino que se deben definir de manera explícita; esto suele hacerse mediante un enlace let mutable, como sigue.
type MyClass(x : string) =
let mutable myInternalValue = x
member this.MyProperty
with get() = myInternalValue
and set(value) = myInternalValue <- value
Para las propiedades de lectura y escritura, que tienen los métodos set y get, el orden de get y set se puede invertir. Como alternativa, se puede proporcionar la sintaxis mostrada para get únicamente y la sintaxis mostrada para set únicamente, en lugar de utilizar la sintaxis combinada. Esto hace que resulte más fácil marcar como comentario el método set o el get individual en caso de que sea necesario hacerlo. Esta alternativa al uso de la sintaxis combinada se muestra en el código siguiente.
member this.MyReadWriteProperty with get () = myInternalValue
member this.MyReadWriteProperty with set (value) = myInternalValue <- value
Las propiedades pueden ser miembros de clases, estructuras, uniones discriminadas, registros, interfaces y extensiones de tipo; además, se pueden definir en expresiones de objeto.
Se pueden aplicar atributos a las propiedades. Para aplicar un atributo a una propiedad, se debe escribir el atributo en una línea independiente antes de la propiedad. Para obtener más información, vea Atributos (F#).
De manera predeterminada, las propiedades son públicas. Los modificadores de accesibilidad también se pueden aplicar a las propiedades. Para aplicar un modificador de accesibilidad, se agrega inmediatamente antes del nombre de la propiedad en caso de que deba aplicarse a los métodos set y get; o bien antes de las palabras clave set y get si se necesita una accesibilidad distinta para cada descriptor de acceso. accessibility-modifier puede ser uno de los siguientes: public, private o internal. Para obtener más información, vea Control de acceso (F#).
Las implementaciones de propiedad se ejecutan cada vez que se obtiene acceso a una propiedad.
Propiedades estáticas y de instancia
Las propiedades pueden ser estáticas o de instancia. Las propiedades estáticas se pueden invocar sin una instancia y se utilizan para los valores asociados al tipo, no a objetos individuales. Para las propiedades estáticas, se omite el autoidentificador. El autoidentificador es necesario para las propiedades de instancia.
La definición de propiedad estática siguiente está basada en un escenario en el que hay un campo myStaticValue estático que es el dispositivo de copia de seguridad para la propiedad.
static member MyStaticProperty
with get() = myStaticValue
and set(value) = myStaticValue <- value
Las propiedades también pueden ser como una matriz, en cuyo caso se denominan propiedades indizadas. Para obtener más información, vea Propiedades indizadas (F#).
Anotación de tipo para las propiedades
En muchos casos, el compilador dispone de información suficiente para realizar la inferencia de tipos de una propiedad a partir del tipo del dispositivo de copia de seguridad; sin embargo, se puede establecer el tipo explícitamente agregando una anotación 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
Utilizar descriptores de acceso set de propiedad
Se pueden establecer propiedades que proporcionen descriptores de acceso set mediante el 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)
El resultado es 20
Propiedades abstractas
Las propiedades pueden ser abstractas. Como sucede con los métodos, abstracto significa tan solo que hay una distribución virtual asociada a la propiedad. Las propiedades abstractas pueden ser verdaderamente abstractas, es decir, sin una definición en la misma clase. Así pues, la clase que contiene una propiedad de este tipo es una clase abstracta. Como alternativa, el término abstracto puede significar que una propiedad es virtual, y en ese caso, debe haber una definición presente en la misma clase. Tenga en cuenta que las propiedades abstractas no deben ser privadas, y si un descriptor de acceso es abstracto, el otro también debe serlo. Para obtener más información sobre las clases abstractas, vea Clases abstractas (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