Tipos de valor que aceptan valores NULL

Un Nullable<'T> de valor que acepta valores NULL representa cualquier tipo de estructura que también pueda ser null. Resulta útil al interactuar con bibliotecas y componentes que pueden representar estas clases de tipos, como enteros, con un valor null por motivos de eficiencia. El tipo subyacente que respalda esta construcción es System.Nullable<T>.

Sintaxis

Nullable<'T>
Nullable value

Declaración y asignación con valores

Declarar un tipo de valor que admite un valor NULL es igual que declarar cualquier tipo similar a un contenedor en F#:

open System

let x = 12
let nullableX = Nullable<int> x

También puede evitar el parámetro de tipo genérico y permitir la inferencia de tipos para resolverlo:

open System

let x = 12
let nullableX = Nullable x

Para asignar un tipo de valor que admite un valor NULL, también deberá ser explícito. No hay ninguna conversión implícita para los tipos de valor que admiten un valor NULL definidos por F#:

open System

let mutable x = Nullable 12
x <- Nullable 13

Asignación de null

No puede asignar null directamente a un tipo de valor que admite un valor NULL. Use Nullable() en su lugar:

let mutable a = Nullable 42
a <- Nullable()

Esto se debe a que Nullable<'T> no tiene null como valor adecuado.

Pase y asignación a miembros

Una diferencia clave entre trabajar con miembros y valores de F# es que los tipos de valor que admiten un valor NULL se pueden inferir implícitamente cuando se trabaja con miembros. Considere el siguiente método que toma un tipo de valor que admite un valor NULL como entrada:

type C() =
    member _.M(x: Nullable<int>) = x.HasValue
    member val NVT = Nullable 12 with get, set

let c = C()
c.M(12)
c.NVT <- 12

En el ejemplo anterior, puede pasar 12 al método M. También puede asignar 12 a la propiedad automática NVT. Si la entrada se puede construir como un tipo de valor que admite un valor NULL y coincide con el tipo de destino, el compilador de F# convertirá implícitamente dichas llamadas o asignaciones.

Examen de una instancia de tipo de valor que admite un valor NULL

A diferencia de las opciones, que son una construcción generalizada para representar un valor posible, los tipos de valor que admiten un valor NULL no se usan con la coincidencia de patrones. En su lugar, debe usar una expresión if y comprobar la propiedad HasValue.

Para obtener el valor subyacente, use la propiedad Value después de una comprobación HasValue, de la siguiente manera:

open System

let a = Nullable 42

if a.HasValue then
    printfn $"{a} is {a.Value}"
else
    printfn $"{a} has no value."

Operadores que admiten valores NULL

Las operaciones en tipos de valor que admiten un valor NULL, como la aritmética o la comparación, pueden requerir el uso de operadores que admiten un valor NULL.

Puede convertir un tipo de valor que admite un valor NULL a otro mediante operadores de conversión del espacio de nombres FSharp.Linq:

open System
open FSharp.Linq

let nullableInt = Nullable 10
let nullableFloat = Nullable.float nullableInt

También puede usar un operador que no acepta valores NULL adecuado para convertirlo a un tipo primitivo, lo que supone un riesgo de una excepción si no tiene ningún valor:

open System
open FSharp.Linq

let nullableFloat = Nullable 10.0
let standardFloat = float nullableFloat

printfn $"value is %f{float standardFloat}"

También puede usar operadores que admiten un valor NULL como una manera abreviada de comprobar HasValue y Value:

open System
open FSharp.Linq

let nullableInt = Nullable 10
let nullableFloat = Nullable.float nullableInt

let isBigger = nullableFloat ?> 1.0
let isBiggerLongForm = nullableFloat.HasValue && nullableFloat.Value > 1.0

La comparación ?> comprueba si el lado izquierdo acepta valores NULL y solo se ejecuta correctamente si tiene un valor. Es equivalente a la línea que la sigue.

Consulte también

  • Last updated on