Naamvan

De nameof expressie produceert een tekenreeksconstante die overeenkomt met de naam in de bron voor vrijwel elke F#-constructie in de bron.

Syntaxis

nameof symbol
nameof<'TGeneric>

Opmerkingen

nameof werkt door het symbool dat aan het symbool is doorgegeven, op te lossen en de naam van dat symbool te produceren, zoals het wordt gedeclareerd in uw broncode. Dit is handig in verschillende scenario's, zoals logboekregistratie en beschermt uw logboekregistratie tegen wijzigingen in de broncode.

let months =
    [
        "January"; "February"; "March"; "April";
        "May"; "June"; "July"; "August"; "September";
        "October"; "November"; "December"
    ]

let lookupMonth month =
    if (month > 12 || month < 1) then
        invalidArg (nameof month) ($"Value passed in was %d{month}.")

    months[month-1]

printfn "%s" (lookupMonth 12)
printfn "%s" (lookupMonth 1)
printfn "%s" (lookupMonth 13)

De laatste regel genereert een uitzondering en "month" wordt weergegeven in het foutbericht.

U kunt bijna elke F#-constructie een naam nemen:

module M =
    let f x = nameof x

printfn $"{(M.f 12)}"
printfn $"{(nameof M)}"
printfn $"{(nameof M.f)}"

nameof is geen eersteklas functie en kan niet als zodanig worden gebruikt. Dit betekent dat deze niet gedeeltelijk kan worden toegepast en dat waarden niet via F#-pijplijnoperators kunnen worden doorgesluisd.

Naam van operators

Operators in F# kunnen op twee manieren worden gebruikt, als operatortekst zelf of een symbool dat het gecompileerde formulier vertegenwoordigt. nameof op een operator wordt de naam van de operator geproduceerd zoals deze in de bron wordt gedeclareerd. Gebruik de gecompileerde naam in de bron om de gecompileerde naam op te halen:

nameof(+) // "+"
nameof op_Addition // "op_Addition"

Naamvan op generieken

U kunt ook een naam van een algemene typeparameter gebruiken, maar de syntaxis is anders:

let f<'a> () = nameof<'a>
f() // "a"

nameof<'TGeneric> neemt de naam van het symbool op zoals gedefinieerd in de bron, niet de naam van het type dat wordt vervangen door een oproepsite.

De reden waarom de syntaxis verschilt, is uitlijnen op andere intrinsieke F#-operators zoals typeof<> en typedefof<>. Dit maakt F# consistent met betrekking tot operators die handelen op algemene typen en alles in de bron.

Naamvan in patroonkoppeling

Met nameof het patroon kunt u een patroonovereenkomstexpressie gebruiken nameof . Dit is met name handig bij het vergelijken van tekenreekswaarden ten opzichte van de namen van symbolen in uw code, waardoor de veiligheid van de compilatietijd en automatische updates worden geboden wanneer u de herstructurering uitvoert.

Een praktisch voorbeeld is het deserialiseren van gebeurtenissen of berichten waarbij tekenreekswaarden type- of casenamen vertegenwoordigen:

type EventType =
    | OrderCreated
    | OrderShipped
    | OrderDelivered

let handleEvent eventName data =
    match eventName with
    | nameof OrderCreated -> printfn "Processing order creation: %s" data
    | nameof OrderShipped -> printfn "Processing order shipment: %s" data
    | nameof OrderDelivered -> printfn "Processing order delivery: %s" data
    | _ -> printfn "Unknown event type: %s" eventName

handleEvent "OrderCreated" "Order #123" // matches first case

Het gebruik nameof van letterlijke tekenreeksen in plaats van letterlijke tekenreeksen "OrderCreated" biedt verschillende voordelen:

• Als u de naam van een gediscrimineerde samenvoegingscase wijzigt, wordt het patroon automatisch bijgewerkt.
• De compiler voorkomt typfouten door ervoor te zorgen dat het symbool bestaat.
• Uw code blijft consistent tijdens het herstructureren.

U kunt ook gebruiken nameof met parameters:

let f (str: string) =
    match str with
    | nameof str -> "It's 'str'!"
    | _ -> "It is not 'str'!"

f "str" // matches
f "asdf" // does not match

Naamvan met exemplaarleden

F# vereist een exemplaar om de naam van een exemplaarlid met nameofte extraheren. Als een exemplaar niet eenvoudig beschikbaar is, kan er een worden verkregen met behulp van Unchecked.defaultof.

type MyRecord = { MyField: int }
type MyClass() =
    member _.MyProperty = ()
    member _.MyMethod () = ()

nameof Unchecked.defaultof<MyRecord>.MyField   // MyField
nameof Unchecked.defaultof<MyClass>.MyProperty // MyProperty
nameof Unchecked.defaultof<MyClass>.MyMethod   // MyMethod