Geïndexeerde eigenschappen

Bij het definiëren van een klasse die abstract is van geordende gegevens, kan het soms handig zijn om geïndexeerde toegang tot die gegevens te bieden zonder de onderliggende implementatie weer te geven. Dit gebeurt met het Item lid.

Syntaxis

Syntaxis voor expressies:

// Looking up an indexed property
expr[idx]

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

Syntaxis voor liddeclaraties:

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

Opmerkingen

De formulieren van de vorige syntaxis laten zien hoe u geïndexeerde eigenschappen definieert die zowel een get als een set methode hebben, alleen een get methode hebben of alleen een set methode hebben. U kunt ook zowel de syntaxis die wordt weergegeven voor alleen ophalen en de syntaxis die wordt weergegeven voor alleen instellen, combineren en een eigenschap produceren die zowel get als set bevat. Met dit laatste formulier kunt u verschillende toegankelijkheidsaanpassingen en -kenmerken op de get- en set-methoden plaatsen.

Door de naam Itemte gebruiken, behandelt de compiler de eigenschap als een standaard geïndexeerde eigenschap. Een standaard geïndexeerde eigenschap is een eigenschap die u kunt openen met behulp van een matrixachtige syntaxis op het objectexemplaren. Als dit bijvoorbeeld o een object is van het type dat deze eigenschap definieert, wordt de syntaxis o[index] gebruikt voor toegang tot de eigenschap.

De syntaxis voor het openen van een niet-standaard geïndexeerde eigenschap is het opgeven van de naam van de eigenschap en de index tussen haakjes, net als een normaal lid. Als de eigenschap bijvoorbeeld wordt aangeroepen oOrdinal, schrijft o.Ordinal(index) u om deze te openen.

Ongeacht welk formulier u gebruikt, moet u altijd het curriede formulier gebruiken voor de ingestelde methode voor een geïndexeerde eigenschap. Zie Functies voor meer informatie over curriede functies.

Vóór F# 6 werd de syntaxis expr.[idx] gebruikt voor indexering. U kunt een optionele informatieve waarschuwing (/warnon:3366 of eigenschap <WarnOn>3366</WarnOn>) activeren om gebruik van de expr.[idx] notatie te rapporteren.

Opmerking

In het volgende codevoorbeeld ziet u de definitie en het gebruik van standaard- en niet-standaard geïndexeerde eigenschappen met get- en setmethoden.

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

Uitvoer

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

Geïndexeerde eigenschappen met meerdere indexwaarden

Geïndexeerde eigenschappen kunnen meer dan één indexwaarde hebben. In dat geval worden de waarden gescheiden door komma's wanneer de eigenschap wordt gebruikt. De ingestelde methode in een dergelijke eigenschap moet twee gecureerde argumenten hebben, waarvan de eerste een tuple is die de sleutels bevat en waarvan de tweede de waarde is die moet worden ingesteld.

De volgende code toont het gebruik van een geïndexeerde eigenschap met meerdere indexwaarden.

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

Zie ook

• Leden