Indexerade egenskaper

När du definierar en klass som abstraherar över ordnade data kan det ibland vara bra att ge indexerad åtkomst till dessa data utan att exponera den underliggande implementeringen. Detta görs med Item medlemmen.

Syntax

Syntax för uttryck:

// Looking up an indexed property
expr[idx]

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

Syntax för medlemsdeklarationer:

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

Kommentarer

Formerna i den tidigare syntaxen visar hur du definierar indexerade egenskaper som har både en get och en set metod, endast har en get metod eller bara har en set metod. Du kan också kombinera både syntaxen som visas för get och syntaxen som endast visas för set och skapa en egenskap som har både get och set. Med det här senare formuläret kan du placera olika hjälpmedelsmodifierare och attribut på get- och set-metoderna.

Med hjälp av namnet Itembehandlar kompilatorn egenskapen som en standardindexerad egenskap. En standardindexerad egenskap är en egenskap som du kan komma åt med hjälp av matrisliknande syntax på objektinstansen. Om o till exempel är ett objekt av den typ som definierar den här egenskapen används syntaxen o[index] för att komma åt egenskapen.

Syntaxen för åtkomst till en icke-standardindexerad egenskap är att ange namnet på egenskapen och indexet inom parenteser, precis som en vanlig medlem. Om egenskapen på o till exempel heter Ordinalskriver du o.Ordinal(index) för att komma åt den.

Oavsett vilket formulär du använder bör du alltid använda formuläret curryform för den angivna metoden på en indexerad egenskap. Information om funktioner i curry finns i Functions.

Före F# 6 användes syntaxen expr.[idx] för indexering. Du kan aktivera en valfri informationsvarning (/warnon:3566 eller egenskap <WarnOn>3566</WarnOn>) för att rapportera användning av notationen expr.[idx] .

Exempel

Följande kodexempel illustrerar definitionen och användningen av standard- och icke-standardindexerade egenskaper som har get- och set-metoder.

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

Indexerade egenskaper med flera indexvärden

Indexerade egenskaper kan ha mer än ett indexvärde. I så fall avgränsas värdena med kommatecken när egenskapen används. Den angivna metoden i en sådan egenskap måste ha två argument, varav den första är en tuppeln som innehåller nycklarna och den andra är värdet som ska anges.

Följande kod visar användningen av en indexerad egenskap med flera indexvärden.

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

Se även

• Medlemmar