Nameof

La expresión genera una constante de cadena que coincide con el nombre nameof del origen para casi cualquier construcción de F# en source.

Sintaxis

nameof symbol
nameof<'TGeneric>

Comentarios

nameof funciona resolviendo el símbolo que se le ha pasado y genera el nombre de ese símbolo tal como se declara en el código fuente. Esto es útil en varios escenarios, como el registro, y protege el registro frente a cambios en el código fuente.

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)

La última línea producirá una excepción y "month" se mostrará en el mensaje de error.

Puede tomar un nombre de casi todas las construcciones de F#:

module M =
    let f x = nameof x

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

nameof no es una función de primera clase y no se puede usar como tal. Esto significa que no se puede aplicar parcialmente y los valores no se pueden canalizar a ella a través de operadores de canalización de F#.

Nameof en los operadores

Los operadores de F# se pueden usar de dos maneras, como un propio texto de operador o un símbolo que representa el formulario compilado. nameof en un operador producirá el nombre del operador tal como se declara en source. Para obtener el nombre compilado, use el nombre compilado en el origen:

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

Nameof en genéricos

También puede tomar un nombre de un parámetro de tipo genérico, pero la sintaxis es diferente:

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

nameof<'TGeneric> tomará el nombre del símbolo tal como se define en source, no el nombre del tipo sustituido en un sitio de llamada.

La razón por la que la sintaxis es diferente es alinearse con otros operadores intrínsecos de F#, typeof<> como y typedefof<> . Esto hace que F# sea coherente con respecto a los operadores que actúan sobre tipos genéricos y cualquier otra cosa en el origen.

Nameof en la coincidencia de patrones

El nameof patrón le permite usar en nameof una expresión de coincidencia de patrón como la siguiente:

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

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

Nameof con miembros de instancia

F# requiere una instancia de para extraer el nombre de un miembro de instancia con nameof . Si una instancia no está disponible fácilmente, se puede obtener una mediante 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