Propriétés indexées

Lors de la définition d’une classe qui extrait des données triées, il peut parfois être utile de fournir un accès indexé à ces données sans exposer l’implémentation sous-jacente. Pour cela, vous utilisez le membre Item.

Syntaxe

Syntaxe des expressions :

// Looking up an indexed property
expr[idx]

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

Syntaxe des déclarations de membre :

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

Notes

Les formes de la syntaxe précédente montrent comment définir des propriétés indexées qui ont à la fois une méthode get et une méthode set, qui ont une méthode get uniquement ou qui ont une méthode set. Vous pouvez également combiner la syntaxe affichée pour get uniquement et la syntaxe affichée pour set uniquement, et produire une propriété qui a à la fois les méthodes get et set. Cette dernière forme vous permet de placer différents modificateurs et attributs d’accessibilité sur les méthodes get et set.

Avec l’utilisation du nom Item, le compilateur traite la propriété comme une propriété indexée par défaut. Une propriété indexée par défaut est une propriété à laquelle vous pouvez accéder à l’aide d’une syntaxe de type tableau sur l’instance d’objet. Par exemple, si o est un objet du type qui définit cette propriété, la syntaxe o[index] est utilisée pour accéder à la propriété.

La syntaxe permettant d’accéder à une propriété indexée autre que celle par défaut consiste à fournir le nom de la propriété et l’index entre parenthèses, comme vous le feriez pour un membre normal. Par exemple, si la propriété sur o est appelée Ordinal, vous devez écrire o.Ordinal(index) pour y accéder.

Quelle que soit la forme que vous utilisez, vous devez toujours utiliser la forme curryfiée pour la méthode set sur une propriété indexée. Pour plus d’informations sur les fonctions curryfiées, consultez Fonctions.

Avant F# 6, la syntaxe expr.[idx] était utilisée pour l’indexation. Vous pouvez activer un avertissement informatif facultatif (/warnon:3566 ou une propriété <WarnOn>3566</WarnOn>) pour signaler les utilisations de la notation expr.[idx].

Exemple

L’exemple de code suivant illustre la définition et l’utilisation des propriétés indexées par défaut et non par défaut qui ont des méthodes get et 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

Propriétés indexées avec plusieurs valeurs d’index

Les propriétés indexées peuvent avoir plusieurs valeurs d’index. Dans ce cas, les valeurs sont séparées par des virgules lorsque la propriété est utilisée. La méthode set d’une telle propriété doit avoir deux arguments curryfiés, le premier étant un tuple contenant les clés, et le second la valeur à définir.

Le code suivant illustre l’utilisation d’une propriété indexée avec plusieurs valeurs d’index.

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

Voir aussi

• Members (Membres)