Propriedades indexadas

Ao definir uma classe que abstrai dados ordenados, às vezes pode ser útil fornecer acesso indexado a esses dados sem expor a implementação subjacente. Isso é feito com o Item membro.

Sintaxe

Sintaxe para expressões:

// Looking up an indexed property
expr[idx]

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

Sintaxe das declarações de membro:

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

Observações

As formas da sintaxe anterior mostram como definir propriedades indexadas que têm um get e um set método, têm apenas um get método ou têm apenas um set método. Você também pode combinar a sintaxe mostrada para get only e a sintaxe mostrada para set only, e produzir uma propriedade que tenha get e set. Este último formulário permite que você coloque diferentes modificadores de acessibilidade e atributos nos métodos get e set.

Usando o nome Item, o compilador trata a propriedade como uma propriedade indexada padrão. Uma propriedade indexada padrão é uma propriedade que você pode acessar usando sintaxe semelhante a uma matriz na instância do objeto. Por exemplo, se o for um objeto do tipo que define essa propriedade, a sintaxe o[index] será usada para acessar a propriedade.

A sintaxe para acessar uma propriedade indexada não padrão é fornecer o nome da propriedade e o índice entre parênteses, assim como um membro regular. Por exemplo, se a propriedade on o for chamada Ordinal, você escreve o.Ordinal(index) para acessá-la.

Independentemente do formulário usado, você sempre deve usar o formulário curried para o método set em uma propriedade indexada. Para obter informações sobre funções curried, consulte Funções.

Antes do F# 6, a sintaxe expr.[idx] era usada para indexação. Você pode ativar um aviso informativo opcional (/warnon:3366 ou propriedade <WarnOn>3366</WarnOn>) para relatar usos da expr.[idx] notação.

Exemplo

O exemplo de código a seguir ilustra a definição e o uso de propriedades indexadas padrão e não padrão que têm métodos get e 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 ""

Saída

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

Propriedades indexadas com vários valores de índice

As propriedades indexadas podem ter mais de um valor de índice. Nesse caso, os valores são separados por vírgulas quando a propriedade é usada. O método set em tal propriedade deve ter dois argumentos curried, o primeiro dos quais é uma tupla contendo as chaves, e o segundo dos quais é o valor a definir.

O código a seguir demonstra o uso de uma propriedade indexada com vários 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 também

• Membros