Propiedades indizadas

Al definir una clase que abstrae los datos ordenados, a veces puede resultar útil proporcionar acceso indexado a esos datos sin exponer la implementación subyacente. Esto se hace con el miembro Item.

Sintaxis

Sintaxis para expresiones:

// Looking up an indexed property
expr[idx]

/// Assign to an indexed property
expr[idx] <- elementExpr

Sintaxis para declaraciones de miembro:

// Indexed property that can be read and written to
member self-identifier.Item
    with get(index-values) =
        get-member-body
    and set index-values values-to-set =
        set-member-body

// Indexed property can only be read
member self-identifier.Item
    with get(index-values) =
        get-member-body

// Indexed property that can only be set
member self-identifier.Item
    with set index-values values-to-set =
        set-member-body

Comentarios

El formato de la sintaxis anterior muestra cómo definir propiedades indexadas que tienen un método get y un método set, que tienen solo un método get o que solo tienen un método set. También puede combinar la sintaxis mostrada solo para get y solo para set, y generar una propiedad que tenga tanto get como set. Este último formato permite colocar distintos modificadores y atributos de accesibilidad en los métodos get y set.

Con el nombre Item, el compilador trata la propiedad como una propiedad indexada predeterminada. Una propiedad indexada predeterminada es una propiedad a la que se puede acceder mediante una sintaxis similar a una matriz en la instancia de objeto. Por ejemplo, si o es un objeto del tipo que define esta propiedad, la sintaxis o[index] se usa para acceder a la propiedad.

La sintaxis para acceder a una propiedad indexada no predeterminada consiste en proporcionar el nombre de la propiedad y el índice entre paréntesis, al igual que con un miembro normal. Por ejemplo, si la propiedad de o se llama Ordinal, escribirá o.Ordinal(index) para acceder a ella.

Independientemente del formato que use, siempre debe usar el formato currificado para el método set en una propiedad indexada. Para más información acerca de las funciones currificadas, consulte Funciones.

Antes de F# 6, la sintaxis expr.[idx] se usaba para la indexación. Puede activar una advertencia informativa opcional (/warnon:3566 o propiedad <WarnOn>3566</WarnOn>) para notificar los usos de la notación expr.[idx].

Ejemplo

En el ejemplo de código siguiente se muestra la definición y el uso de propiedades indexadas predeterminadas y no predeterminadas que tienen métodos get y set.

type NumberStrings() =
    let mutable ordinals =
        [| "one"
           "two"
           "three"
           "four"
           "five"
           "six"
           "seven"
           "eight"
           "nine"
           "ten" |]

    let mutable cardinals =
        [| "first"
           "second"
           "third"
           "fourth"
           "fifth"
           "sixth"
           "seventh"
           "eighth"
           "ninth"
           "tenth" |]

    member this.Item
        with get (index) = ordinals[index]
        and set index value = ordinals[index] <- value

    member this.Ordinal
        with get (index) = ordinals[index]
        and set index value = ordinals[index] <- value

    member this.Cardinal
        with get (index) = cardinals[index]
        and set index value = cardinals[index] <- value

let nstrs = new NumberStrings()
nstrs[0] <- "ONE"

for i in 0..9 do
    printf "%s " nstrs[i]

printfn ""

nstrs.Cardinal(5) <- "6th"

for i in 0..9 do
    printf "%s " (nstrs.Ordinal(i))
    printf "%s " (nstrs.Cardinal(i))

printfn ""

Output

ONE two three four five six seven eight nine ten
ONE first two second three third four fourth five fifth six 6th
seven seventh eight eighth nine ninth ten tenth

Propiedades indexadas con varios valores de índice

Las propiedades indexadas pueden tener más de un valor de índice. En ese caso, los valores están separados por comas cuando se usa la propiedad. El método set de esta propiedad debe tener dos argumentos currificados, el primero de los cuales es una tupla que contiene las claves y el segundo es el valor que se va a establecer.

En el código siguiente se muestra el uso de una propiedad indexada con varios valores de índice.

open System.Collections.Generic

/// Basic implementation of a sparse matrix based on a dictionary
type SparseMatrix() =
    let table = new Dictionary<(int * int), float>()
    member _.Item
        // Because the key is comprised of two values, 'get' has two index values
        with get(key1, key2) = table[(key1, key2)]

        // 'set' has two index values and a new value to place in the key's position
        and set (key1, key2) value = table[(key1, key2)] <- value

let sm = new SparseMatrix()
for i in 1..1000 do
    sm[i, i] <- float i * float i

Consulte también

• Miembros